Array

Array

Array.length

返回或设置一个数组中的元素个数

Array.from()

• 描述：从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例
  • 伪数组对象（拥有一个 length 属性和若干索引属性的任意对象）
  • 可迭代对象（可以获取对象中的元素,如 Map和 Set 等）
• 语法：Array.from(arrayLike[, mapFn[, thisArg]])
• 参数
  • arrayLike：想要转换成数组的伪数组对象或可迭代对象
  • mapFn（可选）：如果指定了该参数，新数组中的每个元素会执行该回调函数
  • thisArg（可选）：执行回调函数 mapFn 时 this 对象
• 返回值：一个新的数组实例

Array.isArray()

• 描述：于确定传递的值是否是一个 Array
• 语法：Array.isArray(obj)
• 参数
  • obj：需要检测的值
• 返回值：如果值是 Array，则为 true，否则为 false

Array.of()

• 描述：创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型
• 语法：Array.of(element0[, element1[, ...[, elementN]]])
• 参数
  • elementN：任意个参数，将按顺序成为返回数组中的元素
• 返回值：新的 Array 实例

// 旧版本兼容
if (!Array.of) {
  Array.of = function() {
    return Array.prototype.slice.call(arguments);
  };
}

Array.prototype.concat()

• 描述：用于合并两个或多个数组，此方法不会更改现有数组
• 语法：var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
• 参数
  • valueN：数组和/或值，将被合并到一个新的数组中
    • 如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝
• 返回值：新的 Array 实例

Array.prototype.copyWithin()

• 描述：浅拷贝数组的一部分到同一数组中的另一个位置（按顺序依次覆盖）
• 语法：arr.copyWithin(target[, start[, end]])
• 参数
  • target：0 为基底的索引，复制序列到该位置
    • 如果是负数，target 将从末尾开始计算
    • 如果 target 大于等于 arr.length，将会不发生拷贝
    • 如果 target 在 start 之后，复制的序列将被修改以符合 arr.length。
  • start：0 为基底的索引，开始复制元素的起始位置
    • 如果是负数，start 将从末尾开始计算
    • 如果 start 被忽略，copyWithin 将会从0开始复制
  • end：0 为基底的索引，开始复制元素的结束位置
    • copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素
    • 如果是负数， end 将从末尾开始计算
    • 如果 end 被忽略，copyWithin 方法将会一直复制至数组结尾（默认为 arr.length）
• 返回值：改变后的数组

Array.prototype.every()

• 描述：测试一个数组内的所有元素是否都能通过某个指定函数的测试
• 语法：arr.every(callback(element[, index[, array]])[, thisArg])
• 参数
  • callback：用来测试每个元素的函数，它可以接收三个参数
    • element：用于测试的当前值
    • index：用于测试的当前值的索引
    • array：调用 every 的当前数组
  • thisArg：执行 callback 时使用的 this 值
• 返回值：如果回调函数的每一次返回都为 truthy 值，返回 true ，否则返回 false

Array.prototype.fill()

• 描述：用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引
• 语法：arr.fill(value[, start[, end]])
• 参数
  • value：用来填充数组元素的值
  • start：起始索引，默认值为 0
  • end：终止索引，默认值为 this.length
• 返回值：修改后的数组**（改变原数组）**

Array.prototype.filter()

• 描述：创建一个新数组, 其包含通过所提供函数实现的测试的所有元素（浅拷贝）
• 语法：var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
• 参数
  • callback：用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：调用了 filter 的数组本身
  • thisArg：执行 callback 时，用于 this 的值
• 返回值：一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组

Array.prototype.find()

• 描述：返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined
• 语法：arr.find(callback[, thisArg])
• 参数
  • callback：在数组每一项上执行的函数，接收 3 个参数
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：数组本身
  • thisArg：执行 callback 时，用于 this 的值

Array.prototype.findIndex()

• 描述：返回数组中满足提供的测试函数的第一个元素的索引，若没有找到对应元素则返回 -1
• 语法：arr.findIndex(callback[, thisArg])
• 参数
  • callback：在数组每一项上执行的函数，接收 3 个参数
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：数组本身
  • thisArg：执行 callback 时，用于 this 的值

Array.prototype.some()

• 描述：测试数组中是不是至少有1个元素通过了被提供的函数测试
• 语法：arr.some(callback(element[, index[, array]])[, thisArg])
• 参数
  • callback：在数组每一项上执行的函数，接收 3 个参数
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：数组本身
  • thisArg：执行 callback 时，用于 this 的值
