JavaScrip 数组 API

entries()

entries() 方法返回一个新的数组迭代器对象，该对象包含数组中每个索引的键/值对。时间复杂度为 O(1)。

const array1 = ['a', , 'b', 'c']

const iterator1 = array1.entries()
console.log(iterator1.next().value) // [ 0, 'a' ]
console.log(iterator1.next().value) // [ 1, undefined ]

const iterator2 = array1.entries()
for (const [index, element] of iterator2) {
  console.log(index, element) // [ 0, 'a' ] [ 1, undefined ] [ 2, 'b' ] [ 3, 'c' ]
}

当在稀疏数组上使用时，entries() 方法迭代空槽，就像它们的值为 undefined 一样。

values()

values() 方法返回一个新的数组迭代器对象，该对象迭代数组中每个元素的值。时间复杂度为 O(1)。

const array1 = ['a', 'b', 'c']
const iterator = array1.values()

for (const value of iterator) {
  console.log(value) // 'a', 'b', 'c'
}

Array.prototype.values() 是 Array.prototype[Symbol.iterator]() 的默认实现。

Array.prototype.values === Array.prototype[Symbol.iterator] // true

isArray()

Array.isArray() 静态方法用于确定传递的值是否是一个数组。时间复杂度为 O(1)。

console.log(Array.isArray([1, 3, 5])) // true
console.log(Array.isArray('[]')) // false
console.log(Array.isArray(new Array(5))) // true
console.log(Array.isArray(new Int16Array([15, 33]))) // false

Array.isArray() 检查传递的值是否为 Array。它不检查值的原型链，也不依赖于它所附加的 Array 构造函数。对于使用数组字面量语法或 Array 构造函数创建的任何值，它都会返回 true。这使得它可以安全地使用跨领域（cross-realm）对象，其中 Array 构造函数的标识是不同的，因此会导致 instanceof Array 失败。

const iframe = document.createElement('iframe')
document.body.appendChild(iframe)
const xArray = window.frames[window.frames.length - 1].Array
const arr = new xArray(1, 2, 3) // [1, 2, 3]

// 正确检查 Array
Array.isArray(arr) // true
// arr 的原型是 xArray.prototype，它是一个不同于 Array.prototype 的对象
arr instanceof Array // false

pop()

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

push()

push() 方法将指定的元素添加到数组的末尾，并返回新的数组长度。时间复杂度为 O(1)。

sort()

sort() 方法就地对数组的元素进行排序，并返回对相同数组的引用。默认排序是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序。时间复杂度为 O(n log n)。通常使用经典的快速排序（quicksort）算法。

如果想要不改变原数组的排序方法，可以使用 toSorted()。

sort()
sort(compareFn)

compareFn 可选 定义排序顺序的函数。返回值应该是一个数字，其符号表示两个元素的相对顺序：如果 a 小于 b，返回值为负数，如果 a 大于 b，返回值为正数，如果两个元素相等，返回值为 0。NaN 被视为 0。该函数使用以下参数调用：

a 第一个用于比较的元素。不会是 undefined。

b 第二个用于比较的元素。不会是 undefined。

如果省略该函数，数组元素会被转换为字符串，然后根据每个字符的 Unicode 码位值进行排序。

sort() 方法保留空槽。如果源数组是稀疏的，则空槽会被移动到数组的末尾，并始终排在所有 undefined 元素的后面。

如果提供了 compareFn，所有非 undefined 的数组元素都会按照比较函数的返回值进行排序（所有的 undefined 元素都会被排序到数组的末尾，并且不调用 compareFn）。

compareFn(a, b) 返回值	排序顺序
> 0	a 在 b 后，如 [b, a]
< 0	a 在 b 前，如 [a, b]
=== 0	保持 a 和 b 原来的顺序

join()

join() 时间复杂度为 O(n)。

console.log([1, , 3].join()) // '1,,3'
console.log([1, undefined, 3].join()) // '1,,3'

keys()

keys() 方法返回一个新的数组迭代器对象，其中包含数组中每个索引的键。时间复杂度为 O(n)。

