JS数组方法

一、改变数组内容的方法

1、push(): 向数组的末尾添加一个或多个元素，并返回新的长度。

let arr = [1,2,3]
arr.push(4);  // 在数组末尾添加元素 4
console.log(arr); // [1, 2, 3, 4]

2、pop(): 删除并返回数组的最后一个元素。

let arr = [1,2,3]
let lastValue = arr.pop(); // 删除并返回数组最后一个元素
console.log(arr); // 输出 [1,2]
console.log(lastValue); // 输出 3

3、shift(): 删除并返回数组的第一个元素。

let arr = [1,2,3]
let firstValue = arr.shift(); // 删除并返回数组第一个元素
console.log(arr); // 输出 [2, 3]
console.log(firstElement); // 输出 1

4、unshift(): 向数组的开头添加一个或多个元素，并返回新的长度。

let arr = [1, 2, 3];
arr.unshift(0); // 在数组开头添加元素 0
console.log(arr); // 输出 [0, 1, 2, 3]

5、splice(): 通过删除现有元素和/或添加新元素来更改一个数组的内容。

let arr = [1, 2, 3, 4, 5];
let val = arr.splice(2, 1); // 从索引 2 开始，删除 1 个元素
console.log(arr); // 输出 [1, 2, 4, 5]
console.log(val); // 输出 [3]
arr.splice(2, 0, 'a'); // 从索引 2 开始，删除 0 个元素, 并添加 'a'
console.log(arr); // 输出 [1, 2, 'a', 4, 5]

6、sort(): 对数组的元素进行排序。

let arr = [5, 2, 8, 1, 4];
arr.sort(function(a, b) {
  return a - b; // 升序排序
});
console.log(arr); // 输出 [1, 2, 4, 5, 8]

7、reverse():颠倒数组中元素的顺序。

let arr = [1, 2, 3, 4, 5];
arr.reverse(); // 颠倒数组元素顺序
console.log(arr); // 输出 [5, 4, 3, 2, 1]

二、查询数组信息的方法

1、length:返回数组的长度。

let arr = [1, 2, 3];
console.log(arr.length); // 输出 3

2、indexOf(): 返回在数组中可以找到给定元素的第一个索引，如果不存在，则返回-1。

let arr = [1, 2, 3, 2, 1];
let index = arr.indexOf(2); // 查找元素 2 第一次出现的索引
console.log(index); // 输出 1

3、lastIndexOf(): 返回在数组中可以找到给定元素的最后一个索引，如果不存在，则返回-1。

let arr = [1, 2, 3, 2, 1];
let lastIndex = arr.lastIndexOf(2); // 查找元素 2 最后一次出现的索引
console.log(lastIndex); // 输出 3

4、concat(): 用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let arr3 = arr1.concat(arr2); // 合并两个数组
console.log(arr3); // 输出 [1, 2, 3, 4, 5, 6]

5、slice(): 返回一个新的数组对象，这一对象是一个由开始到结束（不包括结束）选择的、由原数组的浅拷贝构成。原始数组不会被改变。

let arr = [1, 2, 3, 4, 5];
let slicedArr = arr.slice(1, 3); // 从索引 1 到索引 2（不包含 3）的元素
console.log(slicedArr); // 输出 [2, 3]

6、join(): 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。

let arr = [1, 2, 3];
let joinedStr = arr.join('-'); // 用 '-' 连接数组元素
console.log(joinedStr); // 输出 "1-2-3"

三、数组迭代方法

1、forEach():对数组的每个元素执行一次提供的函数。

let arr = [1, 2, 3];
arr.forEach(function(element) {
  console.log(element); // 输出数组每个元素
});
console.log(arr); // 输出数组每个元素

2、map(): 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后的返回值。

let array = [1, 2, 3, 4, 5];
let newArray = array.map(function(element) {
  return element * 2; // 返回每个元素的两倍
});
console.log(newArray); // 输出 [2, 4, 6, 8, 10]

