js高级02

forEach（）

forEach 循环执行次数 ， 跟数组内个数 相关

是数组提供的方法 可以遍历数组  替代了 for 循环

let arr = [10, 20, 30, 40, 50];
arr.filter(function play(a) {
    console.log(a);
})

forEach() 遍历对象

• 遍历对象方法: 结构

• 函数形参可以任意 起名称

对象名.forEach(function (定义对象) {
       console.log(定义对象);
   })

利用字面量创建对象

const o = {
name: '佩奇',
}

利用new Object 创建对象

const one = new Object({ name: '佩奇' })
console.log(one);

 构造函数创建对象

• new 关键字调用函数的行为被称为 实例化

 function Pig(name, age, gender) {
     this.name = name //佩奇
     this.age = age // 18
     this.gender = gender //男
 }
 const res = new Pig('佩奇', 18, '男')
 console.log(res);

实列成员

• 构造函数创建的对象称为实列对象，实列对象中的属性和方法称为实列成员

实列成员只能调用实列对象

// 实列成员
function play(name, age) {
    this.name = name
    this.age = age
    this.sayHi = function () {
        console.log(`大家好`);
    }
};
//静态成员
play.gender = '男';
play.eat = function () {
    console.log(`你也好`);
}

实列对象调用

let red = new play('张三', 18)
console.log(red.name, red.age, red.
sayHi); //实列
console.log(red.gender, red.eat); // 静态

静态成员

• 构造函数的属性和方法称为静态成员

• 静态成员方法中的this指向构造函数本身

静态成员 只能构造函数调用

构造函数调用

console.log(play.gender, play.eat); // 静态
console.log(play.name, play.age, play.
sayHi); // 实列

基本类型

• 基本类型称为简单类型 ， string number boolean undefind

复杂类型  包装类型 引用类型

包装类型: String , Number , Boolean

引用类型 : Array , Object ， Date

object.keys(对象名)  //访问对象 属性名

•    获取对象中所有 属性名

返回的是一个数组

const obj = {
    name: '佩奇',
    age: 16
}
console.log(Object.keys(obj));

Object.values（对象名） //访问对象 属性值

• 获取对象中所有 属性值

返回的是一个数组

const obj = {
    name: '佩奇',
    age: 16
}
console.log(Object.values(obj));

Object.assign(被覆盖对象名,覆盖对象名)

• 当a对象和b对象内属性名相同时 使用 Object.assign可以让a对象内属性值 覆盖掉对方

 const x = { name: `张三`, age: 18, gender: `男` }
 const y = { name: '刘备', age: 20, gender: `女` }
 Object.assign(y, x)
 console.log(x);
 console.log(y);

reduce 数组求和

• 数组名.reduce(function (累计值,当前元素 ) { } ,起始值)

 let arr = [111, 222, 333, 444]
 let one = arr.reduce((a, b) => {
     return a + b
 }, 0)
 console.log(one);

reduce 对象求和

• 对象名.reduce(function (累计值,当前元素 ) { } ,起始值)

let arr1 = [
    { name: `张三`, num: 11 },
    { name: '李四', num: 22 },
    { name: '王五', num: 33 }
]
let one1 = arr.reduce((prev, item) => {
    return prev + item.num // 对象内数字属性
}, 0)
console.log(one1);

数组方法

join（）  数组中元素 连接一个字符串

concat( )  连接两个数组

sort( )  数组中元素排序

reverse 反转数组

splice（） 删除数组中的元素

join（） 

• join() 数组中的元素 连接成一个字符串

 let one = [11, 22, 33, 44]
 console.log(one.join());

concat( )

•   连接两个数组

let one1 = [1, 2, 3]
let one2 = ['a', 'b', 'c']
console.log(one1.concat(one2));

sort( ) 

• 数组中元素排序

let one = [33, 22, 44, 11]
console.log(one.sort());

reverse

• 反转数组

 let one = [11, 22, 33, 44]
 console.log(one.reverse());

splice（索引,个数 ）

• 删除数组中的元素 

• 索引指: 数组下标

• 个数: 从自身位置开始向后删除多少个

 let one = [11, 22, 33, 44]
 one.splice(2, 1)
 console.log(one);

 // 1. find() 根据条件查找第一个满足条件的元素;
 //    find()和filter()的区别，就是一个返回第一个，另一个返回所有;
 console.log([111, 222, 333, 444].filter(item => item % 2 == 0));
 console.log([111, 222, 333, 444].find(item => item % 2 == 0));
 // 2. findIndex() 根据条件查找第一个满足条件的元素的索引值;
 console.log([111, 222, 333, 444].findIndex(item => item % 2 == 0));
 // 3. every() 是否每一项都满足条件; 有一项不满足就返回false
 console.log([222, 444, 666].every(item => item % 2 == 0));
 // 4. some() 是否存在一项满足条件; 有一项满足就返回true
 console.log([111, 333, 555].some(item => item % 2 == 0));

Array.from（） 

• 伪数组转换数组  

let divs = document.querySelectorAll(`div`) // 伪数组
let arr = Array.from(divs) // 转换真实数组
console.log(arr); 

startsWith( )    是否以某个字符串开始

endsWith()      是否以某个字符串结束

replace（）     替换

match( )           匹配 

startsWith( )  

• 是否以某个字符串为开始

console.log('abcdef'.startsWith('abc'));

endsWith()

• 是否以某个字符串结束

console.log('abcdef'.endsWith('def'));

replace（）

• 替换

console.log('abcdef'.replace('cd', '123'));

match( )   

• 匹配

console.log('aaabbbccc'.match(/bbb/));

slice（ 开始索引，结束索引）  截字符串 - 数组也支持

split（）   字符串切割为数组

toUpperCase（）              转换大写

toLowerCase( )                 转换小写

slice（ 开始索引，结束索引）

• 传递的参数如果是负值，就从后往前截取;

split（）   

• 字符串 切割为数组

const gift = `50g茶叶,清洁球,洗洁灵,奥迪A6`
let arr = gift.split(`,`)
console.log(arr);

toUpperCase（） 

• 转换大写

console.log('abcdef'.toUpperCase());

toLowerCase（）

• 转换小写

console.log('AAAAA'.toLowerCase());

toFixed(2) 

• 对象名.toFixed(2) 

(2)  // 括号里面写2就保留 2 位有效数字

 console.log((100).toFixed(2));

（2）括号里面2 表示保留 0. 后面的两位数

 console.log(0.30000000000000004.toFixed(2));

toString()

• 对象名.toString()   

转字符串

  let all = [111, 222, 333, 444]
  console.log(all.toString());