扩展运算符（...）

它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。

const arr = [ ...(1 > 0 ? [1] :  []), 'b' ]     // [1, 'b']

[ ...[], 1 ]        // [1]

Math.max(...[14, 3, 45])    // 接受一个参数序列而不是数组

应用

• 合并数组

[1, 2, [3, 4]]

• 与解构赋值结合

const [first, ...rest] = [1,2,3]
// first 1
// rest [2,3]

• 处理字符串

[...'hello']  // ['h', 'e', 'l' , 'l', 'o']

'𠮷'.length // 2
[..."𠮷"].length  // 1

Array.from()

用于将两类对象转为真正的数组：类似数组的对象（array-like-object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。 第一个参数是要处理的类似数组的对象，第二个参数是对每个元素处理的函数

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};
const arr = Array.from(ArrayLike) // ['a','b','c']

DOM 操作返回的 NodeList 以及函数内部的 arguments 对象都是类似数组的对象，可以使用 Array.from()转换为数组

应用

Array.from({ length: 2 }, () => 'jack' )    // ['jack', 'jack']

Array.of()

将一组值转换为数组，替代 Array()或 new Array()

Array.of(1,2,3) // [1,2,3]

copyWithin

在当前数组内部将指定位置的成员复制到其他位置，覆盖原有成员。接受 3 个参数：

• target（必需）：从该位置开始替换数据
• start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数
• end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数

[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]

[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
// [4, 2, 3, 4, 5]

find() 和 findIndex()

find()查找当前数组中第一个符合条件的数组成员，没有找到是返回 undefined。 findIndex()返回索引，没找到返回-1。它们的第一个参数是一个回调函数，回调函数有三个参数，以此为当前值当前位置，原数组。 第二个参数用来绑定回调函数的 this 对象。

fill()

使用给定值填充一个数组，数组中已有的值会被全部抹去。参数依次为要填充的值，起始位置，结束位置。

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

entries(), keys(), values()

ES6 提供三个新的方法—— entries() ， keys() 和 values() ——用于遍历数组。它们都返回一个遍历器对象，可以 用 for...of 循环进行遍历，唯一的区别是 keys() 是对键名的遍历、 values() 是对键值的遍历， entries() 是对键值对的遍历。

for (let index of ['a', 'b'].keys()) {
    console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
    console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
    console.log(index, elem);
}
// 0 "a"
// 1 "b"

手动调用遍历器的 next()方法

let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']

includes() => boolean

返回一个布尔值表示是否包含给定值，第一个参数为查找元素，第二个为起始位置

数组空位

ES6 将空位转为 undefined

Array(3) // [, , ,]

filter(callback[, thisObject]) => any[]

参数：

• callback: 数组中每个元素都会执行的函数，有三个参数
  • element：当前元素
  • index：当前元素索引
  • array：当前数组对象
• thisObject：回调函数内部的 this 对象

[1,2,3,4].filter(item => item > 2) // [3,4]

map(callback) => any[]

遍历每一个元素，返回新数组。 参数：

• callback: 数组中每个元素都会执行的函数，有三个参数
  • element：当前元素
  • index：当前元素索引
  • array：当前数组对象

some(callback) => boolean

对每一个元素执行一次回调函数，直到此函数返回 true，some 将返回 true,如果每个元素执行后都返回 false，some 将返回 false 参数：

• callback: 数组中每个元素都会执行的函数，有三个参数
  • element：当前元素
  • index：当前元素索引
  • array：当前数组对象

[1,2,3,4].some(item => item >=3) // true
[1,2,3,4].some(item => item >=5) // false

every(callback) => boolean

对每一个元素执行一次回调函数，直到此函数返回 false，every 将返回 false，如果每个元素执行后都返回 true，every 将返回 false 参数：

• callback: 数组中每个元素都会执行的函数，有三个参数
  • element：当前元素
  • index：当前元素索引
  • array：当前数组对象

[1,2,3,4].every(item => item >=3) // false
[1,2,3,4].every(item => item >=1) // true

flat(number) => any[]

按照指定的深度(number)递归遍历数组，返回新数组

[1, 2, [3, 4, [5, 6]]].flat() // [1, 2, 3, 4, [5, 6]]
[1, 2, [3, 4, [5, 6]]].flat(2) // [1, 2, 3, 4, 5, 6]

flatMap()

[1, 2, 3, 4].flatMap(item => [item * 2]) // [2, 4, 6, 8]
[1, 2, 3, 4].flatMap(item => [[item * 2]]) // [[2], [4], [6], [8]]