javascript Array方法总结（下篇）

最新推荐文章于 2024-05-05 15:01:09 发布

樊小书生

最新推荐文章于 2024-05-05 15:01:09 发布

阅读量240

点赞数 2

分类专栏： JavaScript web开发录文章标签： javascript array

本文链接：https://blog.csdn.net/fxss5201/article/details/85723513

版权

JavaScript 同时被 2 个专栏收录

86 篇文章 1 订阅

订阅专栏

web开发录

57 篇文章 1 订阅

订阅专栏

每个方法都有相应的描述、语法、参数、返回值、注意项（可选）、例子（可选）。
语法中的[]里面中的内容表示参数为可选参数。

原文出自：https://fxss5201.github.io/practical-code-snippet/js/javascript/Array.html

`Array.prototype.lastIndexOf()`

描述：返回从数组中逆向找到给定元素的第一个索引，如果不存在，则返回-1。

语法：

number = old_array.lastIndexOf(searchElement[, fromIndex]);

参数：

old_array：原数组。
searchElement：需要查找的元素值。
fromIndex：从该索引处开始逆向查找searchElement。默认值从array.length - 1，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，则从array.length + fromIndex索引出开始逆向查找。如果负值的绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

返回值：

number：返回从数组中逆向找到给定元素的第一个索引，如果不存在，则返回-1。

注意项：

lastIndexOf使用严格等于进行判断（仅当两个操作数的类型相同且值相等才为true）。

例子：

[2, 5, 9].lastIndexOf(2); // 0
[2, 5, 9].lastIndexOf('2'); // -1

`Array.prototype.map()`

描述：创建一个新数组，其结果是该数组中的每个元素都调用提供函数后返回的结果。

语法：

new_array = old_array.map(callback(element[, index[, array]])[, thisArg]);

参数：

old_array：原数组。
callback：原数组中的每个元素都执行的回调函数，然后返回新数组中对应索引处的元素。
1. element：当前在数组中处理的元素。
2. index：当前在数组中处理的元素的索引。
3. array：当前数组。
thisArg：执行回调函数时的this对象。

返回值：

new_array：callback每次执行后的返回值（包括undefined）组合起来形成一个新数组。

注意项：

map遍历的元素范围在第一次调用callback之前就已经确定了。在调用map之后新添加到数组中的元素不会被callback访问到。如果数组中存在的元素被更改，则他们传入callback的值是map访问到他们那一刻的值。从来没被赋过值或被删除的元素将不会被访问到。

例子：

[2, 5, 9].map(x => x * x); // [4, 25, 81]

["1", "2", "3"].map(parseInt); // [1, NaN, NaN]
["1", "2", "3"].map(x => parseInt(x)); // [1, 2, 3]

`Array.prototype.pop()`

描述：从数组中删除最后一个元素，并返回该元素的值。

语法：

last_element = old_array.pop();

参数：

old_array：原数组。

返回值：

last_element：数组的最后一个元素。

注意项：

在空数组上调用pop()，返回undefined。
Array(7)等稀疏数组上调用pop()，返回undefined。
此方法会改变原数组。

例子：

[2, 5, 9].pop(); // 9
[2, 5, [9, 10]].pop(); // [9, 10]

[].pop(); // undefined
Array(7).pop(); // undefined

`Array.prototype.push()`

描述：将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

语法：

new_array_length = old_array.push(element1, ..., elementN);

参数：

old_array：原数组。
elementN：被添加到数组末尾的元素。

返回值：

new_array_length：返回数组添加元素之后的新长度。

例子：

var arr = [1, 2, 3];
arr.push(4, 5); // 5
console.log(arr); // [1, 2, 3, 4, 5]

`Array.prototype.reduce()`

描述：对数组中的每个元素执行提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

语法：

number = old_array.reduce(callback(accumulator, element[[, index], array])[, initialValue]);

参数：

old_array：原数组。
callback：原数组中的每个元素都执行的回调函数。
1. accumulator：上一次调用回调的返回值，或提供的initialValue。
2. element：当前在数组中处理的元素。
3. index：当前在数组中处理的元素的索引。
4. array：当前数组。
initialValue：用作第一次调用callback的参数值。如果未提供初始值，则将使用数组中的第一个元素。空数组在没有初始值时调用reduce()抛出TypeError。

返回值：

number：对数组中的每个元素执行提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

注意项：

