JavaScript 数组方法总结

- 创建数组
- 访问和修改数组（长度＆元素）
- 添加和删除元素
- 数组遍历
- 元素查找
- 过滤和映射
- 归并和缩减
- 数组的连接
- 数组的扁平化
- 数组的排序
- 数组的反转
- 数组的复制
- 数组的测试
- 数组的填充

创建数组

Array.of(...elements): 创建一个包含所有传入参数的新数组。

Array.from(arrayLike, mapFn, thisArg): 从类数组对象或可迭代对象创建一个新数组。

let arr = Array.of(1, 2, 3); // [1, 2, 3]let arr = Array.from('hello'); // ['h', 'e', 'l', 'l', 'o']

访问和修改数组（长度＆元素）

arr.length: 获取或设置数组的长度。

arr[index]: 访问或修改数组指定位置的元素。

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

添加和删除元素

arr.push(...elements): 向数组末尾添加一个或多个元素，返回新的长度。
arr.pop(): 删除并返回数组的最后一个元素。
arr.unshift(...elements): 向数组开头添加一个或多个元素，返回新的长度。

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

let arr = [1, 2];
arr.push(3, 4); // [1, 2, 3, 4]let arr = [1, 2, 3];
let last = arr.pop(); // 3
console.log(arr); // [1, 2]let arr = [1, 2];
arr.unshift(0); // [0, 1, 2]let arr = [1, 2, 3];
let first = arr.shift(); // 1
console.log(arr); // [2, 3]

arr.splice(start, deleteCount, ...items): 从数组中删除或添加元素。
```
let arr = [1, 2, 3];
arr.splice(1, 1, 'a'); // [1, 'a', 3]
```

数组遍历

arr.forEach(callback, thisArg): 对数组的每个元素执行一次提供的函数

let arr = [1, 2, 3];
arr.forEach((item, index) => {console.log(index, item);
});

元素查找

arr.indexOf(searchElement, fromIndex): 返回数组中第一次找到的指定元素的索引，没有则返回 -1。
arr.lastIndexOf(searchElement, fromIndex): 返回数组中最后一次找到的指定元素的索引，没有则返回 -1。

arr.includes(searchElement, fromIndex): 判断数组是否包含指定的元素。

let arr = [1, 2, 3];
arr.indexOf(2); // 1let arr = [1, 2, 3, 2];
arr.lastIndexOf(2); // 3let arr = [1, 2, 3];
arr.includes(2); // true

arr.find(callback, thisArg): 返回数组中满足提供的测试函数的第一个元素的值。

arr.findIndex(callback, thisArg): 返回数组中满足提供的测试函数的第一个元素的索引。

let arr = [1, 2, 3];
let found = arr.find(item => item > 1); // 2let arr = [1, 2, 3];
let index = arr.findIndex(item => item > 1); // 1

过滤和映射

arr.filter(callback, thisArg): 创建一个新数组，其中包含所有通过提供函数实现的测试的元素。

arr.map(callback, thisArg): 创建一个新数组，其中每个元素是对原数组中的每个元素调用一个提供函数后的返回值。

let arr = [1, 2, 3];
let filtered = arr.filter(item => item > 1); // [2, 3]let arr = [1, 2, 3];
let mapped = arr.map(item => item * 2); // [2, 4, 6]

归并和缩减

arr.reduce(callback, initialValue): 对数组中的每个元素执行一个由您提供的 reducer 函数（升序执行），将其结果汇总为单个返回值。

arr.reduceRight(callback, initialValue): 与 reduce 类似，但从右到左执行。

let arr = [1, 2, 3];
let sum = arr.reduce((acc, item) => acc + item, 0); // 6let arr = [1, 2, 3];
let sum = arr.reduceRight((acc, item) => acc + item, 0); // 6

数组的连接

arr.concat(...arrays): 合并两个或多个数组，不改变现有数组，返回一个新数组。

arr.join(separator): 将数组的所有元素连接成一个字符串。

let arr1 = [1, 2];
let arr2 = [3, 4];
let merged = arr1.concat(arr2); // [1, 2, 3, 4]let arr = [1, 2, 3];
let joined = arr.join('-'); // '1-2-3'

数组的扁平化

arr.flat(depth): 按照指定深度递归地将数组扁平化。

arr.flatMap(callback, thisArg): 首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。

let arr = [1, [2, [3, 4]]];
let flat = arr.flat(2); // [1, 2, 3, 4]let arr = [1, 2, 3];
let flatMapped = arr.flatMap(item => [item, item * 2]); // [1, 2, 2, 4, 3, 6]

数组的排序

arr.sort(compareFunction): 原地对数组的元素进行排序，并返回此数组。（其中，(a, b) => b - a 表示降序，(b, a) => a - b 表示升序）
```
let arr = [3, 1, 2];
arr.sort(); // [1, 2, 3]
arr.sort((a, b) => b - a); // [3, 2, 1]
```

数组的反转

arr.reverse(): 原地反转数组中元素的顺序。

let arr = [1, 2, 3];
arr.reverse(); // [3, 2, 1]

数组的复制

arr.slice(start, end): 返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。
arr.copyWithin(target, start, end): 浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
```
let arr = [1, 2, 3];
let sliced = arr.slice(1, 3); // [2, 3]let arr = [1, 2, 3, 4];
arr.copyWithin(0, 2, 4); // [3, 4, 3, 4]
```

数组的测试

Array.isArray(value): 判断一个值是否为数组。

Array.isArray([1, 2, 3]); // true
Array.isArray('hello'); // false

arr.every(callback, thisArg): 测试数组的所有元素是否都通过了指定函数的测试。

arr.some(callback, thisArg): 测试数组中的某些元素是否至少有一个通过了指定函数的测试。

let arr = [1, 2, 3];
let allPositive = arr.every(item => item > 0); // truelet arr = [1, 2, 3];
let somePositive = arr.some(item => item > 2); // true