ES6数组的扩展

构造器上新增的方法

• Array.of()，弥补了原本 Array 创建数组时传入一个参数的缺陷。

  console.log(Array()); // -> []
  console.log(Array.of()); // -> []
      
  // Array()传入的参数为一个时，指定的是数组的长度为 3
  console.log(Array(3)); // -> [empty × 3]
  console.log(Array.of(3)); // -> [3]
      
  console.log(Array(1, 2)); // -> [1, 2]
  console.log(Array.of(1, 2)); // -> [1, 2]
  

• Array.from()，可以将类数组转和部署了iterator接口的对象转换为数组。可接收三个参数，第一个参数为arrayLike，要转换为数组的对象，第二个可选参数，mapFn，将转换成的数组进行二次处理，第三个可选参数改变this指向，后两个参数一般不会用到。

  function foo (a, b, c, d) {
    console.log(arguments); // -> Arguments(4) [1, 2, 3, 4, callee: ƒ, Symbol(Symbol.iterator): ƒ]
    arguments = Array.from(arguments);
    console.log(arguments); // -> [1, 2, 3, 4]
  }
  foo(1, 2, 3, 4);
      
  let obj = {
    start: [1, 2, 3],
    end: [4, 5],
    [Symbol.iterator] () {
      let index = 0,
          arr = [...this.start, ...this.end],
          len = arr.length;
      return {
        next () {
          if(index < len){
            return {value: arr[index++], done: false}
          }else{
            return {value: undefined, done: true}
          }
        }
      }
    }
  }
  console.log(Array.from(obj)); // -> [1, 2, 3, 4, 5]
  

原型上新增的方法

• [].fill(value, start, end)，填充数组(改变原始数组)，第一个参数为指定填充的值，后两个参数无指定，默认填充整个数组。第二个参数为开始填充的索引（默认值为0）包含当前索引，第三个参数为结束填充的索引（默认值为this.length）不包含当前索引。

  let arr = [1, 2, 3, 4];
  arr.fill(5);
  console.log(arr); // -> [5, 5, 5, 5]
      
  arr.fill(5, 1);
  console.log(arr); // -> [1, 5, 5, 5]
      
  arr.fill(5, 1, 2);
  console.log(arr); // -> [1, 5, 3, 4]
      
  // 注意：这种方式对象也可以调用
  let obj = {
    length: 3
  };
  [].fill.call(obj, 4);
  console.log(obj); // ->  {0: 4, 1: 4, 2: 4, length: 3}
  

• [].keys() / values() / entries()，返回值是一个遍历器（iterator）对象，就可以使用for of 遍历当前对应的值。

• 注意： 与Object.keys() / values() / entries()的区别，对象构造器上的方法返回的是数组，而这里返回的是遍历器（iterator）对象。

  let arr = ['a', 'b', 'c'];
  console.log(arr.keys()); // -> Array Iterator {}
  console.log(arr.values()); // -> Array Iterator {}
  console.log(arr.entries()); // -> Array Iterator {}
      
  let iter = arr.values();
  console.log(iter.next()); // -> {value: 'a', done: false}
  console.log(iter.next()); // -> {value: 'b', done: false}
  console.log(iter.next()); // -> {value: 'c', done: false}
  console.log(iter.next()); // -> {value: undefined, done: true}
      
  for(let item of arr.entries()){
    console.log(item); // -> [0, 'a'] [1, 'b'] [2, 'c']
  }
  

• [].find() / findIndex()，与map()等方法的使用方式一致，但返回值不同，返回的是当前符合回调函数条件的第一个成员，没有返回undefined，findeIndex()，返回的是第一个符合条件成员的索引，没有返回-1。

  let arr = [1, 2, 3, 4];
  let res = arr.find((value, index, arr) => {
    return value > 2;
  })
  console.log(res); // -> 3
      
  let idx = arr.findIndex(value => value > 2); 
  console.log(idx); // -> 2
      
  // 改善了indexOf() 的缺陷
  console.log([NaN].indexOf(NaN)); // -> -1
      
  console.log([NaN].findIndex(val => Object.is(NaN, val))); // -> 0
  

• [].includes()，查询数组中是否包含传入的参数，返回一个布尔值。

  console.log([1, 2, 4, NaN].includes(3)); // -> false
      
  console.log([1, 2, 4, NaN].includes(NaN)); // -> true