• 返回值：数组中有至少一个元素通过回调函数的测试就会返回 true，所有元素都没有通过回调函数的测试返回值才会为false

Array.prototype.flat()

• 描述：按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回
• 语法：var newArray = arr.flat([depth])
• 参数
  • depth ：指定要提取嵌套数组的结构深度，默认值为 1
• 返回值：一个包含将数组与子数组中所有元素的新数组

Array.prototype.flatMap()

• 描述：首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 连着深度值为1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些

• 语法

  var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
      // return element for new_array
  }[, thisArg])
  

• 参数

  • callback：在数组每一项上执行的函数，接收 3 个参数
    • currentValue：当前正在数组中处理的元素
    • index：正在处理的元素在数组中的索引
    • array：被调用的 map 数组
  • thisArg：执行 callback 时，用于 this 的值

• 返回值： 一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为 1

Array.prototype.forEach()

• 描述：对数组的每个元素执行一次给定的函数
• 语法：arr.forEach(callback(currentValue [, index [, array]])[, thisArg])
• 参数
  • callback：在数组每一项上执行的函数，接收 3 个参数
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：数组本身
  • thisArg：执行 callback 时，用于 this 的值
• 返回值：undefined
• 注意
  • 不对未初始化的值进行任何操作 [1,,2,,3]

Array.prototype.includes()

• 描述：判断一个数组是否包含一个指定的值
• 语法：arr.includes(valueToFind[, fromIndex])
• 参数
  • valueToFind：需要查找的元素值
  • fromIndex：从fromIndex 索引处开始查找 valueToFind
    • 如果为负值，则按升序从 array.length + fromIndex 的索引开始搜，默认为 0。
• 返回值：如果包含则返回 true，否则返回false
• 注意
  • 可以检测 NaN
  • 严格检测 ===
    
    

Array.prototype.indexOf()

• 描述：返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回 -1
• 语法：arr.indexOf(searchElement[, fromIndex])
• 参数
  • searchElement：要查找的元素
  • fromIndex：开始查找的位置
    • 如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回 -1
    • 如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索，默认为 0
• 注意
  • 不可以检测 NaN
  • 严格检测 ===
    
    

Array.prototype.lastIndexOf()

• 描述：返回指定元素在数组中最后一次出现的索引，如果不存在，则返回 -1
• 语法：arr.lastIndexOf(searchElement[, fromIndex])
• 参数
  • searchElement：要查找的元素
  • fromIndex：从此位置开始逆向查找，默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找
    • 如果该索引值大于或等于数组长度，则整个数组会被查找
    • 如果为负值，则按升序从 array.length + fromIndex 的索引开始向左搜索

Array.prototype.join()

• 描述：方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串
• 语法：arr.join([separator])
• 参数
  • separator ：指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。
    • 如果缺省该值，数组元素用逗号（,）分隔
    • 如果separator是空字符串("")，则所有元素之间都没有任何字符。
• 返回值：个所有数组元素连接的字符串。如果 arr.length 为 0，则返回空字符串

Array.prototype.entries()

• 描述：返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对
• 语法：arr.entries()
• 返回值：一个新的 Array 迭代器对象。Array Iterator是对象，它的原型（__proto__:Array Iterator）上有一个next方法，可用用于遍历迭代器取得原数组的[key,value]

Array.prototype.keys()

• 描述：返回一个包含数组中每个索引键的 Array Iterator 对象
• 语法：arr.keys()

Array.prototype.values()

• 描述： 返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
• 语法：arr.values()

Array.prototype.map()

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

• 语法

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

• 参数

  • callback：在数组每一项上执行的函数，接收 3 个参数
    • element：数组中当前正在处理的元素
    • index：正在处理的元素在数组中的索引
    • array：数组本身
  • thisArg：执行 callback 时，用于 this 的值

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

Array.prototype.reduce()

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

• 语法：arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

