1:super关键字;

this是指向当前的函数;也是代表当前的作用域;
es6新增了super指向当前对象的原型;

const proto = {
  foo: 'hello'
};

const obj = {
  foo: 'world',
  find() {
    return super.foo;
  }
};

Object.setPrototypeOf(obj, proto);
obj.find() // "hello"

上面代码中，对象obj.find()方法之中，通过super.foo引用了原型对象proto的foo属性。

2:Object.is();

ES5 比较两个值是否相等，只有两个运算符：相等运算符（==）和严格相等运算符（===）。它们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。JavaScript 缺乏一种运算，在所有环境中，只要两个值是一样的，它们就应该相等。

ES6 提出“Same-value equality”（同值相等）算法，用来解决这个问题。Object.is就是部署这个算法的新方法。
它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

3:Object.assign();

Object.assign(target,source1,source2)方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）;用于对象的合并;

const target = { a: 1 };

const source1 = { b: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}
第一个参数是目标对象;最后一个参数都是源对象;

注意点:首先是浅拷贝;是对对象的引用;原对象改变;拷贝后的也会改变;
2:同名替换;一旦遇到同名属性;会做替换处理后面的替换掉前面的

const target = { a: { b: 'c', d: 'e' } }
const source = { a: { b: 'hello' } }
Object.assign(target, source)
// { a: { b: 'hello' } }

3:Object.assign可以用来处理数组，但是会把数组视为对象

如下;
Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3];
就会按位替换
替换了0位和1位;

4:Object.keys()，Object.values()，Object.entries()
ES5 引入了Object.keys方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名。

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]

对应的辅助方法;
Object.value();

var obj={foo:'bar',baz:42};
Object.values(obj);


//这个好全概括了
从Object中取出keys,values,entries方法;
let {keys, values, entries} = Object;

let obj = { a: 1, b: 2, c: 3 };

for (let key of keys(obj)) {
  console.log(key); // 'a', 'b', 'c'
}

for (let value of values(obj)) {
  console.log(value); // 1, 2, 3
}

for (let [key, value] of entries(obj)) {
  console.log([key, value]); // ['a', 1], ['b', 2], ['c', 3]
}