JavaScrip数组API

遍历

every() :

返回值为boolean类型,每次遍历的结果都为true则返回true,有任何一个返回不为true时,则返回false。

1
2
3
4
5
6
7
8
9
var array = [1, 2, 3, 4, 5];
var flag = array.every(function (element, index, arr) {
// 不写return时返回undefined
if (element < 5) {
return true;
}
})

// flag结果为false,因为当index = 4时不满足,故最后结果为false;
filter() :

返回值为数组,当遍历时的结果为true,则将该结果写入新数组中,最后返回该新数组。

1
2
3
4
5
6
7
8
9
var array = [1, 2, 3, 4, 5];
var newArr = array.filter(function (element, index, arr) {
if (element > 2) {
return true;
}
return false;
})

// 最后newArr = [3, 4, 5]
foreach()

无返回值,纯数组操作。

1
2
3
4
5
6
var array = [1, 2, 3, 4, 5];
array.foreach(function(element, index, arr) {
log.info(element)
})

// foreach方法最大的问题是无法跳出循环,哪怕是return了或者抛异常,它都会看作continue操作,直到执行完所有的遍历操作为止。
some()

返回值为boolean类型,当遍历时有一个结果返回true时,终止遍历操作,返回true。

1
2
3
4
5
6
7
8
var array = [1, 2, 3, 4, 5];
array.some(function (element, index, arr) {
if (element > 1) {
return true;
}
})

// 当遍历到index = 1时,满足条件返回true,结束循环,一共只执行了两次遍历,相对比较节约资源
map()

返回值为数组,将每次遍历的返回值写入新数组中,最后返回新数组。

1
2
3
4
5
6
var array = [1, 2, 3, 4, 5];
var newArr = array.map(function(element, index, arr) {
return element + 5;
})

// 最后newArr = [6, 7, 8, 9, 10]
find()

返回值为数组中第一个满足条件的元素。

1
2
3
4
5
6
var array = [1, 2, 3, 4, 5];
var result = array.find(element => {
return element > 2;
})

// 结果 result = 3
findIndex()

返回值为数组中第一个满足条件的元素的索引。

1
2
3
4
5
6
var array = [1, 2, 3, 4, 5];
var index = array.findIndex(element => {
return element > 2;
})

// 结果 index = 2

其它API

push()

返回值为新数组长度,把一个元素增加到数组的末尾。

1
2
3
4
var array = ['a', 'b', 'c', 'd'];
var len = array.push'('e');

// 结果:len = 5, array = ['a', 'b', 'c', 'd', 'e']
pop()

返回值为数组最后一个元素,删除数组中的最后一个值,并将其结果返回。

1
2
3
4
var array = ['a', 'b', 'c', 'd', 'e'];
var result = array.pop();

// 结果: result = 'e', array = ['a', 'b', 'c', 'd']
unshift()

返回值为新数组的长度,在数组最前端增加一个元素。

1
2
3
4
var array = ['b', 'c', 'd', 'e'];
var len = array.unshift('a');

// 结果:len = 5, array = ['a', 'b', 'c', 'd', 'e']
shift()

返回值为删除的元素本身,删除数组最前端的元素,并将其返回。

1
2
3
4
var array = ['a', 'b', 'c', 'd', 'e'];
var result = array.shift();

// 结果: result = 'a', array = ['b', 'c', 'd', 'e']
reverse()

返回值为反转后的数组,反转数组的顺序。

1
2
3
4
var array = [1, 2, 3, 4, 5];
var newArr = array.reverse();

// 结果: array = [5, 4, 3, 2 ,1]
sort()

返回值为排序后的数组,当不传参时,按照字母的编码顺序进行排序,也可以自行传入对比函数进行排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 1.当不传的对比函数时
var array = ['1', '3', '11', '2'];
array.sort();
/**
* 结果:array = ['1', '11', '2', '3'] (字符串顺序)
* 若想要按照数字顺序,需要传入参数 array.sort(sortNumber)
*/

// 2.当传入对比函数时
var array = ['1', '3', '11', '2'];
array.sort(function (n1, n2) {
return n1 > n2;
});
/**
* 对比函数中必须有两个参数
* 返回值大于0时,表示n1在n2后面
* 返回值小于0时,表示n1在n2前面
*/
slice()

返回值为截取后的数组,从指定索引位置进行数组截取。

1
2
3
4
5
6
7
8
9
10
11
var array = [1, 2, 3, 4, 5];

// 1.当只有一个参数时,表示从该索引开始截取,一直到末尾, 原数组不变
var newArr = array.slice(1);

// 结果: array = [1, 2, 3, 4, 5], newArr = [2, 3, 4, 5]

// 2.当有两个参数时,表示截取两个索引之间的子数组(前闭后开), 原数组不变
var newArr = array.slice(1, 3);

// 结果: array = [1, 2, 3, 4, 5], newArr = [2, 3]
splice()

返回值为操作后的新数组,对数组进行在指定位置的删除、插入操作。

1
2
3
4
5
6
7
8
9
10
11
var array = [1, 2, 3, 4, 5];
/**
* 参数1:进行操作的起始位置
* 参数2:进行删除操作的长度
* 参数3: 进行插入操作的元素(该参数为可变参数)
*/
var newArr = array.splice(1, 1, 'a', 'b');
/**
* 先进行删除操作,从索引为1的位置开始,删除长度1,得到newArr = [1, 3, 4, 5]
* 再进行插入操作,从索引为1的位置开始,插入'a', 'b'两个元素,得到newArr = [1, 'a', 'b', 3, 4, 5]
*/
indexOf()

返回值为指定元素的索引,从指定位置开始正序搜索指定元素,返回指定元素索引,若没找到则返回-1。

1
2
3
4
5
6
7
8
9
var array = [1, 2, 2, 3];
// 1.当只有一个参数时,该参数为要搜索的元素
var index =array.indexOf(2);
// 结果: index = 1

// 2.当有两个参数时,第一个参数表示要搜索的元素,第二个参数表示从指定索引开始搜索的索引值
var index =array.indexOf(2, 2);
// 结果: index = 2
12345678
lastIndexOf()

返回值为指定元素的索引,从指定位置开始倒序搜索指定元素,返回指定元素索引,若没找到则返回-1。

1
2
3
4
5
6
7
8
var array = [1, 2, 2, 3];
// 1.当只有一个参数时,该参数为要搜索的元素
var index =array.indexOf(2);
// 结果: index = 2

// 2.当有两个参数时,第一个参数表示要搜索的元素,第二个参数表示从指定索引开始搜索的索引值
var index =array.indexOf(2, 1);
// 结果: index = 1
includes()

返回值为boolean类型,判断一个数组是否包含指定的值,包含返回true,不包含返回false。

1
2
3
4
5
var array = ['a', 'b', 'c', 'd'];
var result1 = array.includes('a');
var result2 = array.includes('e');

// 结果 result1 = true, result2 = false