ES6中对象新增了哪些扩展?

一、属性的简写

ES6中，
当对象键名与对应值名相等的时候，可以进行简写，
当对象键对应的值是个方法的时候，也可以进行简写

const foo = 'hello world!'
const o = {
  say: function() {    
    return "Hello!";
  },
  foo:foo    
}

// 等同于

const o = {
  say() {                // 值为方法，简写
    return "Hello!";
  },
  foo         // 键与值名相等，简写
};

注意：简写的对象方法不能用作构造函数，否则会报错

二、属性名表达式

ES6 允许字面量定义对象时，将表达式放在括号内，也适用于方法

let lastWord = 'last word';
let add = 'addFn';

const a = {
  [lastWord]: 'world',    // 字面量定义对象的key
  [add](){return 'hi!'}
  
};
// a['last word']    word
// a[lastWord]    word
// a[add]() 

注意1，属性名表达式与简洁表示法，不能同时使用，会报错

// 报错
const foo = 'bar';
const bar = 'abc';
const baz = { [foo] };

// 正确
const foo = 'bar';
const baz = { [foo]: 'abc'};

注意2，属性名表达式如果是一个对象，默认情况下会自动将对象转为字符串[object Object]

const keyA = {a: 1};
const keyB = {b: 2};

const myObject = {
  [keyA]: 'valueA',
  [keyB]: 'valueB'
};

myObject // Object {[object Object]: "valueB"}

三、super关键字

this关键字总是指向函数所在的当前对象，
ES6 新增的super指向当前对象的原型对象

const a = {
  foo: 'hello'
};

const obj = {
  foo: 'world',
  find() {
    return super.foo;    // super指向原型对象
  }
};

Object.setPrototypeOf(obj, a); // 为obj设置原型对象为a
obj.find() // "hello"

四、扩展运算符的应用

• 对象解构的基本语法 ------ 左边是对应的key，右边是新赋值后的变量名

let person = {
  name: "ec50n9",
  age: 19,
  job: "student"
};
let { name: personName, age: personAge } = person;
console.log(personName)   //"ec50n9"
console.log(personAge)    // 19 

• 对象解构的简化写法 ------ 如果解构后的key与变量名相同，可简化写法如下

let person = {
  name: "ec50n9",
  age: 19,
  job: "student"
};
// 完整写法： let { name:name,age:age } = person;
let { name, age } = person;
console.log(name); // "ec50n9"
console.log(age);  // 19 

• 定义默认值
  有时候，可能被解构的对象中没有被引用的属性，可以通过下面这种方法来定义默认值，也就是如果对象中没有对应属性，就使用默认值：

let person = {
  name: "ec50n9",
  age: 19,
  job: "student"
};
let { name="no Name", sex="男", height } = person;

console.log(name);   // "ec50n9"  对象中有 name 属性✅，所以使用对象中的值
console.log(sex);    // "男"      对象中没有 sex 属性❌，使用默认值
console.log(height); // undefined 对象中没有 height 属性❌，也没有默认值

• 在解构赋值中，未被读取的可遍历的属性，分配到指定的对象上面

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x) // 1
console.log(y) // 2
console.log(z) // { a: 3, b: 4 }

五、属性的遍历

ES6 一共有 5 种方法可以遍历对象的属性:

• for...in：循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）
• Object.keys(obj)： 返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名

以下两种方式，了解下

• Object.getOwnPropertyNames(obj)：回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名
• Object.getOwnPropertySymbols(obj)：返回一个数组，包含对象自身的所有 Symbol 属性的键名
• Reflect.ownKeys(obj)：返回一个数组，包含对象自身的（不含继承的）所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举

六、对象新增的方法

• Object.assign(target,source1,source2,...)
  用于对象的合并，将源对象source的所有可枚举属性，复制到目标对象target，该方法的第一个参数是目标对象，后面的参数都是源对象，遇到同名属性会进行替换(后面的会覆盖前面的)
  注意：Object.assign()方法是浅拷贝

  const target = { a: 1, b: 1 };
  
  const source1 = { b: 2, c: 2 };
  const source2 = { c: 3 };
  
  Object.assign(target, source1, source2);
  target // {a:1, b:2, c:3}
  

• Object.keys()
  返回自身的（不含继承的）所有可遍历（enumerable）属性的键名的数组

• Object.values()
  返回自身的（不含继承的）所有可遍历（enumerable）属性的键对应值的数组

• Object.setPrototypeOf()
  设置一个对象的原型对象

  const a = {
    foo: 'hello'
  };
  
  const obj = {
    world: 'world'
  };
  
  Object.setPrototypeOf(obj, a)    // 设置obj对象的原型对象为a
  console.log(obj.__proto__)     //  {foo:'hello'}
  

• Object.getPrototypeOf()
  用于读取一个对象的原型对象

  Object.getPrototypeOf(obj);
  

参考链接：https://mp.weixin.qq.com/s/sJ-OB-K47sV8MFqDjB50Uw