const array1 = ['a', 'b', 'c']
const iterator = array1.keys()

for (const key of iterator) {
  console.log(key) // 0, 1, 2
}

与 Object.keys() 只包含数组中实际存在的键不同，keys() 迭代器不会忽略缺失属性的键。

const arr = ['a', , 'c']
const sparseKeys = Object.keys(arr)
const denseKeys = [...arr.keys()]
console.log(sparseKeys) // ['0', '2']
console.log(denseKeys) // [0, 1, 2]

concat()

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

const array1 = ['a', 'b', 'c']
const array2 = ['d', 'e', , 'f']
const array3 = array1.concat(array2)

console.log(array3) // [ 'a', 'b', 'c', 'd', 'e', undefined, 'f' ]

如果任何源数组是稀疏数组，concat() 方法会保留空槽。

copyWithin()

copyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。时间复杂度为 O(n)。

copyWithin(target)
copyWithin(target, start)
copyWithin(target, start, end)

const array1 = ['a', 'b', 'c', 'd', 'e']
// Copy to index 0 the element at index 3
console.log(array1.copyWithin(0, 3, 4)) // [ 'd', 'b', 'c', 'd', 'e' ]
// Copy to index 1 all elements from index 3 to the end
console.log(array1.copyWithin(1, 3)) // [ 'd', 'd', 'e', 'd', 'e' ]

target

序列开始替换的目标位置，以 0 为起始的下标表示，且将被转换为整数

• 负索引将从数组末尾开始计数——如果 target < 0，则实际是 target + array.length。
• 如果 target < -array.length，则使用 0。
• 如果 target >= array.length，则不会拷贝任何内容。
• 如果 target 位于 start 之后，则复制只会持续到 array.length 结束（换句话说，copyWithin() 永远不会扩展数组）。

start 可选

要复制的元素序列的起始位置，以 0 为起始的下标表示，且将被转换为整数

• 负索引将从数组末尾开始计数——如果 start < 0，则实际是 start + array.length。
• 如果省略 start 或 start < -array.length，则默认为 0。
• 如果 start >= array.length，则不会拷贝任何内容。

end 可选

要复制的元素序列的结束位置，以 0 为起始的下标表示，且将被转换为整数。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。

• 负索引将从数组末尾开始计数——如果 end < 0，则实际是 end + array.length。
• 如果 end < -array.length，则使用 0。
• 如果省略 end 或 end >= array.length，则默认为 array.length，这将导致直到数组末尾的所有元素都被复制。
• 如果 end 位于 start 之前，则不会拷贝任何内容。

every()

every() 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。时间复杂度为 O(n)。

every(callbackFn)
every(callbackFn, thisArg)

callbackFn

为数组中的每个元素执行的函数。它应该返回一个真值以指示元素通过测试，否则返回一个假值。该函数被调用时将传入以下参数：

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

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

array 调用了 every() 的数组本身。

thisArg 可选

执行 callbackFn 时用作 this 的值。

// --------------
//   修 改 元 素
// --------------
let arr = [1, 2, 3, 4]
arr.every((elem, index, arr) => {
  arr[index + 1]--
  console.log(`[${arr}][${index}] -> ${elem}`)
  return elem < 2
})

// 循环会迭代 3 次
// 没有修改的情况下只会迭代 2 次
//
// 第 1 次迭代：[1,1,3,4][0] -> 1
// 第 2 次迭代：[1,1,2,4][1] -> 1
// 第 3 次迭代：[1,1,2,3][2] -> 2

// --------------
//   添 加 元 素
// --------------
arr = [1, 2, 3]
arr.every((elem, index, arr) => {
  arr.push('new')
  console.log(`[${arr}][${index}] -> ${elem}`)
  return elem < 4
})

// 循环迭代 3 次，即使在添加新元素之后
//
// 第 1 次迭代：[1, 2, 3, new][0] -> 1
// 第 2 次迭代：[1, 2, 3, new, new][1] -> 2
// 第 3 次迭代：[1, 2, 3, new, new, new][2] -> 3

