ES5

pop

从数组中删除最后一个元素并返回。

1
2
const arr = [1, 2, 3];
const removedItem = arr.pop(); // 3

shift

从数组中删除第一个元素并返回它。

1
2
const arr = [1, 2, 3];
const removedItem = arr.shift(); // 1

push

向数组追加新元素,并返回数组的新长度。

1
2
const arr = [1, 2, 3];
const newLength = arr.push(4); // 4

unshift

在数组的开头插入新元素。

1
2
const arr = [1, 2, 3];
arr.unshift(4); // [4, 1, 2, 3]

indexOf

返回数组中第一个出现值的索引。

1
2
const arr = [1, 2, 3, 1, 4, 3, 1];
arr.indexOf(3, 0); // 2

lastIndexOf

返回数组中指定值的最后一次出现的索引。

1
2
const arr = [1, 2, 3, 1, 4, 3, 1];
arr.lastIndexOf(3); // 5

every

检测数值元素的每个元素是否都符合条件。

1
2
const arr = [1, 2, 3, 4];
arr.every(item=> item & 1); // false

some

检测数组元素中是否有元素符合指定条件。

1
2
const arr = [1, 2, 3, 4];
arr.some(item=> item & 1); // true

reduce

将数组元素计算为一个值(从左到右)。

1
2
3
4
const arr = [1, 2, 3, 4];
const reduceArr = arr.reduce((previousValue, currentValue, currentIndex, array) => {
return previousValue * currentValue << 1;
}, 1); // 384 = 1 * 2 * 3 * 4 << arr.length

reduceRight

将数组元素计算为一个值(从右到左)。

1
2
3
4
const arr = [1, 2, 3, 4];
const reduceRightArr = arr.reduceRight((previousValue, currentValue, currentIndex, array) => {
return previousValue * currentValue << 1;
}, 1); // 384 = 4 * 3 * 2 * 1 << arr.length

concat

用于连接两个或多个数组。该方法不会改变现有的数组,而仅仅会返回被连接数组的一个副本。

1
2
3
const arr1 = [1, 2];
const arr2 = [3, 4];
const concatArr = arr1.concat(arr2); // [1, 2, 3, 4]

join

添加由指定分隔符字符串分隔的数组的所有元素。

1
2
const arr = [1, 2, 3];
const joinStr = arr.join('-'); // '1-2-3'

sort

根据指定规则对数组排序

1
2
const users = ['Esther', 'Emil', 'Amy'];
users.sort((u1, u2)=> u1.length - u2.length); // ["Amy", "Emil", "Esther"] 按字符长度正序

reverse

反转数组中的元素。

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

slice

截取数组中的一部分

参数列表

  • start 可选。规定从何处开始选取。如果是负数,那么它规定从数组尾部开始算起的位置。也就是说,-1 指最后一个元素,-2 指倒数第二个元素,以此类推。
  • end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数,那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数,那么它规定的是从数组尾部开始算起的元素。
1
2
const arr = [1, 2, 3, 4];
const sliceArr = arr.slice(-3, -1); // [2, 3]

splice

参数列表

  • index 必需。规定从何处添加/删除元素。该参数是开始插入和(或)删除的数组元素的下标,必须是数字。
  • deleteCount 可选。规定应该删除多少元素。必须是数字,但可以是 “0”。如果未规定此参数,则删除从 index 开始到原数组结尾的所有元素。
  • …items 可选。要添加到数组的新元素
1
2
const arr = ['1', '2', '3', '4'];
arr.splice(2, 1, '7', '8'); // ["1", "2", "7", "8", "4"]

forEach

对数组进行遍历,不能中断,没有返回值

1
2
3
4
const arr = [1, 2, 3];
arr.forEach((item, index, arr) => {
console.log(`item:${item},index:${index}`);
});

map

对数组中的每个元素进行处理,得到新的数组。不改变原有数据的结构和数据。

1
2
3
4
const arr = [1, 2, 3];
const mapArr = arr.map(item=>{
return item * 2;
}); // [2, 4, 6]

filter

检测数值元素,并返回符合条件所有元素的数组。

1
2
const arr = [1, 2, 3, 4];
const filterArr = arr.filter(item=> item & 1); // [1, 3]

ES6

of

将参数中所有值作为元素形成数组。

1
2
3
4
5
const arr1 = Array.of(1, 2, 3, 4); // [1, 2, 3, 4]
// 参数值可为不同类型
const arr2 = Array.of(1, '2', false); // [1, '2', false]
// 参数为空时返回空数组
const arr3 = Array.of(); // []

from

将类数组对象或可迭代对象转化为数组。

1
2
3
4
// 参数为数组,返回与原数组一样的数组
const arr1 = Array.from([1,2]); // [1, 2]
// 参数含空位
const arr2 = Array.from([1,2,]); // [1, 2, undefined]

find

查找数组中符合条件的元素,若有多个符合条件的元素,则返回第一个元素。

1
2
const arr = Array.of(1, 2, 3, 4);
const findArr = arr.find(item=> item & 1); // [1]

findIndex

查找数组中符合条件的元素索引,若有多个符合条件的元素,则返回第一个元素索引。

1
2
const arr = Array.of(1, 2, 3, 4);
const findArr = arr.findIndex(item=> item & 1); // 0

fill

将一定范围索引的数组元素内容填充为单个指定的值。

参数列表

  • value 必需。填充的值。
  • start 可选。元素复制的起始位置。
  • end 可选。停止复制的索引位置 (默认为 array.length)。如果为负值,表示倒数。
1
2
const arr = Array.of(1, 2, 3, 4);
const fillArr = arr.fill(0, 1, 2); // [1, 0, 3, 4]

copyWithin

复制数组的前面两个元素到后面两个元素上:

参数列表

  • target 必需。复制到指定目标索引位置。
  • start 可选。元素复制的起始位置。
  • end 可选。停止复制的索引位置 (默认为 array.length)。如果为负值,表示倒数。
1
2
const arr = Array.of(1, 2, 3, 4, 5, 6);
const copyWithinArr = arr.copyWithin(2, 0); // [1, 2, 1, 2, 3, 4]

includes

判断一个数组是否包含一个指定的值

1
2
const arr = Array.of(1, 2, 3, 4); // [1, 2, 3, 4]
const isIncluded = arr.includes(5); // false

ES2019

flat

嵌套数组转一维数组

1
2
3
4
5
6
const arr1 = [1, [2, 3]];
const flatArr1 = arr1.flat(); // [1, 2, 3]

// 指定转换的嵌套层数
const arr2 = [1, [2, [3]]];
const flatArr2 = arr2.flat(); // [1, 2, 3]

flatMap

先对数组中每个元素进行了的处理,再对数组执行 flat() 方法。

1
2
3
4
const arr = [1, [2, 3]];
const mapArr = arr.flatMap(item=>{
return item * 2;
}); // [2, 4, 6]