数组方法

添加/移除数组元素

• arr.push(item1,item2,item3….) —— 从尾端添加元素
• arr.pop() —— 从尾端删除最后个元素，并返回该删除元素，改变原数组
• arr.shift() —— 从首端删除第一元素，并返回该删除元素，改变原数组
• arr.unshift(item1,item2,item3….) —— 从首端添加元素。

splice

arr.splice(start, deleteCount, elem1, …, elemN)—— 它从索引 start 开始修改 arr：删除 deleteCount 个元素并在当前位置插入 elem1, …, elemN。最后返回已被删除元素的数组，改变原数组

//删除
let arr = ["I", "study", "JavaScript"];
arr.splice(1, 1); // 从索引 1 开始删除 1 个元素
alert( arr ); // ["I", "JavaScript"]
// 插入
let arr = ["I", "study", "JavaScript", "right", "now"];
arr.splice(0, 3, "Let's", "dance");//从索引0开始，删除3个元素，并插入新元素
alert( arr ) // ["Let's", "dance", "right", "now"]
//将 deleteCount 设置为 0，splice 方法就能够插入元素而不用删除任何元素：
let arr = ["I", "study", "JavaScript"];
// 从索引 2 开始, 删除 0 个元素,然后插入 "complex" 和 "language"
arr.splice(2, 0, "complex", "language");
//负向索引,它们从数组末尾计算位置
let arr = [1, 2, 5];
// 从索引 -1（尾端前一位）,删除 0 个元素，然后插入 3 和 4
arr.splice(-1, 0, 3, 4);
alert( arr ); // 1,2,3,4,5

slice(功能强大)

语法：arr.slice(start,end)
介绍：它会返回一个新数组，将所有从索引 start 到 end（不包括 end）的数组项复制到一个新的数组。start 和 end 都可以是负数，在这种情况下，从末尾计算索引。

let arr = ["t", "e", "s", "t"];
alert( arr.slice(1, 3) ); // e,s（复制从位置 1 到位置 3 的元素）
alert( arr.slice(-2) ); // s,t（复制从位置 -2 到尾端的元素）

concat

语法：arr.concat(arg1, arg2…)
介绍：创建一个新数组，其中包含来自于其他数组和其他项的值。它接受任意数量的参数 —— 数组或值都可以。

let arr = [1, 2];
alert( arr.concat([3, 4]) ); // 1,2,3,4
alert( arr.concat([3, 4], [5, 6]) ); // 1,2,3,4,5,6
alert( arr.concat([3, 4], 5, 6) ); // 1,2,3,4,5,6
//通常，它只复制数组中的元素。其他对象会被作为一个整体添加
let arrayLike = {
  0: "something",
  length: 1
};
alert( arr.concat(arrayLike) ); // 1,2,[object Object]
//如果类似数组的对象具有 Symbol.isConcatSpreadable 属性，那么它就会被 concat 当作一个数组来处理
let arrayLike = {
  0: "something",
  1: "else",
  [Symbol.isConcatSpreadable]: true,
  length: 2
};
alert( arr.concat(arrayLike) ); // 1,2,something,else

遍历

forEach

