ES6数组新方法归纳

ES6（ECMAScript 2015）引入了许多新的数组方法，以下是一些常见的 ES6 数组方法：

1. Array.from()：将类似数组或可迭代对象转换为真正的数组。
2. Array.of()：根据传入的参数创建一个新数组。
3. Array.find()：查找满足条件的第一个元素，并返回该元素。
4. Array.findIndex()：查找满足条件的第一个元素，并返回该元素的索引。
5. Array.includes()：判断数组是否包含指定的元素，返回布尔值。
6. Array.fill()：用静态值填充数组的所有元素。
7. Array.copyWithin()：将数组中的一部分元素复制到指定位置。
8. Array.keys()：返回一个新的 Array Iterator 对象，包含数组中每个索引的键。
9. Array.values()：返回一个新的 Array Iterator 对象，包含数组中每个索引的值。
10. Array.entries()：返回一个新的 Array Iterator 对象，包含数组中每个索引的键/值对。
11. Array.flat()：将嵌套的子数组扁平化为单层数组。
12. Array.flatMap()：先使用映射函数对每个元素进行映射，然后将结果扁平化为单层数组。
13. Array.filter()：过滤数组中的元素，返回满足条件的新数组。
14. Array.map()：对数组中的每个元素进行操作，返回新数组。
15. Array.reduce()：将数组中的元素累积为一个值。
16. Array.reduceRight()：从数组的末尾向前累积元素为一个值。
17. Array.every()：检查数组中的所有元素是否都满足指定条件，如果都满足返回 true。
18. Array.some()：检查数组中是否至少有一个元素满足指定条件，如果有则返回 true。
19. Array.sort()：对数组元素进行排序。
20. Array.reverse()：反转数组中元素的顺序。

下面是具体的示例：

1. Array.from()：将类似数组或可迭代对象转换为真正的数组。
    

   const str = 'hello';
   const arr = Array.from(str);
   console.log(arr); // ['h', 'e', 'l', 'l', 'o']

2. Array.of()：根据传入的参数创建一个新数组。
    

   const arr = Array.of(1, 2, 3, 4, 5);
   console.log(arr); // [1, 2, 3, 4, 5]

3. Array.find()：查找满足条件的第一个元素，并返回该元素。
    

   const numbers = [1, 2, 3, 4, 5];
   const greaterThanThree = numbers.find(num => num > 3);
   console.log(greaterThanThree); // 4

4. Array.findIndex()：查找满足条件的第一个元素，并返回该元素的索引。
    

   const numbers = [1, 2, 3, 4, 5];
   const index = numbers.findIndex(num => num === 3);
   console.log(index); // 2

5. Array.includes()：判断数组是否包含指定的元素，返回布尔值。
    

   const numbers = [1, 2, 3, 4, 5];
   const includesThree = numbers.includes(3);
   console.log(includesThree); // true

6. Array.fill()：用静态值填充数组的所有元素。
    

   const numbers = [1, 2, 3, 4, 5];
   numbers.fill(0, 2, 4);
   console.log(numbers); // [1, 2, 0, 0, 5]

7. Array.copyWithin()：将数组中的一部分元素复制到指定位置。
    

   const numbers = [1, 2, 3, 4, 5];
   numbers.copyWithin(0, 3);
   console.log(numbers); // [4, 5, 3, 4, 5]

8. Array.keys()：返回一个新的 Array Iterator 对象，包含数组中每个索引的键。
    

   const numbers = [10, 20, 30];
   const keys = numbers.keys();
   for (const key of keys) {
     console.log(key); // 0, 1, 2
   }

9. Array.values()：返回一个新的 Array Iterator 对象，包含数组中每个索引的值。
    

   const numbers = [10, 20, 30];
   const values = numbers.values();
   for (const value of values) {
     console.log(value); // 10, 20, 30
   }

10. Array.entries()：返回一个新的 Array Iterator 对象，包含数组中每个索引的键/值对。
     

    const numbers = [10, 20, 30];
    const entries = numbers.entries();
    for (const entry of entries) {
      console.log(entry); // [0, 10], [1, 20], [2, 30]
    }

11. Array.flat()：将嵌套的子数组扁平化为单层数组。
     

    const nestedArray = [1, [2, [3, [4]]]];
    const flattenedArray = nestedArray.flat(Infinity);
    console.log(flattenedArray); // [1, 2, 3, 4]

12. Array.flatMap()：先使用映射函数对每个元素进行映射，然后将结果扁平化为单层数组。
     

    const numbers = [1, 2, 3];
    const doubledArray = numbers.flatMap(num => [num, num * 2]);
    console.log(doubledArray); // [1, 2, 2, 4, 3, 6]

13. Array.filter()：过滤数组中的元素，返回满足条件的新数组。
     

    const numbers = [1, 2, 3, 4, 5];
    const evenNumbers = numbers.filter(num => num % 2 === 0);
    console.log(evenNumbers); // [2, 4]

14. Array.map()：对数组中的每个元素进行操作，返回新数组。
     

    const numbers = [1, 2, 3];
    const squaredNumbers = numbers.map(num => num ** 2);
    console.log(squaredNumbers); // [1, 4, 9]

15. Array.reduce()：将数组中的元素累积为一个值。
     

    const numbers = [1, 2, 3, 4, 5];
    const sum = numbers.reduce((acc, curr) => acc + curr, 0);
    console.log(sum); // 15

16. Array.reduceRight()：从数组的末尾向前累积元素为一个值。
     

    const numbers = [1, 2, 3, 4, 5];
    const concatenatedString = numbers.reduceRight((acc, curr) => acc + curr.toString(), '');
    console.log(concatenatedString); // "54321"

17. Array.every()：检查数组中的所有元素是否都满足指定条件，如果都满足返回 true。
     

    const numbers = [2, 4, 6, 8, 10];
    const allEven = numbers.every(num => num % 2 === 0);
    console.log(allEven); // true
    
    const numbers2 = [1, 2, 3, 4, 5];
    const allEven2 = numbers2.every(num => num % 2 === 0);
    console.log(allEven2); // false

18. Array.some()：检查数组中是否至少有一个元素满足指定条件，如果有则返回 true。
     

    const numbers = [1, 3, 5, 7, 9];
    const hasEven = numbers.some(num => num % 2 === 0);
    console.log(hasEven); // false
    
    const numbers2 = [1, 2, 3, 4, 5];
    const hasEven2 = numbers2.some(num => num % 2 === 0);
    console.log(hasEven2); // true

19. Array.sort()：对数组元素进行排序。
     

    const fruits = ['apple', 'orange', 'banana', 'grape'];
    fruits.sort();
    console.log(fruits); // ['apple', 'banana', 'grape', 'orange']
    
    const numbers = [10, 2, 8, 4, 6];
    numbers.sort((a, b) => a - b);
    console.log(numbers); // [2, 4, 6, 8, 10]

20. Array.reverse()：反转数组中元素的顺序。
     

    const numbers = [1, 2, 3, 4, 5];
    numbers.reverse();
    console.log(numbers); // [5, 4, 3, 2, 1]
    
    const letters = ['a', 'b', 'c', 'd', 'e'];
    letters.reverse();
    console.log(letters); // ['e', 'd', 'c', 'b', 'a']

这些是 ES6 引入的一些主要的数组方法。它们提供了更便捷、简洁、功能丰富的操作数组的方式。请注意，某些方法可能需要使用 Polyfill 或构建工具来支持旧版本的浏览器。