# 数组常用方法汇总
# 基础
# join
将数组中的元素转化为字符串并连接在一起，默认以逗号分隔元素，可以自定义分隔符，返回最终连接在一起的字符串。
var arr = [1,2,3,4];
console.log(arr.join()); // 打印："1,2,3,4,"。默认使用逗号隔开。
var arr = [1,2,3,4];
console.log(arr.join("-")); // 打印："1-2-3-4"。指定只用"-"隔开。
var arr = [1,2,3,4];
console.log(arr.join("")); // 打印："1234"。使用空字符串时，字符之间没有分隔符。
-------------------------------------------------------------------------
var arr = [1,2,3,[4,5,6]];
console.log(arr.join()); // 打印："1,2,3,4,5,6"。多维数组，会保留其中的逗号。
var arr = [1,2,3,[4,5,6]];
console.log(arr.join("")); // 打印："1234,5,6"。多维数组，会保留其中的逗号。
var arr = [1,2,3,[4,5,6]];
console.log(arr.jon("-")); // 打印："1-2-3-4,5,6"。多维数组，会保留其中的逗号。
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
# reverse
将数组中的元素颠倒顺序，并返回改变后的数组。
var arr = [1,2,3];
console.log(arr.reverse()); // 打印：[3,2,1]。改变原数组。
1
2
2
# sort
将数组中的元素排序并返回排序后的数组,默认按照元素字母顺序。
- 自定义排序规则：
- 返回 > 0，第一个参数应该在第二个参数后面；
- 返回 < 0，第一个参数应该在第二个参数前面；
- 返回 = 0，位置不变
var arr = [2,1,3];
console.log(arr.sort()); // 打印：[1,2,3]。改变原数组。
-------------------------------------------------------------------------
var arr = [undefined,2,1,'A'];
console.log(arr.sort()); // 打印：[1,2,'A',undefined]。当数组中存在undefined时，排序后会将undefined放到数组的最后。
-------------------------------------------------------------------------
var arr = [33,4,1111,222];
console.log(arr.sort()); // 打印：[1111,222,33,4]。由于没有指明compareFunction，因此在比较时，数字会先被转换为字符串然后再做比较。
arr.sort(function(a,b){
return a - b;
})
console.log(arr); // 打印：[4,33,222,1111]。
arr.sort(function(a,b){
return b - a;
})
console.log(arr); // 打印：[1111,222,33,4]。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# concat
用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
var arr = [1,2,3];
console.log(arr.concat(4,5,6)); // 打印：[1,2,3,4,5,6]。
var arr = [1,2,3];
console.log(arr.concat([4,5,6])); // 打印：[1,2,3,4,5,6]。
var arr = [1,2,3];
console.log(arr.concat([4,5],[6,7])); // 打印：[1,2,3,4,5,6,7]。
var arr = [1,2,3];
console.log(arr.concat([4,5,6,[7,8,9]])); // 打印：[1,2,3,4,5,6,[7,8,9]]。
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# slice
返回指定数组的一个片段或子数组。它的两个参数分别表示开始位置和结束位置，但不包括结束位置上的元素。
var arr = [1,2,3,4,5];
console.log(arr.slice(1,3)); // 打印：[2,3]。
var arr = [1,2,3,4,5];
console.log(arr.slice(3)); // 打印：[4,5]。
1
2
3
4
2
3
4
# splice
删除现有元素和/或添加新元素来修改数组,并返回原数组中被修改的内容。
var arr = [1,2,3,4];
console.log(arr.splice(2)); // 打印：[3,4]，此时arr=[1,2]。
var arr = [1,2,3,4];
console.log(arr.splice(1,2)); // 打印：[2,3]，此时arr=[1,4]。
var arr = [1,2,3,4];
console.log(arr.splice(0,0,5,6)); // 打印：[]，此时arr=[5,6,1,2,3,4]。
var arr = [1,2,3,4];
console.log(arr.splice(0,0,[5,6])); // 打印：[]，此时arr=[[5,6],1,2,3,4]。splice()会插入数组本身并非数组中的元素，此特性与 concat()不同。
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# push
在数组末尾插入一个或多个元素，并返回数组新的长度。
var arr = [1,2];
console.log(arr.push(3)); // 打印：3，此时arr=[1,2,3]。
var arr = [1,2];
console.log(arr.push(3,4,5)); // 打印：5，此时arr=[1,2,3,4,5]。
1
2
3
4
2
3
4
# pop
删除数组末尾一个元素，返回被删除的元素，改变数组长度。
var arr = [1,2,3,4,5];
console.log(arr.pop()); // 打印：5，此时arr=[1,2,3,4]。
1
2
2
# unshift
在数组的头部插入一个或多个元素并返回数组新的长度。
var arr = [];
console.log(arr.unshift(1)); // 打印：1，此时arr=[1]。
var arr = [];
console.log(arr.unshift(1,2,3)); // 打印：3，此时arr=[1,2,3]。
1
2
3
4
2
3
4
# shift
在数组的头部删除一个元素，返回被删除的元素，改变数组长度。
var arr = [1,2];
console.log(arr.shift()); // 打印：1，此时arr=[2]。
1
2
2
# toString
将每个元素转换为字符串，并且输出用逗号分隔的字符串列表。与不使用任何参数调用join()方法返回的字符串一样。
var arr = [1,2,3,4,5];
console.log(arr.toString()); // 打印："1,2,3,4,5"。
1
2
2
# ES5新增
# isArray
用来判断一个对象是否为数组
console.log(Array.isArray([1, 2, 3])); // 打印：true。
console.log(Array.isArray({foo: 123})); // 打印：false。
console.log(Array.isArray("foobar")); // 打印：false。
console.log(Array.isArray(undefined)); // 打印：false。
1
2
3
4
2
3
4
# indexOf
返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。查找顺序：从前往后。
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear')) // 打印：2。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear', 1)) // 打印：2。从数组第2个位置开始查找
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear', 10)) // 打印：2。当查询位置大于或等于数组长度时，返回-1，不查找数组。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear', -2)) // 打印：2。其中-2表示从倒数第二个位置开始查找。若不改变查询顺序，还是默认按照从前往后查找。
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# lastIndexOf
返回在数组中可以找到一个给定元素的最后一个索引，如果不存在，则返回-1。查找顺序：从后往前。
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.lastIndexOf('apple')) // 打印：3。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', 1)) // 打印：0。从数组第2个位置开始先前查找
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', 10)) // 打印：3。其中10大于数组长度，则查找整个数组
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', -2)) // 打印：3。其中-2表示从数组末尾向前的偏移量。查找顺序还是从后往前。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', -10)) // 打印：-1。当负数的绝对值大于数组长度时，会返回-1，不查找数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
# every
检测数组中所有元素是否满足条件
var arr = [11, 24, 35, 30];
var result = arr.every(function(item) {
return item > 10;
});
console.info(result); // 打印：true。检测数组中每个数字是否大于10
-------------------------------------------------------------------------
var arr = [11, 24, 35, 30];
arr[10] = 40;
var result = arr.every(function(item, index) {
console.info(index);
return item > 10;
});
console.info(result); // 打印：0,1,2,3,10,true。every只会为被赋了值的索引调用回调函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
# some
检测数组中是否有一个元素满足条件
var arr= [1, 5, -3, 4, 7];
var result = arr.some(function(item, index) {
return item < 0;
});
console.info(result); // 打印：true。检测数组中是否存在小于0的数字
1
2
3
4
5
2
3
4
5
# forEach
对数组中每个元素执行特定的方法
var arr = ['a', 'b', 'c', 'd'];
arr.forEach(function(item){
console.info(item);
}); // 总是返回undefined，且不可中止或跳出forEach循环，除了抛出异常。
1
2
3
4
2
3
4
# map
对数组中每个元素进行一定的操作后，返回新的数组
var arr = [2, 4, 6, 8, 10];
var newArr = arr.map(function(item) {
return item * 2;
});
console.log(newArr); // 打印：3，8，12，16，20。
1
2
3
4
5
2
3
4
5
# filter
对数组中每一个元素进行条件筛选，返回新的数组
var arr = [1,2,3,4,5,6,7];
var newArr = arr.filter(function(item) {
return item % 2 === 0;
});
console.log(newArr);
1
2
3
4
5
2
3
4
5
# reduce
对数组中每个元素执行特定的方法，最终返回累计处理的结果。升序
var arr = [1, 2, 3, 4];
var count = arr.reduce(function(accumulator, currentValue) {
return accumulator + currentValue;
});
console.log(count); // 打印：10。accumulate：累计器。currentValue：当前值。按照升序执行回调函数，并且若没有提供initialValue时，第一次执行函数时，accumulator为数组第一个元素，currentValue为第二个元素。此后，accumulator为每次的累计值。
-------------------------------------------------------------------------
var arr = [1, 2, 3, 4];
var count = arr.reduce(function(accumulator, currentValue) {
return accumulator + currentValue;
}, 5);
console.log(count); // 打印：15。此处提供了一个initialValue值，作为第一次执行函数时的accumulator的值。
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# reduceRight
对数组中每个元素执行特定的方法，最终返回累计处理的结果。降序
var arr = [[0, 1], [2, 3], [4, 5], [6, 7]];
var arr2 = arr.reduceRight(function(accumulator, currentValue) {
return accumulator.concat(currentValue);
});
console.log(arr2); // 打印：[6, 7, 4, 5, 2, 3, 0, 1]。用法与reduce一样
1
2
3
4
5
2
3
4
5
← 属性的描述符