reduce为数组中的每一个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素。
如果调用reduce时提供了initialValue，accumulator取值为initialValue，element取数组中的第一个值；如果没有提供initialValue，那么accumulator取数组中的第一个值，element取数组中的第二个值。
如果没有提供initialValue，reduce会从索引 1 的地方开始执行callback方法，跳过第一个索引。如果提供initialValue，从索引 0 开始。
如果数组仅有一个元素（无论位置如何）并且没有提供initialValue，或者有提供initialValue但是数组为空，那么此唯一值将被返回并且callback不会被执行。

例子：（代码注释中的->表示执行一次的结果）

[0, 1, 2, 3, 4].reduce(function(accumulator, element, index, array){
  console.log(accumulator); // 0 -> 1 -> 3 -> 6
  return accumulator + element;
}); // 10
[0, 1, 2, 3, 4].reduce(function(accumulator, element, index, array){
  console.log(accumulator); // 10 -> 10 -> 11 -> 13 -> 16
  return accumulator + element;
}, 10); // 20

`Array.prototype.reduceRight()`

描述：从右到左对数组中的每个元素执行提供的reduceRight函数，将其结果汇总为单个返回值。

语法：

number = old_array.reduceRight(callback(previousValue, element[[, index], array])[, initialValue]);

参数：

old_array：原数组。
callback：原数组中的每个元素都执行的回调函数。
1. previousValue：上一次调用回调的返回值，或提供的initialValue。
2. element：当前在数组中处理的元素。
3. index：当前在数组中处理的元素的索引。
4. array：当前数组。
initialValue：用作第一次调用reduceRight的参数值。如果未提供初始值，则将使用数组中的最后一个元素。空数组在没有初始值时调用reduceRight()抛出TypeError。

返回值：

number：从右到左对数组中的每个元素执行提供的reduceRight函数，将其结果汇总为单个返回值。

注意项：

reduceRight为数组中的每一个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素。
如果调用reduceRight时提供了initialValue，previousValue取值为initialValue，element取数组中的最后一个值；如果没有提供initialValue，那么previousValue取数组中的最后一个值，element取数组中的倒数第二个值。
如果数组仅有一个元素（无论位置如何）并且没有提供initialValue，或者有提供initialValue但是数组为空，那么此唯一值将被返回并且callback不会被执行。

例子：

[0, 1, 2, 3, 4].reduceRight(function(accumulator, element, index, array){
  console.log(accumulator); // 4 -> 7 -> 9 -> 10
  return accumulator + element;
}); // 10
[0, 1, 2, 3, 4].reduceRight(function(accumulator, element, index, array){
  console.log(accumulator); // 10 -> 14 -> 17 -> 19 -> 20
  return accumulator + element;
}, 10); // 20

`Array.prototype.reverse()`

描述：将数组中元素的位置颠倒。

语法：

new_array = old_array.reverse();

参数：

old_array：原数组。

返回值：

new_array：颠倒数组中元素的位置，并返回该数组的引用。

例子：

var arr = ['one', 'two', 'three'];
var reversed = arr.reverse();
console.log('reversed: ', reversed); // ["three", "two", "one"]
console.log('arr: ', arr); // ["three", "two", "one"]

`Array.prototype.shift()`

描述：从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

语法：

first_element = old_array.shift();

参数：

old_array：原数组。

返回值：

first_element：数组中的第一个元素。

注意项：

如果数组的length属性的值为 0 (长度为 0)，则返回undefined。

例子：

var arr = ['one', 'two', 'three'];
var shift = arr.shift();
console.log('shift: ', shift); // one
console.log('arr: ', arr); // ['two', 'three']

[].shift(); // undefined

`Array.prototype.slice()`

描述：slice不修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。

语法：