// --------------
//   删 除 元 素
// --------------
arr = [1, 2, 3, 4]
arr.every((elem, index, arr) => {
  arr.pop()
  console.log(`[${arr}][${index}] -> ${elem}`)
  return elem < 4
})

// 循环仅迭代 2 次
// 因为剩余的元素被 `pop()` 删除
//
// 第 1 次迭代：[1,2,3][0] -> 1
// 第 2 次迭代：[1,2][1] -> 2

fill()

fill() 方法用一个固定值填充一个数组中从起始索引（默认为 0）到终止索引（默认为 array.length）内的全部元素。它返回修改后的数组。时间复杂度为 O(n)。

fill(value)
fill(value, start)
fill(value, start, end)

start 可选

基于零的索引，从此开始填充，转换为整数。

• 负数索引从数组的末端开始计算，如果 start < 0，则使用 start + array.length。
• 如果 start < -array.length 或 start 被省略，则使用 0。
• 如果 start >= array.length，没有索引被填充。

end 可选

基于零的索引，在此结束填充，转换为整数。fill() 填充到但不包含 end 索引。

• 负数索引从数组的末端开始计算，如果 end < 0，则使用 end + array.length。
• 如果 end < -array.length，则使用 0。
• 如果 end >= array.length 或 end 被省略，则使用 array.length，导致所有索引都被填充。
• 如果经标准化后，end 的位置在 start 之前或之上，没有索引被填充。

filter()

filter() 方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。时间复杂度为 O(n)。

filter(callbackFn)
filter(callbackFn, thisArg)

callbackFn

为数组中的每个元素执行的函数。它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值。该函数被调用时将传入以下参数：

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

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

array 调用了 every() 的数组本身。

thisArg 可选

执行 callbackFn 时用作 this 的值。

• 当开始调用 filter() 时，callbackFn 将不会访问超出数组初始长度的任何元素。
• 对已访问索引的更改不会导致再次在这些元素上调用 callbackFn。
• 如果数组中一个现有的、尚未访问的元素被 callbackFn 更改，则它传递给 callbackFn 的值将是该元素被修改后的值。被删除的元素则不会被访问。

find()

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。时间复杂度为 O(n)。

find(callbackFn)
find(callbackFn, thisArg)

callbackFn

为数组中的每个元素执行的函数。它应该返回一个真值来表示已经找到了匹配的元素。该函数被调用时将传入以下参数：

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

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

array 调用了 every() 的数组本身。

thisArg 可选

执行 callbackFn 时用作 this 的值。

find() 不会改变被调用的数组，但是提供给 callbackFn 的函数可能会改变它。但需要注意的是，在第一次调用 callbackFn 之前，数组的长度会被保存。因此：

• 当调用 find() 时，callbackFn 不会访问超出数组初始长度的任何元素。
• 对已经访问过的索引的更改不会导致再次在这些元素上调用 callbackFn。
• 如果 callbackFn 改变了数组中已存在但尚未被访问的元素，则传递给 callbackFn 的该元素的值将是该元素在被访问时的值。被删除的元素被视为 undefined。

如果需要在数组中找到对应元素的索引，请使用 findIndex()。

findIndex()

findIndex() 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。时间复杂度为 O(n)。

findIndex(callbackFn)
findIndex(callbackFn, thisArg)

callbackFn

为数组中的每个元素执行的函数。它应该返回一个真值以指示已找到匹配元素，否则返回一个假值。该函数被调用时将传入以下参数：

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

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

array调用了 findIndex() 的数组本身。

thisArg 可选

执行 callbackFn 时用作 this 的值。

findLast()

findLast() 方法反向迭代数组，并返回满足提供的测试函数的第一个元素的值。如果没有找到对应元素，则返回 undefined。时间复杂度为 O(n)。

findLastIndex()

findLastIndex() 方法反向迭代数组，并返回满足所提供的测试函数的第一个元素的索引。若没有找到对应元素，则返回 -1。时间复杂度为 O(n)。

flat()