语法：arr.forEach(function(item, index, array){ // … do something with item} );
介绍：允许为数组的每个元素都运行一个函数

搜索

indexOf/lastIndexOf 和 includes

这3个方法与字符串操作具有相同的语法，并且作用基本上也与字符串的方法相同，只不过这里是对数组元素而不是字符进行操作

• arr.indexOf(item, from) 从索引 from 开始搜索 item，如果找到则返回索引，否则返回 -1。
• arr.lastIndexOf(item, from) —— 和上面相同，只是从右向左搜索。
• arr.includes(item, from) —— 从索引 from 开始搜索 item，如果找到则返回 true（译注：如果没找到，则返回 false）。 ```javascript let arr = [1, 0, false];

alert( arr.indexOf(0) ); // 1 alert( arr.indexOf(false) ); // 2 alert( arr.indexOf(null) ); // -1

alert( arr.includes(1) ); // true

<a name="QZkib"></a>
### [find 和 findIndex](https://zh.javascript.info/array-methods#find-he-findindex)
find语法：
```javascript
//形参：item是元素，index是索引，array是数组本身
let result = arr.find(function(item, index, array) {
  // 如果返回 true，则返回 item 并停止搜索
  // 对于假值（falsy）的情况，则返回 undefined
});

findIndex语法：（与 arr.find 方法）基本上是一样的，但它返回找到元素的索引，而不是元素本身。并且在未找到任何内容时返回 -1。

filter

介绍：返回的是所有匹配元素组成的新数组
语法：

let results = arr.filter(function(item, index, array) {
  // 如果 true item 被 push 到 results，迭代继续
  // 如果什么都没找到，则返回空数组
});

转换数组：数组转换和重新排序

map

语法：let result = arr.map(function(item, index, array){// 返回新值而不是当前元素})
它对数组的每个元素都调用函数，并返回一个新结果数组

sort(fn)

arr.sort 方法对数组进行 原位（in-place） 排序，更改元素的顺序。(译注：原位是指在此数组内，而非生成一个新数组。)

let arr = [ 1, 2, 15 ];
// 该方法重新排列 arr 的内容
arr.sort();
//默认情况下被按字符串进行排序
alert( arr );  // 1, 15, 2
//要使用自己的排序顺序，需要提供一个函数作为 arr.sort() 的参数。
数字：arr.sort(function(a, b) { return a - b; });
字符串：['steh', 'Ana', 'Vim'].sort( (a, b) => a.localeCompare(b) ) )

reverse

用于颠倒 arr 中元素的顺序。

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

split 和 join

str.split(delim,len)，它通过给定的分隔符 delim 将字符串分割成一个数组，可选参数len,是对长度的限制，如果有，额外的元素会被忽略

let arr = 'Bilbo, Gandalf, Nazgul, Saruman'.split(', ', 2);
alert(arr); // Bilbo, Gandalf
//拆分字母
let str = "test";
alert( str.split('') ); // t,e,s,t

arr.join(glue) 与 split 相反。它会在它们之间创建一串由 glue 粘合的 arr 项。

let arr = ['Bilbo', 'Gandalf', 'Nazgul'];
let str = arr.join(';'); // 使用分号 ; 将数组粘合成字符串
alert( str ); // Bilbo;Gandalf;Nazgul

reduce/reduceRight

语法：

let value = arr.reduce(function(accumulator, item, index, array) {
  // ...
}, [initial]);
参数：
accumulator —— 是上一个函数调用的结果，第一次等于 initial（如果提
供了 initial 的话，没提供则取数组第一个为初始值，从第2个元素开始迭代）。
item —— 当前的数组元素。
index —— 当前索引。
arr —— 数组本身

应用函数时，上一个函数调用的结果将作为第一个参数传递给下一个函数。
因此，第一个参数本质上是累加器，用于存储所有先前执行的组合结果。最后，它成为 reduce 的结果

let arr = [1, 2, 3, 4, 5];
let result = arr.reduce((sum, current) => sum + current, 0);
alert(result); // 15
//没有初始值，那么 reduce 会将数组的第一个元素作为初始值，并从第二个元素开始迭代。
let result = arr.reduce((sum, current) => sum + current, 0);
alert(result); // 15

其他不常用方法

• arr.some(fn)/arr.every(fn) 检查数组。与 map 类似，对数组的每个元素调用函数 fn。如果任何/所有结果为 true，则返回 true，否则返回 false。
• arr.fill(value, start, end) —— 从索引 start 到 end，用重复的 value 填充数组。
• arr.copyWithin(target, start, end) —— 将从位置 start 到 end 的所有元素复制到 自身 的 target 位置（覆盖现有元素）。
• arr.flat(depth)/arr.flatMap(fn) 从多维数组创建一个新的扁平数组。
• Array.of(element0[, element1[, …[, elementN]]]) 基于可变数量的参数创建一个新的 Array 实例，而不需要考虑参数的数量或类型。

  isArray

  判断是否为数组，返回布尔值。Array.isArray(value)。如果 value 是一个数组，则返回 true；否则返回 false。

  大多数方法都支持 “thisArg”

  几乎所有调用函数的数组方法 —— 比如 find，filter，map，除了 sort 是一个特例，都接受一个可选的附加参数 thisArg。 ```javascript arr.find(func, thisArg); arr.filter(func, thisArg); arr.map(func, thisArg); // … // thisArg 是可选的最后一个参数

thisArg 参数的值在 func 中变为 this。

例子： let army = { minAge: 18, maxAge: 27, canJoin(user) { return user.age >= this.minAge && user.age < this.maxAge; } };

let users = [ {age: 16}, {age: 20}, {age: 23}, {age: 30} ];

// 找到 army.canJoin 返回 true 的 user let soldiers = users.filter(army.canJoin, army);

alert(soldiers.length); // 2 alert(soldiers[0].age); // 20 alert(soldiers[1].age); // 23 ```