new_array = old_array.slice([start[, end]);

参数：

old_array：原数组。
start：从该索引处开始复制原数组中的元素（包含该索引处的值），索引以0开始，如果指定负数，将从数组的末尾开始往回算。默认值为：0。
end：在该索引处结束复制原数组元素（不包含该索引处的值），索引以0开始，如果指定负数，将从数组的末尾开始往回算。默认值为：old_array.length。

返回值：

new_array：返回浅复制的新数组。

注意项：

如果原数组中当前复制元素是对象引用（不是实际的对象），slice会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素都会发生改变。
对于字符串、数字及布尔值来说（不是String、Number或者Boolean对象），slice会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响其他数组。

例子：

var arr1 = [1, 2, 3],
    arr2 = [arr1, 4, 5, 6], // [[1, 2, 3], 4, 5, 6]
    arr3 = arr2.slice(0, 2), // [[1, 2, 3], 4]
    arr4 = arr2.slice(1, 3); // [4, 5]
arr1[0] = 7;
arr2[1] = 8;
console.log(arr2); // [[7, 2, 3], 8, 5, 6]
console.log(arr3); // [[7, 2, 3], 4]
console.log(arr4); // [4, 5]

`Array.prototype.some()`

描述：测试是否至少有一个元素通过提供的函数的测试。

语法：

boolean = old_array.some(callback(element[, index[, array]])[, thisArg]);

参数：

old_array：原数组。
callback：用来测试数组的每个元素的函数，符合条件则返回true，否则返回false。
1. element：当前在数组中处理的元素。
2. index：当前在数组中处理的元素的索引。
3. array：当前数组。
thisArg：执行callback时使用的this值。

返回值：

boolean：如果至少有一个元素符合条件则返回true，否则返回false。

注意项：

空数组调用some方法返回false。
some为数组中的每一个元素执行一次callback函数，直到找到一个使得callback返回一个true或Truthy。如果找到了这样一个值，some()将会立即返回 true，否则返回false。callback只会在那些”有值“的索引上被调用，不会在那些被删除或从来未被赋值的索引上调用。
some遍历的元素范围在第一次调用callback之前就已经确定了。在调用some之后新添加到数组中的元素不会被callback访问到。如果数组中存在的元素被更改，则他们传入callback的值是some访问到他们那一刻的值。那些被删除的元素或从来未被赋值的元素将不会被访问到。

例子：

[].some(x => x > 0); // false

[1, 2, 3].some(x => x > 2); // true

`Array.prototype.sort()`

描述：对数组的元素进行排序，并返回数组。默认排序顺序是根据字符串Unicode排序。

语法：

new_array = old_array.sort([compareFunction]);

参数：

old_array：原数组。
compareFunction：用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode进行排序。

返回值：

new_array：排序后的数组。

例子：

[1, 20, 8, 16].sort(); // [1, 16, 20, 8]

[1, 20, 8, 16].sort((a,b) => a - b); // [1, 8, 16, 20]

`Array.prototype.splice()`

描述：通过删除现有元素和 / 或添加新元素来修改数组，并以数组返回原数组中被删除的内容。

语法：

new_array = old_array.splice(start[, deleteCount[, item1[, item2[, ...]]]]);

参数：

old_array：原数组。
start：从该索引处开始删除现有元素和 / 或添加新元素来修改数组，索引以0开始，如果指定负数，将从数组的末尾开始往回算。默认值为：0。
deleteCount：整数，表示要移除的数组元素的个数。
1. 如果deleteCount是 0或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
2. 如果deleteCount大于start之后的元素的总数，则从start后面的元素都将被删除（含第start位）。
3. 如果deleteCount被省略，则其相当于old_array.length - start。
itemN：从start索引开始添加进数组的元素。如果不指定，则splice将只删除数组元素。

返回值：

new_array：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

例子：

[1, 20, 8, 16].splice(1); // [20, 8, 16]
[1, 20, 8, 16].splice(1, 2); // [20, 8]

var arr1 = [1, 20, 8, 16],
    arr2 = arr1.splice(1, 2, 2, 3, 4);
console.log(arr1); // [1, 2, 3, 4, 16]
console.log(arr2); // [20, 8]

`Array.prototype.toString()`

描述：返回一个字符串，表示指定的数组及其元素。

语法：

str = old_array.toString();

参数：

old_array：原数组。

返回值：

str：返回一个字符串，表示指定的数组及其元素。

例子：

[1, 20, 8, 16].toString(); // "1,20,8,16"

[1, [20, [10, 15], 8], 16].toString(); // "1,20,10,15,8,16"

`Array.prototype.unshift()`

描述：将一个或多个元素添加到数组的开头，并返回该数组的新长度。

语法：

new_array_length = old_array.unshift(element1, ..., elementN);

参数：

old_array：原数组。
elementN：要添加到数组开头的元素。

返回值：

new_array_length：将一个或多个元素添加到数组的开头，并返回该数组的新长度。

例子：

var arr1 = [1, 20, 8, 16],
    len = arr1.unshift(-1, 0);
console.log(arr1); // [-1, 0, 1, 20, 8, 16]
console.log(len); // 6

`Array.prototype.values()`

描述：返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值。

语法：

new_iterator = old_array.values();

参数：

old_array：原数组。
elementN：要添加到数组开头的元素。

返回值：

new_iterator：返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值。

例子：

var iterator = ['a', 'b', 'c'].values();
iterator.next();   // {value: "a",done: false}
iterator.next();   // {value: "b",done: false}
iterator.next();   // {value: "c",done: false}
iterator.next();   // {value: undefined,done: true}