flat() 方法创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中。时间复杂度是 O(n)。

flat()
flat(depth)

depth 可选

指定要提取嵌套数组的结构深度，默认值为 1。

如果待展开的数组是稀疏的，flat() 方法会忽略其中的空槽。

const arr5 = [1, 2, , 4, 5]
console.log(arr5.flat()) // [1, 2, 4, 5]

const array = [1, , 3, ['a', , 'c']]
console.log(array.flat()) // [ 1, 3, "a", "c" ]

const array2 = [1, , 3, ['a', , ['d', , 'e']]]
console.log(array2.flat()) // [ 1, 3, "a", ["d", empty, "e"] ]
console.log(array2.flat(2)) // [ 1, 3, "a", "d", "e"]

some()

some() 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回 true；否则返回 false。它不会修改数组。时间复杂度为 O(n)。

forEach()

forEach() 方法对数组的每个元素执行一次给定的函数。时间复杂度是 O(n)。

forEach(callbackFn)
forEach(callbackFn, thisArg)

callbackFn

为数组中每个元素执行的函数。并会丢弃它的返回值。该函数被调用时将传入以下参数：

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

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

array 调用了 forEach() 的数组本身。

thisArg 可选

执行 callbackFn 时用作 this 的值。

forEach() 不会改变其调用的数组，但是，作为 callbackFn 的函数可以更改数组。请注意，在第一次调用 callbackFn 之前，数组的长度已经被保存。因此：

• 当调用 forEach() 时，callbackFn 不会访问超出数组初始长度的任何元素。
• 已经访问过的索引的更改不会导致 callbackFn 再次调用它们。
• 如果 callbackFn 更改了数组中已经存在但尚未访问的元素，则传递给 callbackFn 的值将是在访问该元素时的值。已经被删除的元素不会被访问。

除非抛出异常，否则没有办法停止或中断 forEach() 循环。

map()

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

map(callbackFn)
map(callbackFn, thisArg)

callbackFn

为数组中的每个元素执行的函数。它的返回值作为一个元素被添加为新数组中。该函数被调用时将传入以下参数：

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

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

array 调用了 map() 的数组本身。

thisArg 可选

执行 callbackFn 时用作 this 的值。

reduce()

reduce() 时间复杂度为 O(n)。

reduce(callbackFn)
reduce(callbackFn, initialValue)

callbackFn

为数组中每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。该函数被调用时将传入以下参数：

accumulator 上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为 array[0] 的值。

currentValue 当前元素的值。在第一次调用时，如果指定了 initialValue，则为 array[0] 的值，否则为 array[1]。

currentIndex currentValue 在数组中的索引位置。在第一次调用时，如果指定了 initialValue 则为 0，否则为 1。

array 调用了 reduce() 的数组本身。

initialValue 可选

第一次调用回调时初始化 accumulator 的值。如果指定了 initialValue，则 callbackFn 从数组中的第一个值作为 currentValue 开始执行。如果没有指定 initialValue，则 accumulator 初始化为数组中的第一个值，并且 callbackFn 从数组中的第二个值作为 currentValue 开始执行。在这种情况下，如果数组为空（没有第一个值可以作为 accumulator 返回），则会抛出错误。

reduceRight()

reduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。时间复杂度为 O(n)。

reduceRight(callbackFn)
reduceRight(callbackFn, initialValue)

callbackFn

为数组中的每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将成为 reduceRight() 的返回值。该函数被调用时将传入以下参数：

accumulator 上一次调用 callbackFn 的结果。在第一次调用时，如果指定了 initialValue 则为指定的值，否则为数组最后一个元素的值。

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

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

array 调用了 reduceRight() 的数组本身。

initialValue 可选

首次调用 callbackFn 时累加器的值。如果不提供初始值，则将使用数组中的最后一个元素，并在迭代时跳过它。没有初始值的情况下，在空数组上调用 reduceRight() 会产生 TypeError。

数组转成嵌套对象 ["a","b","c","d"] => {a: {b: {c: {d: null}}}}