• 参数

  • callback：执行数组中每个值 (如果没有提供 initialValue 则第一个值除外)的函数，包含四个参数
    • accumulator：累计器累计回调的返回值
      • 它是上一次调用回调时返回的累积值，或initialValue
    • currentValue：数组中正在处理的元素
    • index：数组中正在处理的当前元素的索引
      • 如果提供了initialValue，则起始索引号为 0，否则从索引 1 起始
    • array：调用 reduce() 的数组
  • initialValue：作为第一次调用 callback 函数时的第一个参数的值
    • 如果没有提供初始值，则将使用数组中的第一个元素，并跳过该元素
    • 在没有初始值的空数组上调用 reduce 将报错

• 返回值：函数累计处理的结果

var arr = [1, 2, 3, 4, 5];
var sum = arr.reduce(function (accumulator, currentValue, index) {
    return accumulator + currentValue;
}, 10)
console.log(sum)

Array.prototype.reduceRight()

• 描述：接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。

• 语法：arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])

• 参数

  • callback：执行数组中每个值，包含四个参数
    • accumulator：累计器累计回调的返回值
      • 它是上一次调用回调时返回的累积值，或 initialValue
    • currentValue：数组中正在处理的元素
    • index：数组中正在处理的当前元素的索引
    • array：调用 reduce() 的数组
  • initialValue：作为第一次调用 callback 函数时的第一个参数的值
    • 如果没有提供初始值，则将使用数组中的最后一个元素，并跳过该元素
    • 在没有初始值的空数组上调用 reduce 将报错

• 返回值：函数累计处理的结果

Array.prototype.unshift()

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

• 语法：arr.unshift(element1, ..., elementN)

• 参数

  • elementN：被添加到数组开头的元素

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

Array.prototype.shift()

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

• 语法：arr.shift()

• 返回值：从数组中删除的元素（ 当数组为空时返回 undefined ）

Array.prototype.push()

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

• 语法：arr.push(element1, ..., elementN)

• 参数

  • elementN：被添加到数组末尾的元素

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

Array.prototype.pop()

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

• 语法：arr.pop()

• 返回值：从数组中删除的元素（ 当数组为空时返回 undefined ）

Array.prototype.slice()

• 描述：返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end），原始数组不会被改变

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

• 参数

  • begin：从该索引开始提取原数组元素
    • 如果省略 begin，则 slice 从索引 0 开始
    • 如果为负值，则按升序从 array.length + fromIndex 的索引开始
    • 如果 begin 大于原数组的长度，则会返回空数组
  • end：在该索引处结束提取原数组元素
    • 如果省略 end 或者 end 大于数组的长度，则 slice 会一直提取到原数组末尾
    • 如果为负值，则按升序从 array.length + fromIndex 的索引结束

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

Array.prototype.splice()

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

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

• 参数

  • start：指定修改的开始位置（从0计数）
    • 如果超出了数组的长度，则从数组末尾开始添加内容
    • 如果为负值，则按升序从 array.length + fromIndex 的索引开始添加内容
    • 负数的绝对值大于数组的长度，则表示开始位置为第 0 位
  • deleteCount：整数，表示要移除的数组元素的个数
    • 如果 deleteCount 被省略了 或者 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）
    • deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素（否则没有意义）
  • item1, item2, ...：要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素

• 返回值：由被删除的元素组成的一个数组

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

Array.prototype.sort()

• 描述：元素按照转换为的字符串的各个字符的 Unicode 位点进行排序

• 语法：arr.sort([compareFunction])

• 参数

  • compareFunction：用来指定按某种顺序进行排列的函数
    • firstEl：第一个用于比较的元素
    • secondEl：第二个用于比较的元素
    • compareFunction(firstEl, secondEl) 小于 0 ，那么 firstEl 会被排列到 secondEl 之前
    • compareFunction(firstEl, secondEl) 大于 0 ， secondEl 会被排列到 firstEl 之前

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

Array.prototype.reverse()

• 描述：将数组中元素的位置颠倒，并返回该数组，该方法会改变原数组

• 语法：arr.reverse()

• 参数

  • compareFunction：用来指定按某种顺序进行排列的函数
    • firstEl：第一个用于比较的元素
    • secondEl：第二个用于比较的元素
    • compareFunction(firstEl, secondEl) 小于 0 ，那么 firstEl 会被排列到 secondEl 之前
    • compareFunction(firstEl, secondEl) 大于 0 ， secondEl 会被排列到 firstEl 之前

• 返回值：颠倒后的数组

Array.prototype.toString()

• 描述： 返回一个字符串，表示指定的数组及其元素
• 语法：arr.toString()
• 返回值：一个表示指定的数组及其元素的字符串