ES6中新增的数组方法

ES6在数组中新增了以下几种方法：

Array.from()
Array.of()
Array.at()
find()与findIndex()
fill()
entries()，keys() 和 values()
includes()
flat()与flatMap()

Array.from() 用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组；

const arr1 = {
    "0": "Apple",
    "1": "Lemon",
    "2": "Banana",
    length: 3
};
const arr2 = Array.from(arr1);
console.log('arr2', arr2) // ['Apple', 'Lemon', 'Banana']
//Array.from还可以接受第二个参数，作用类似于数组的map方法
const map = Array.from(arr1, x => x.length);
console.log(map); //  [5,5,6]
//用法：1、数组去重;
const arr3 = ['Apple', 'Lemon', 'Banana', 'Apple']
const arr4 = Array.from(new Set(arr3));
console.log('arr4', arr4) // ['Apple', 'Lemon', 'Banana']

Array.of()  用于将一组值转换为数组；

//of() 方法用于将一组值转换为数组，不考虑参数的数量或类型。
//Array.of() 和 Array() 构造函数之间的区别在于对单个参数的处理：
// Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个 length 为 7 的空数组。
const arr1 = {
    "0": "Apple",
};
const arr2 = Array.of(arr1);
console.log('arr2', arr2) // [{ 0: "Apple",}]

Array.at()  接收一个整数值并返回该索引对应的元素；

//接收一个整数值并返回该索引对应的元素，允许正数和负数。负整数从数组中的最后一个元素开始倒数。
const arr1 = ['apple', 'banana', 'pear'];
const arr2 = arr1.at(-3);
console.log('arr2', arr2) // apple

entries()，keys()和 values()；用于遍历数组,可以用 for...of 循环进行遍历，唯一的区别是： keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历；

//entries()，keys()和 values()；
// 用于遍历数组,可以用 for...of 循环进行遍历，唯一的区别是：
// keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历；
const arr1 = ['apple', 'banana', 'pear'];
for (const [index, ele] of arr1.entries()) {
    console.log(index, ele);
    //0 'apple'
    //1 'banana'
    //2 'pear'
}
for (const index of arr1.keys()) {
    console.log(index);
    //0
    //1
    //2
}
for (const ele of arr1.values()) {
    console.log(ele);
    //apple
    //banana
    //pear
}
const x = [...arr1.keys()];
console.log('x', x) //[0, 1, 2]
const y = [...arr1.values()];
console.log('y', y) //['apple', 'banana', 'pear']
const z = [...arr1.entries()];
console.log('z', z) //[[0, 'apple'],[1, 'banana'],[2, 'pear']]

includes() 用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false；

const arr1 = ['apple', 'banana', 'pear'];
const y = arr1.includes('banana')
console.log('y', y) //true

flat() 方法返回一个包含将数组与子数组中所有元素的新数组；
flatMap() 方法返回一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为 1。

//flat() 方法会按照一个可指定的深度递归遍历数组，
// 并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
//flat() 方法返回一个包含将数组与子数组中所有元素的新数组
const arr1 = ['apple', 'banana', ['apple', ['pear', 'apricot']]];
const x = arr1.flat();
const y = arr1.flat(2)
console.log('x', x); //['apple', 'banana', 'apple', ['pear', 'apricot']]
console.log('y', y); //['apple', 'banana', 'apple', 'pear', 'apricot']
//flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。
// 它与 map 连着深度值为 1 的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。
//flatMap() 方法返回一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为 1。
const z = arr1.flatMap(x => x.length);
console.log('z', z); //[5, 6, 2]
const arr2 = ["it's Sunny in", "", "California"];
const w = arr2.flatMap(x => x.split(' '));
console.log('w', w) //["it's", 'Sunny', 'in', '', 'California']