const fun = (arr) => {
  return arr.reduceRight((acc, cur) => {
    return {
      [cur]: acc
    }
  }, null)
}

shift()

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

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

unshift()

unshift() 方法将指定元素添加到数组的开头，并返回数组的新长度。时间复杂度为 O(n)。

slice()

slice() 方法返回一个新的数组对象，这一对象是一个由 start 和 end 决定的原数组的浅拷贝（包括 start，不包括 end），其中 start 和 end 代表了数组元素的索引。原始数组不会被改变。时间复杂度为 O(n)。

start 可选

提取起始处的索引（从 0 开始），会转换为整数。

• 如果索引是负数，则从数组末尾开始计算——如果 start < 0，则使用 start + array.length。
• 如果 start < -array.length 或者省略了 start，则使用 0。
• 如果 start >= array.length，则不提取任何元素。

end 可选

提取终止处的索引（从 0 开始），会转换为整数。slice() 会提取到但不包括 end 的位置。

• 如果索引是负数，则从数组末尾开始计算——如果 end < 0，则使用 end + array.length。
• 如果 end < -array.length，则使用 0。
• 如果 end >= array.length 或者省略了 end，则使用 array.length，提取所有元素直到末尾。
• 如果 end 在规范化后小于或等于 start，则不提取任何元素。

slice() 方法会保留空槽。如果被切片的部分是稀疏的，则返回的数组也是稀疏的。

toString()

toString() 方法返回一个字符串，表示指定的数组及其元素。时间复杂度为 O(n)。

splice()

splice() 方法就地移除或者替换已存在的元素和/或添加新的元素。时间复杂度为 O(n)。

要创建一个删除和/或替换部分内容而不改变原数组的新数组，请使用 toSpliced()。要访问数组的一部分而不修改它，参见 slice()。

splice(start)
splice(start, deleteCount)
splice(start, deleteCount, item1)
splice(start, deleteCount, item1, item2)
splice(start, deleteCount, item1, item2, /* …, */ itemN)

const months = ['Jan', 'March', 'April', 'June']
months.splice(1, 0, 'Feb')
// Inserts at index 1
console.log(months) // [ 'Jan', 'Feb', 'March', 'April', 'June' ]

months.splice(4, 1, 'May')
// Replaces 1 element at index 4
console.log(months) // [ 'Jan', 'Feb', 'March', 'April', 'May' ]

返回值

一个包含了删除的元素的数组。如果只移除一个元素，则返回一个元素的数组。如果没有删除任何元素，则返回一个空数组。

toLocaleString()

toLocaleString() 方法返回一个字符串，表示数组中的所有元素。每个元素通过调用它们自己的 toLocaleString 方法转换为字符串，并且使用特定于语言环境的字符串（例如逗号“,”）分隔开。时间复杂度为 O(n)。

toLocaleString()
toLocaleString(locales)
toLocaleString(locales, options)

const array1 = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')]
const localeString = array1.toLocaleString('en', { timeZone: 'UTC' })

console.log(localeString) // '1,a,12/21/1997, 2:12:00 PM'

如果一个元素是 undefined、null，它会被转换为空字符串，而不是 "null" 或者 "undefined"。

当用于稀疏数组时，toLocaleString() 方法迭代时会把空槽当作 undefined 一样处理它。

toLocaleString() 方法是通用的。它只期望 this 值具有 length 属性和整数键属性。

from()

Array.from() 静态方法从可迭代或类数组对象创建一个新的浅拷贝的数组实例。时间复杂度为 O(n)。

Array.from(arrayLike)
Array.from(arrayLike, mapFn)
Array.from(arrayLike, mapFn, thisArg)

mapFn 可选

调用数组每个元素的函数。如果提供，每个将要添加到数组中的值首先会传递给该函数，然后将 mapFn 的返回值增加到数组中。使用以下参数调用该函数：

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

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

thisArg 可选

执行 mapFn 时用作 this 的值。

Array.from() 绝不会创建稀疏数组。如果 arrayLike 对象缺少一些索引属性，那么这些属性在新数组中将是 undefined。

includes()

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

