JavaScript的数组方法

JavaScript中的数组是高阶的、灵活的数据结构，提供了许多内置方法来操作数组。以下是一些常用的数组方法：

1. 数组的添加、删除和替换方法：

• push(...items)：向数组末尾添加一个或多个元素，并返回新的长度。
• pop()：移除数组的最后一个元素，并返回被移除的元素。
• unshift(...items)：向数组开头添加一个或多个元素，并返回新的长度。
• shift()：移除数组的第一个元素，并返回被移除的元素。
• splice(index, deleteCount, ...items)：添加或删除数组元素，返回被删除的元素数组。
• fill(value, start, end)：用一个固定值填充数组的一部分。

• let fruits = ['apple', 'banana', 'mango'];
  
  // 添加元素到数组尾部
  fruits.push('orange'); // ['apple', 'banana', 'mango', 'orange']
  
  // 删除最后一个元素
  let lastFruit = fruits.pop(); // 'orange'
  
  // 添加到数组开头
  fruits.unshift('grape'); // ['grape', 'apple', 'banana', 'mango']
  
  // 删除第一个元素
  let firstFruit = fruits.shift(); // 'grape'
  
  // 替换和添加元素
  fruits.splice(1, 1, 'cherry'); // ['grape', 'cherry', 'mango']
  
  // 填充数组
  fruits.fill('berry', 1, 3); // ['grape', 'berry', 'berry', 'berry']

2. 数组的排序方法：

• sort(compareFunction)：对数组元素进行排序，默认按照字符串的Unicode点进行排序，可以提供一个比较函数来自定义排序逻辑。

• let numbers = [10, 5, 8, 2];
  
  // 默认排序
  numbers.sort(); // [2, 5, 8, 10]
  
  // 自定义排序
  numbers.sort((a, b) => b - a); // [10, 8, 5, 2]

3. 数组的迭代方法：

• forEach(callback, thisArg)：对数组中的每个元素执行一次提供的函数。
• map(callback, thisArg)：创建一个新数组，其元素是调用 callback 函数时的结果。
• filter(callback, thisArg)：创建一个新数组，包含通过 callback 函数测试的所有元素。
• reduce(callback, initialValue)：将数组元素累加到一个单一的值。
• reduceRight(callback, initialValue)：与 reduce 类似，但是累加的方向是从右到左。

• let arr = [1, 2, 3, 4];
  
  // forEach
  arr.forEach((item, index) => {
    console.log(`Index: ${index}, Value: ${item}`);
  });
  
  // map
  let squared = arr.map(item => item * item); // [1, 4, 9, 16]
  
  // filter
  let even = arr.filter(item => item % 2 === 0); // [2, 4]
  
  // reduce
  let sum = arr.reduce((acc, item) => acc + item, 0); // 10
  
  // reduceRight
  let product = arr.reduceRight((acc, item) => acc * item, 1); // 24

4. 数组的位置查询方法：

• indexOf(searchElement, fromIndex)：返回在数组中可以找到给定元素的第一个索引，如果不存在，则返回-1。
• lastIndexOf(searchElement, fromIndex)：返回在数组中可以找到给定元素的最后一个索引。

• let fruits = ['apple', 'banana', 'mango', 'kiwi'];
  
  // indexOf
  let index = fruits.indexOf('mango'); // 2
  
  // lastIndexOf
  let lastIndex = fruits.lastIndexOf('banana'); // 1

5. 数组的连接和切片方法：

• concat(...items)：合并两个或多个数组，返回一个新数组。
• slice(start, end)：返回一个新数组，包含从开始到结束（不包括结束）的数组的一部分。

• let fruits1 = ['apple', 'banana'];
  let fruits2 = ['mango', 'orange'];
  
  // concat
  let combined = fruits1.concat(fruits2); // ['apple', 'banana', 'mango', 'orange']
  
  // slice
  let part = fruits1.slice(1); // ['banana']

6. 数组的查找方法：

• find(callback, thisArg)：返回数组中满足提供的测试函数的第一个元素的值，如果没有找到，则返回undefined。
• findIndex(callback, thisArg)：返回数组中满足提供的测试函数的第一个元素的索引，如果没有找到，则返回-1。

• let users = [
    { name: 'Alice', age: 21 },
    { name: 'Bob', age: 25 },
    { name: 'Charlie', age: 30 }
  ];
  
  // find
  let user = users.find(user => user.age > 24); // { name: 'Bob', age: 25 }
  
  // findIndex
  let index = users.findIndex(user => user.name === 'Charlie'); // 2

7. 数组的填充方法：

• fill(value, start, end)：用一个固定值填充数组的一部分，从start索引到end索引（不包括end）。

• let arr = [1, 2, 3, 4, 5];
  
  // 使用fill方法填充数组
  arr.fill(0, 2, 4); // 从索引2开始到索引4（不包括4），将元素填充为0
  console.log(arr); // [1, 2, 0, 0, 5]

8. 数组的扁平化和展开方法：

• flat()：创建一个新数组，所有子数组都被扁平化到一个深度。
• flatMap(callback, thisArg)：首先使用 map 的回调函数映射每个元素，然后将结果扁平化到一个深度。

• let nestedArray = [1, [2, [3, [4]]], 5];
  
  // flat
  let flatArray = nestedArray.flat(2); // [1, 2, [3, [4]], 5]
  
  // flatMap
  let flatMapped = nestedArray.flatMap(item => [item, item * 2]); // [1, 2, 2, 4, 5, 10]

9. 数组的统计方法：

• some(callback, thisArg)：如果数组中至少有一个元素满足测试，则返回true。
• every(callback, thisArg)：如果数组中的所有元素都满足测试，则返回true。

• let scores = [90, 85, 70, 95, 80];
  
  // some
  let somePass = scores.some(score => score >= 60); // true
  
  // every
  let allPass = scores.every(score => score >= 60); // true

这些方法提供了对数组进行操作的强大工具集，使得处理数据变得更加灵活和高效。