Array.Fill

使用制定的元素填充数组，其实就是用默认内容初始化数组

console.log([1, 'a', undefined].fill(7));//数组所有值替换为7
console.log(['a', 'b', 'c'].fill(7, 1, 3));//数组从下标1-3替换为7

判断空对象

if(!cart || JSON.stringify(cart)=="{}"){  }

Array.from 类数组对象转换成数组

Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。
那么什么是类数组对象呢？所谓类数组对象，最基本的要求就是具有length属性的对象。

1、将类数组对象转换为真正数组：
let arrayLike = {
    0: 'tom', 
    1: '65',
    2: '男',
    3: ['jane','john','Mary'],
    'length': 4
}
let arr = Array.from(arrayLike)
console.log(arr) // ['tom','65','男',['jane','john','Mary']]

 let arrayLike = {
        '1': 'tom',
        '2': '65',
        '4': ['jane', 'john', 'Mary'],
        length: 6
      }
      let arr = Array.from(arrayLike)
      console.log(arr)   // [undefined, "tom", "65", undefined, ["jane", "john", "Mary"], undefined]

let obj={
        0:'a',
        1:'b',
        2:'c'
      }
      console.log(Array.from(obj)) //[]
      obj['length']=3
      console.log(Array.from(obj)) // ["a", "b", "c"]

那么，如果将上面代码中length属性去掉呢？实践证明，答案会是一个长度为0的空数组。
这里将代码再改一下，就是具有length属性，但是对象的属性名不再是数字类型的，而是其他字符串型的，代码如下：

  {
      let arrayLike = {
        'name': 'tom',
        'age': '65',
        'sex': '男',
        'friends': ['jane', 'john', 'Mary'], 
      }
      let arr = Array.from(arrayLike)
      console.log(arr)   // []
    }
    {
      let arrayLike = {
        'name': 'tom',
        'age': '65',
        'sex': '男',
        'friends': ['jane', 'john', 'Mary'],
        'length': 4
      } 
      let arr = Array.from(arrayLike)
      console.log(arr)   //[undefined, undefined, undefined, undefined]
    }

将一个类数组对象转换为一个真正的数组，必须具备以下条件：
1、该类数组对象必须具有length属性，用于指定数组的长度。如果没有length属性，那么转换后的数组是一个空数组。
2、该类数组对象的属性名必须“数值型”或字符串型的”数字”
3、属性名数字从0递增，不能

Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组

console.log(Array.from([1, 3, 5], function (item) { return item * 2 }));
// [2, 6, 10]
console.log(Array.from([1, 3, 5], item => item * 2));//简写方式 结果同上

find filter 查找目标元素

find()函数用来查找目标元素，找到就返回该元素，找不到返回undefined。
findIndex()函数也是查找目标元素，找到就返回元素的位置，找不到就返回-1。

 console.log([ 2, 3, 4, 5, 6].find(function (item) { return item > 3 })); //4     
 console.log([ 2, 3, 4, 5, 6].findIndex(function (item) { return item > 3 }));//2

console.log([ 2, 3, 4, 5, 6].filter(function (item) { return item > 3 })); //[4,5,6]

includes() 判断是否包含某一元素

ES5已经提供了indexOf用来查找某个元素的位置，如果不存在就返回-1，但是这个函数在判断数组是否包含某个元素时有两个小不足，第一个是它会返回-1和元素的位置来表示是否包含，在定位方面是没问题，就是不够语义化。另一个问题是不能判断是否有NaN的元素。
ES6提供了Array.includes()函数判断是否包含某一元素，除了不能定位外，解决了indexOf的上述的两个问题。它直接返回true或者false表示是否包含元素，对NaN一样能有有效。

console.log( [1, 2, NaN].includes(1)); // true
console.log([1, 2, NaN].includes(5));  //false
console.log( [1, 2, NaN].includes(NaN)); // true

对象

对象属性表达式

      let a='x'+1
      let obj={
        a: 2,
        [a]: 3
      }
      console.log(obj)  //{a: 2, x1: 3}

Object.assign 拷贝

用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

const a = { 0: 1, 1: 2 }
const b = { b: 1, c: 2 }
console.log(Object.assign(a, b)) // {0: 1, 1: 2, b: 1, c: 2}

循环对象

Object.entries() Object.keys() Object.values()

 const b = { b: 1, c: 2 }
      for (let [k, v] of Object.entries(b)) {
        console.log(k,v);   //b 1  c 2 
      }   
      for (let v of Object.values(b)) {
        console.log(v);    // 1 2
      } 
      for (let v of Object.keys(b)) {
        console.log(v);  //b  c
      }

ES6 数组和对象