JavaScript-数组

L1u、

已于 2022-07-04 18:55:53 修改

阅读量252

点赞数 1

文章标签：前端 javascript

于 2022-06-27 17:07:12 首次发布

本文链接：https://blog.csdn.net/m0_61866713/article/details/125466318

版权

1.静态方法

1）Array.from()

Array.from() 方法对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。

伪数组对象（拥有一个 length 属性和若干索引属性的任意对象）
可迭代对象（可以获取对象中的元素，如 Map 和 Set 等）

语法：Array.from(arrayLike[, mapFn[, thisArg]])

参数：第一个参数是想要转换成数组的伪数组对象或可迭代对象。第二个参数是如果指定了该参数，新数组中的每个元素会执行该回调函数（可选）。第三个参数可选参数，执行回调函数 mapFn 时 this 对象。

返回值：一个新的数组实例。

2）Array.isArray()

Array.isArray() 用于确定传递的值是否是一个Array 。

语法：Array.isArray(obj)

参数：obj 需要检测的值。

返回值：如果值是Array，则为 true；否则为 false。

3）Array.of()

根据一组参数来创建新的数组实例，支持任意的参数数量和类型

语法：Array.of(element0[, element1[, ...[, elementN]]])

参数：任意个参数，将按顺序成为返回数组中的元素。

返回值：新的Array实例。

2.实例方法

1）Array.prototype.at()

at() 方法接收一个整数值并返回该索引的项目，允许正数和负数。负整数从数组中的最后一个项目开始倒数。

语法：at(index)

参数：index 要返回的数组元素的索引（位置）。当传递负数时，支持从数组末端开始的相对索引；也就是说，如果使用负数，返回的元素将从数组的末端开始倒数。

返回值：匹配给定索引的数组中的元素。如果找不到指定的索引，则返回undefined。

2）Array.prototype.concat()

concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

语法：var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

参数：数组和/或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝。详情请参阅下文描述。

返回值：新的Array实例。

重写concat：

3）Array.prototype.every()

测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值

语法：arr.every(callback(element[, index[, array]])[, thisArg])

参数：

callback

用来测试每个元素的函数，它可以接收三个参数：

element

用于测试的当前值。

index可选

用于测试的当前值的索引。

array可选

调用 every 的当前数组。

thisArg

执行 callback 时使用的 this 值。

返回值：如果回调函数的每一次返回都为真值，返回 true，否则返回 false。

重写every：

4）Array.prototype.filter()

filter() 方法创建一个新数组，其包含通过所提供函数实现的测试的所有元素。

语法：
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
参数：

callback

        用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数：

element

        数组中当前正在处理的元素。

index可选

        正在处理的元素在数组中的索引。

array可选

        调用了 filter 的数组本身。

thisArg可选

        执行 callback 时，用于 this 的值。

返回值：一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

重写filter：

5）Array.prototype.find()

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。

语法：
arr.find(callback[, thisArg])
参数：

callback

在数组每一项上执行的函数，接收 3 个参数：

element

当前遍历到的元素。

index可选

当前遍历到的索引。

array可选

数组本身。

thisArg可选

执行回调时用作 this 的对象。

返回值：数组中第一个满足所提供测试函数的元素的值，否则返回 undefined。

6）Array.prototype.flat()

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。flat() 方法还可以用来移除数组中的空项。

语法：
var newArray = arr.flat([depth])
参数：

depth 可选

指定要提取嵌套数组的结构深度，默认值为 1。使用Infinity可展开任意深度嵌套数组

返回值：一个包含将数组与子数组中所有元素的新数组。

7）Array.prototype.forEach()

forEach() 方法对数组的每个元素执行一次给定的函数。没有返回值，无法使用return终止函数。

语法：
arr.forEach(callback(currentValue [, index [, array]])[, thisArg])
参数：

callback

        为数组中每个元素执行的函数，该函数接收一至三个参数：

currentValue

        数组中正在处理的当前元素。

index 可选

        数组中正在处理的当前元素的索引。

array 可选

        forEach() 方法正在操作的数组。

thisArg 可选

        可选参数。当执行回调函数 callback 时，用作 this 的值。

返回值：undefined。

重写forEach：

8）Array.prototype.includes()

includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

语法：
arr.includes(valueToFind[, fromIndex])
参数：

valueToFind

需要查找的元素值。

fromIndex 可选

从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜（即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。

返回值：undefined。

重写includes：

9）Array.prototype.indexOf()

indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

语法：
arr.indexOf(searchElement[, fromIndex])
参数：

searchElement

要查找的元素

fromIndex 可选

开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回 -1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即 -1 表示从最后一个元素开始查找，-2 表示从倒数第二个元素开始查找，以此类推。注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于 0，则整个数组都将会被查询。其默认值为 0。

返回值：undefined首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1

重写indexOf：

10）Array.prototype.join()

join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。

语法：
arr.join([separator])
参数：

separator 可选

指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串 ("")，则所有元素之间都没有任何字符。

返回值：一个所有数组元素连接的字符串。如果 arr.length 为 0，则返回空字符串。

重写join：

11）Array.prototype.lastIndexOf()

lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

语法：
arr.lastIndexOf(searchElement[, fromIndex])
参数：

searchElement

被查找的元素。

fromIndex 可选

从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

返回值：数组中该元素最后一次出现的索引，如未找到返回-1。

12）Array.prototype.map()

map() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。

语法：
var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])
参数：