includes(searchElement)
includes(searchElement, fromIndex)

fromIndex 可选

开始搜索的索引（从零开始），会转换为整数。

• 负索引从数组末尾开始计数——如果 fromIndex < 0，那么实际使用的是 fromIndex + array.length。然而在这种情况下，数组仍然从前往后进行搜索。
• 如果 fromIndex < -array.length 或者省略 fromIndex，则使用 0，这将导致整个数组被搜索。
• 如果 fromIndex >= array.length，则不会搜索数组并返回 false。

描述

includes() 方法使用零值相等(零值相等与严格相等的区别在于其将 NaN 视作是相等的，与同值相等的区别在于其将 -0 和 0 视作相等的。)算法将 searchElement 与数组中的元素进行比较。0 值都被认为是相等的，不管符号是什么。（即 -0 等于 0），但 false 不被认为与 0 相同。NaN 可以被正确搜索到。

当在稀疏数组上使用时，includes() 方法迭代空槽，就像它们的值是 undefined 一样。

includes() 方法是通用的。它只期望 this 值具有 length 属性和整数键属性。

indexOf()

indexOf() 方法返回数组中第一次出现给定元素的下标，如果不存在则返回 -1。时间复杂度为 O(n)。

indexOf(searchElement)
indexOf(searchElement, fromIndex)

const beasts = ['ant', 'bison', 'camel', 'duck', 'bison']

console.log(beasts.indexOf('bison')) // 1
// Start from index 2
console.log(beasts.indexOf('bison', 2)) // 4
console.log(beasts.indexOf('giraffe')) // -1

fromIndex 可选

开始搜索的索引（从零开始），会转换为整数。

• 负索引从数组末尾开始计数——如果 frommindex < 0，使用 frommindex + array.length。注意，在这种情况下，仍然从前到后搜索数组。
• 如果 fromIndex < -array.length 或者省略了 fromIndex ，将使用 0，而导致整个数组被搜索。
• 如果 fromIndex >= array.length，数组不会继续搜索并返回 -1。

描述

indexOf() 使用严格相等（与 === 运算符使用的算法相同）将 searchElement 与数组中的元素进行比较。NaN 值永远不会被比较为相等，因此当 searchElement 为 NaN 时 indexOf() 总是返回 -1。

indexOf() 方法会跳过稀疏数组中的空槽。

indexOf() 方法是通用的。它只期望 this 值具有 length 属性和整数键属性。

lastIndexOf()

lastIndexOf() 方法返回数组中给定元素最后一次出现的索引，如果不存在则返回 -1。该方法从 fromIndex 开始向前搜索数组。 时间复杂度为 O(n)。

lastIndexOf(searchElement)
lastIndexOf(searchElement, fromIndex)

const animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo']

console.log(animals.lastIndexOf('Dodo')) // 3
console.log(animals.lastIndexOf('Tiger')) // 1

fromIndex 可选

以 0 起始的索引，表明反向搜索的起始位置，会被转换为整数。

• 如果 fromIndex < 0，则从数组末尾开始倒数计数——即使用 fromIndex + array.length 的值。
• 如果 fromIndex < -array.length，则不搜索数组并返回 -1。从概念上讲，你可以把它想象成从数组开始之前不存在的位置开始反向搜索，这条路径上没有任何数组元素，因此 searchElement 永远不会被找到。
• 如果 fromIndex >= array.length 或者省略了 fromIndex，则使用 array.length - 1，这会导致搜索整个数组。可以将其理解为从数组尾部之后不存在的位置开始向前搜索。最终会访问到数组最后一个元素，并继续向前开始实际搜索数组元素。

描述

lastIndexOf 使用严格相等（与 === 运算符使用的算法相同）比较 searchElement 和数组中的元素。NaN 值永远不会被比较为相等，因此当 searchElement 为 NaN 时 lastIndexOf() 总是返回 -1。

lastIndexOf() 方法会跳过稀疏数组中的空槽。

lastIndexOf() 方法是通用的。它只期望 this 值具有 length 属性和整数键属性。