es6 数组新增哪些方法以及使用场景

参考 : https://es6.ruanyifeng.com/#docs/array
1.扩展运算符

console.log(...[1, 2, 3])
// 1 2 3

console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5

[...document.querySelectorAll('div')]
// [<div>, <div>, <div>]

[...'hello']
// ['h', 'e', 'l', 'l', 'o']
'hello'.split('')
// ['h', 'e', 'l', 'l', 'o']

1. Array.from()
   ```js
   let arrayLike = {
   '0': 'a',
   '1': 'b',
   '2': { a : 'a'},
   length: 3
   };

// ES5 的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6 的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

arr2[2].a = 1000 // 查看arrayLike,也同步改了, 说明是浅拷贝

4 . Array.of
```js
// 方法用于将一组值，转换为数组
// Array.of()基本上可以用来替代Array()或new Array()，并且不存在由于参数不同而导致的重载。它的行为非常统一。

Array.of() // []
Array.of(undefined) // [undefined]
Array.of(1) // [1]
Array.of(1, 2) // [1, 2]
// Array.of()总是返回参数值组成的数组。如果没有参数，就返回一个空数组。

// Array.of()方法可以用下面的代码模拟实现。

function ArrayOf(){
  return [].slice.call(arguments);
}

参考 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin

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

// 将3号位复制到0号位
let arr = [1, 2, 3, {
    a : 4 , b : 444}, 5]
    arr.copyWithin(0, 3, 4)
arr[3].b = '浅拷贝?'
// 查看arr 都会同步变化,是浅复制

1. 实例方法 find() 与 findIndex()
   数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

数组实例的findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1

[1, 5, 10, 15].findIndex(function(value, index, arr) {
   
  return value > 9;
}) // 2
// 另外，这两个方法都可以发现NaN，弥补了数组的indexOf方法的不足
[NaN].indexOf(NaN)
// -1

[NaN].findIndex(y => Object.is(NaN, y))
// 0

1. fill
   ```js
   fill方法使用给定值，填充一个数组。

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

new Array(3).fill(7)
// [7, 7, 7]

let arrayLike = {
'0': 'a',
'1': 'b',
'2': { a : 'a'},
length: 3
};

Array.from(arrayLike).fill(10) // ['a', 'b', 'c']

7. 实例方法：entries，keys-和-values
```js
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"

1. includs
   ```js
   [1, 2, 3].includes(2) // true
   [1, 2, 3].includes(4) // false
   [1, 2, NaN].includes(NaN) // true

 indexOf方法有两个缺点，一是不够语义化，它的含义是找到参数值的第一个出现位置，
所以要去比较是否不等于-1，表达起//来不够直观。二是，它内部使用严格相等运算符（===）进行判断，这会导致对NaN的误判。
```js
[NaN].indexOf(NaN)
// -1

1. flat() , flatMap()
   ```js
   //如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。

[1, [2, [3]]].flat(Infinity)
// [1, 2, 3]

flatMap()方法对原数组的每个成员执行一个函数（相当于执行Array.prototype.map()），
然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组。
```js
// 相当于 [[2, 4], [3, 6], [4, 8]].flat()
[2, 3, 4].flatMap((x) => [x, x * 2])
// [2, 4, 3, 6, 4, 8]

10 . at()
长久以来，JavaScript 不支持数组的负索引，如果要引用数组的最后一个成员，不能写成arr[-1]，只能使用arr[arr.length - 1]。

const arr = [5, 12, 8, 130, 44];
arr.at(2) // 8
arr.at(-2) // 130
arr.at() // 5  ,默认第一个
arr.at(6) // undefined ,大于数组长度