callback

        生成新数组元素的函数，使用三个参数：函数会被自动传入三个参数：数组元素，元素索引，原数组本身。

currentValue

        callback 数组中正在处理的当前元素。

index可选

        callback 数组中正在处理的当前元素的索引。

array可选

        map 方法调用的数组。

thisArg可选

        执行 callback 函数时值被用作this。

返回值：一个由原数组每个元素执行回调函数的结果组成的新数组。

重写map：

13）Array.prototype.pop()

pop() 方法从数组中删除最后一个元素，并返回该元素的值。此方法会更改数组的长度。

语法：
arr.pop()
返回值：从数组中删除的元素（当数组为空时返回undefined）。

重写pop：

14）Array.prototype.push()

push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

语法：
arr.push(element1, ..., elementN)
参数：

elementN

被添加到数组末尾的元素。

返回值：当调用该方法时，新的 length 属性值将被返回。

重写push：

15）Array.prototype.reduce()

reduce() 方法对数组中的每个元素按序执行一个由您提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。

第一次执行回调函数时，不存在“上一次的计算结果”。如果需要回调函数从数组索引为 0 的元素开始执行，则需要传递初始值。否则，数组索引为 0 的元素将被作为初始值 initialValue，迭代器将从第二个元素开始执行（索引为 1 而不是 0）。

语法：
// Arrow function
reduce((previousValue, currentValue) => { /* ... */ } )
reduce((previousValue, currentValue, currentIndex) => { /* ... */ } )
reduce((previousValue, currentValue, currentIndex, array) => { /* ... */ } )
reduce((previousValue, currentValue, currentIndex, array) => { /* ... */ }, initialValue)

// Callback function
reduce(callbackFn)
reduce(callbackFn, initialValue)

// Inline callback function
reduce(function(previousValue, currentValue) { /* ... */ })
reduce(function(previousValue, currentValue, currentIndex) { /* ... */ })
reduce(function(previousValue, currentValue, currentIndex, array) { /* ... */ })
reduce(function(previousValue, currentValue, currentIndex, array) { /* ... */ }, initialValue)
参数：

callbackFn

一个 “reducer” 函数，包含四个参数：

previousValue：上一次调用 callbackFn 时的返回值。在第一次调用时，若指定了初始值 initialValue，其值则为 initialValue，否则为数组索引为 0 的元素 array[0]。
currentValue：数组中正在处理的元素。在第一次调用时，若指定了初始值 initialValue，其值则为数组索引为 0 的元素 array[0]，否则为 array[1]。
currentIndex：数组中正在处理的元素的索引。若指定了初始值 initialValue，则起始索引号为 0，否则从索引 1 起始。
array：用于遍历的数组。

initialValue 可选

作为第一次调用 callback 函数时参数 previousValue 的值。若指定了初始值 initialValue，则 currentValue 则将使用数组第一个元素；否则 previousValue 将使用数组第一个元素，而 currentValue 将使用数组第二个元素。

返回值：使用 “reducer” 回调函数遍历整个数组后的结果。

重写reduce：

16）Array.prototype.reverse()

reverse() 方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。

语法：
arr.reverse()
返回值：颠倒后的数组。

重写reverse：

17)Array.prototype.shift()

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

语法：
arr.shift()
参数：

返回值：从数组中删除的元素; 如果数组为空则返回undefined 。

重写shift:

18)Array.prototype.slice()

slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

语法：
arr.slice([begin[, end]])
参数：

begin 可选

提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。如果省略 begin，则 slice 从索引 0 开始。如果 begin 超出原数组的索引范围，则会返回空数组。

end 可选

提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素（索引为 1, 2, 3 的元素）。如果该参数为负数，则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。如果 end 被省略，则 slice 会一直提取到原数组末尾。如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

返回值：一个含有被提取元素的新数组。

重写slice：

19）Array.prototype.some()

some() 方法测试数组中是不是至少有 1 个元素通过了被提供的函数测试。它返回的是一个 Boolean 类型的值。

语法：
arr.some(callback(element[, index[, array]])[, thisArg])
参数：

callback

        用来测试每个元素的函数，接受三个参数：

element

        数组中正在处理的元素。

index 可选

        数组中正在处理的元素的索引值。

array可选

  some()被调用的数组。

thisArg可选

执行 callback 时使用的 this 值。

返回值：数组中有至少一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为 false。

重写some：

20）Array.prototype.sort()

sort() 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列时构建的

语法：
arr.sort([compareFunction])
参数：

compareFunction 可选

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

firstEl

        第一个用于比较的元素。

secondEl

        第二个用于比较的元素

返回值：排序后的数组。请注意，数组已原地排序，并且不进行复制。

21)Array.prototype.splice()

splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容。此方法会改变原数组。

语法：
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
参数：

start

        指定修改的开始位置（从 0 计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从 -1 计数，这意味着 -n 是倒数第 n 个元素并且等价于 array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第 0 位。

deleteCount 可选

        整数，表示要移除的数组元素的个数。如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。

item1, item2, ... 可选

        要添加进数组的元素，从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

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

重写splice：

22）Array.prototype.toString()

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

语法：
arr.toString()
参数：

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

23)Array.prototype.unshift()

unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度（该方法修改原有数组）。

语法：
arr.unshift(element1, ..., elementN)
参数：

elementN

要添加到数组开头的元素或多个元素。

返回值：当一个对象调用该方法时，返回其 length 属性值。