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