3、filter(): 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let newArray = array.filter(function(element) {
  return element % 2 === 0; // 返回所有偶数
});
console.log(newArray); // 输出 [2, 4, 6, 8, 10]

4、some(): 测试数组中是否有某些元素通过由提供的函数实现的测试。

let array = [1, 2, 3, 4, 5];
let hasEven = array.some(function(element) {
  return element % 2 === 0; // 测试是否有偶数
});
console.log(hasEven); // 输出 true

5、every(): 测试数组的所有元素是否都通过由提供的函数实现的测试。

let array = [1, 2, 3, 4, 5];
let areAllPositive = array.every(function(element) {
  return element > 0; // 测试所有元素是否都大于0
});
console.log(areAllPositive); // 输出 true

6、find(): 返回数组中满足提供的测试函数的第一个元素。否则返回 undefined。

let array = [1, 2, 3, 4, 5];
let found = array.find(function(element) {
  return element > 3; // 找到第一个大于3的元素
});
console.log(found); // 输出 4

7、findIndex(): 返回数组中满足提供的测试函数的第一个元素的索引。否则返回 -1。

let array = [1, 2, 3, 4, 5];
let index = array.findIndex(function(element) {
  return element > 3; // 找到第一个大于3的元素的索引
});
console.log(index); // 输出 3

8、reduce(): 对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个输出值。

let array = [1, 2, 3, 4, 5];
let sum = array.reduce(function(accumulator, currentValue) {
  return accumulator + currentValue; // 计算所有元素的总和
}, 0);
console.log(sum); // 输出 15

9、reduceRight(): 同 reduce()，但是从右到左应用函数。

let arr = [1, 2, 3, 4, 5];
let product = arr.reduceRight((accumulator, currentValue) => accumulator * currentValue, 1);
console.log(product); // 输出 120

四、ES6 新增方法

1、includes(): 判断一个数组是否包含一个指定的值，根据情况，如果返回 true，则元素在原数组中的索引值会被返回。

let array = [1, 2, 3, 4, 5];
console.log(array.includes(3)); // 输出: true
console.log(array.includes(6)); // 输出: false
console.log(array.includes(3, 3));  // 输出: false（从索引 3 开始搜索，找不到）

2、flat(): 用于将嵌套的数组“拉平”，变成一维的数组。

lat nestedArray = [1, [2, [3, [4, 5]]]];

// 展开一层
let flattenedOnce = nestedArray.flat();
console.log(flattenedOnce); // 输出: [1, 2, [3, [4, 5]]]

// 完全展开
let flattenedCompletely = nestedArray.flat(Infinity);
console.log(flattenedCompletely); // 输出: [1, 2, 3, [4, 5]]

// 指定深度为 2
let flattenedToDepth2 = nestedArray.flat(2);
console.log(flattenedToDepth2); // 输出: [1, 2, 3, 4, 5]

3、flatMap(): 首先使用映射函数映射每个元素，然后将结果展平到一个新数组中。它相当于对数组的每个元素先调用一个映射函数，然后再将结果展平。

let numbers = [1, 2, 3];
let roots = numbers.flatMap(x => [x, x * x]);
console.log(roots); // 输出: [1, 1, 2, 4, 3, 9]

4、copyWithin(): 在数组内部浅复制元素到另一个位置，并返回它（数组本身），不改变其大小。

let array = [1, 2, 3, 4, 5];
array.copyWithin(0, 3);
console.log(array);     // 输出: [4, 5, 3, 4, 5]

5、from(): 从一个类似数组或可迭代的对象创建一个新的数组实例。

let arrayLike = { length: 3, 0: 'a', 1: 'b', 2: 'c' };
let arr = Array.from(arrayLike);
console.log(arr);                    // 输出: ['a', 'b', 'c']

6、toString(): 返回数组的字符串表示形式。

let array = [1, 2, 3];
let string = array.toString();
console.log(string); // 输出: "1,2,3"