代替函数apply方法：
// ES5 的写法
function f(x, y, z) {
// ...
}
var args = [0, 1, 2];
f.apply(null, args);
// ES6的写法
function f(x, y, z) {
// ...
}
let args = [0, 1, 2];
f(...args);
简化：
// ES5 的写法
Math.max.apply(null, [14, 3, 77])
// ES6 的写法
Math.max(...[14, 3, 77])
// 等同于
Math.max(14, 3, 77);
实例：将数组添加到另一个数组的尾部（push）
// ES5的 写法
var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
Array.prototype.push.apply(arr1, arr2);
// ES6 的写法
let arr1 = [0, 1, 2];
let arr2 = [3, 4, 5];
arr1.push(...arr2);
复制数组：
const a1 = [1, 2];
const a2 = a1;
a2[0] = 2;
a1 // [2, 2]
a2并不是a1的克隆，而是指向同一份数据的另一个指针。修改a2，会直接导致a1的变化。
es5：
const a1 = [1, 2];
const a2 = a1.concat();
a2[0] = 2;
a1 // [1, 2]
a1会返回原数组的克隆，再修改a2就不会对a1产生影响。
简写：
const a1 = [1, 2];
// 写法一
const a2 = [...a1];
// 写法二
const [...a2] = a1;
合并数组：
const arr1 = ['a', 'b'];
const arr2 = ['c'];
const arr3 = ['d', 'e'];
// ES5 的合并数组
arr1.concat(arr2, arr3);
// [ 'a', 'b', 'c', 'd', 'e' ]
// ES6 的合并数组
[...arr1, ...arr2, ...arr3]
// [ 'a', 'b', 'c', 'd', 'e' ]
（浅拷贝）
map和set结构： map结构：
let map = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
let arr = [...map.keys()]; // [1, 2, 3]
keys()代表k，values()代表v。
Array.from：（转数组）：
Array.from('hello')
// ['h', 'e', 'l', 'l', 'o']
注：扩展运算符（
...）也可以将某些数据结构转为数组。
// arguments对象
function foo() {
const args = [...arguments];
}
// NodeList对象
[...document.querySelectorAll('div')]
array.from参数：
Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);
Array.from([1, 2, 3], (x) => x * x)
// [1, 4, 9]
Array.from({ length: 2 }, () => 'jack')
// ['jack', 'jack']
array.of()：
Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1
Array.of()方法用于将一组值，转换为数组
Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]
没有参数、一个参数、三个参数时，返回的结果都不一样。
copyWithin()：
Array.prototype.copyWithin(target, start = 0, end = this.length)
3个参数：
- target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
- start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。
- end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。
（注：这三个参数都应该是数值，如果不是，会自动转为数值。）
// 将3号位复制到0号位
[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
// [4, 2, 3, 4, 5]
// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]
// 将3号位复制到0号位
[].copyWithin.call({length: 5, 3: 1}, 0, 3)
// {0: 1, 3: 1, length: 5}
// 将2号位到数组结束，复制到0号位
let i32a = new Int32Array([1, 2, 3, 4, 5]);
i32a.copyWithin(0, 2);
// Int32Array [3, 4, 5, 4, 5]
// 对于没有部署 TypedArray 的 copyWithin 方法的平台
// 需要采用下面的写法
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
// Int32Array [4, 2, 3, 4, 5]
查找数组：find()和findIndex():
数组实例的
find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。
小于0的数：
[1, 4, -5, 10].find((n) => n < 0)
// -5
[1, 5, 10, 15].find(function(value, index, arr) {
return value > 9;
}) // 10
三个参数 ：当前的值、当前的位置和原数组。 findIndex： 数组实例的
findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。
[1, 5, 10, 15].findIndex(function(value, index, arr) {
return value > 9;
}) // 2
fill():
fill方法使用给定值，填充一个数组。
['a', 'b', 'c'].fill(7)
// [7, 7, 7]
new Array(3).fill(7)
// [7, 7, 7]
接受参数：用于指定填充的起始位置和结束位置
['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']
遍历数组：forof
let obj={
name:"张三",
age:18,
addr:"郑州"
}
// 遍历 keys()
for (const item of Object.keys(obj)) {
console.log(item)
}
// 属性值 values()
for (const item of Object.values(obj)) {
console.log(item)
}
// 键值对 属性值 entries()
for (const [k,v] of Object.entries(obj)) {
console.log(k,v)
}
// 合并对象 Object.assign()
let obj2={
name:"李四",
age:18,
sex:"男"
}
Object.assign(obj,obj2);
console.log(obj);
// {name: "李四", age: 18, addr: "郑州", sex: "男"} obj2覆盖obj1
数组扁平化：flat()
// 57 完成一个函数,接受数组作为参数,数组元素为整数或者数组,数组元素包含整
// 数或数组,函数返回扁平化后的数组
var arr=[1,[2,[[3,4],5],6]];
var r=[];
// 写一个function 传入两个参数，一个是数组，一个作返回值
function flat(arr,r){
// 写一个for循环 遍历数组
for(var i=0;i<arr.length;i++){
// 对数组中的每一项进行判断
if(typeof arr[i]==="number"){
// 如果数据类型是数值型 添加给返回值
r.push(arr[i]);
}else{
// 如果不是数值型 再次执行function
flat(arr[i],r);
}
}
}
flat(arr,r);
console.log(r);
promise对象：
简单判断案例（Promise）：
function f1(s,e){
//...
let val=Math.random(); //随机数
// console.log(val);
return new Promise(function(resolve,reject){
if(val>=0.5){
resolve("val>0.5"+val);
// 穿多个值 用{}
}else{
reject("val<0.5"+val)
}
});
}
f1().then(function(val){
// 成功
console.log(val);
}).catch(function(error){
//失败
console.log(error);
})
（resolve，reject两个对象分别对照成功（then）和失败（catch））
异步：
//异步
function timeout(ms) {
return new Promise((resolve, reject) => {
setTimeout(resolve, ms, 'done');
});
}
timeout(1000).then((value) => {
console.log(value);
});
//1000毫秒以后运行
console.log(0); //直接运行
//0
//done 1000毫秒以后显示
