ES6 对象的扩展
一、属性的简洁表示法
ES6 允许直接写入变量和函数，作为对象的属性和方法
let a = 1;
let b = 2;
let es5 = { a: a, b: b };
// 等同于
let es6 = { a, b };
上面代码表明，ES6 允许在对象之中，直接写变量。这时，属性名为变量名, 属性值为变量的值
同样的，如果对象是方法，也可以简写：
let es5 = {
sayhello: function () {
console.log('hello');
}
};
// 等同于
let es6 = {
sayhello() {
console.log('hello');
}
};
二、属性名表达式
ES6 允许字面量定义对象时，用表达式作为对象的属性名，即把表达式放在方括号内
let a = 'b';
let es5 = { a: 'c' }; // 输出{a:"c"}
let es6 = { [a]: 'c' }; // 输出{b:"c"}
表达式还可以用于定义方法名
let obj = {
['h' + 'ello']() {
return 'hi';
}
};
obj.hello() // hi
注意，属性名表达式与简洁表示法，不能同时使用，会报错
let a = "my";
let b = "name";
let person = {
[a + b],
b
}; // Uncaught SyntaxError: Unexpected token ,
三、方法的简洁表示法
ES6 新增了一个关键字 super，指向当前对象的原型对象
1、ES5 对象内方法写法
var obj = {
total: function (a, b) {
return a + b
}
}
console.log(obj.total(1, 2)) // 3
2、ES6 对象内方法简写
let obj = {
total(a, b) {
return a + b
}
}
console.log(obj.total(1, 2)) // 3
四、ES6 对象内的异步方法
在方法前加个星号
let obj = {
* foo() {
console.log('foo')
}
}
五、super 关键字
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 属性。
注意，super 关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。
JavaScript 引擎内部，super.foo 等同于 Object.getPrototypeOf(this).foo（属性）或 Object.getPrototypeOf(this).foo.call(this)（方法）
六、扩展运算符
对象的扩展运算符（...）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中
let z = { a: 3, b: 4 };
let n = { ...z };
n // { a: 3, b: 4 }
由于数组是特殊的对象，所以对象的扩展运算符也可以用于数组
let foo = { ...['a', 'b', 'c'] };
foo // {0: "a", 1: "b", 2: "c"}
如果扩展运算符后面是字符串，它会自动转成一个类似数组的对象
{...'hello'}
// {0: "h", 1: "e", 2: "l", 3: "l", 4: "o"}
七、对象的新增方法
1、Object.is()
ES6 中 Object.is() 用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致，但前者会自动转换数据类型，所以其 NaN 等于自身，+0 等于 -0，而后者不等
'foo' === 'foo' // true
Object.is('foo', 'foo') // true
{} === {} // false
Object.is({}, {}) // false
+0 === -0 // true
Object.is(+0, -0) // false
NaN === NaN // false
Object.is(NaN, NaN) // true
2、Object.assign()
用于对象的合并，将源对象的所有可枚举属性复制到目标对象，其中第一个参数是目标对象，后面的参数都是源对象
const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3 };
Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}
如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性
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.assign 会直接返回该参数
const obj = {a: 1};
Object.assign(obj) === obj // true
如果该参数不是对象，则会先转成对象，然后返回
typeof Object.assign(2) // "object"
由于 undefined 和 null 无法转成对象，所以如果它们作为参数，就会报错
Object.assign(undefined) // 报错
Object.assign(null) // 报错
如果非对象参数出现在源对象的位置，这些参数都会转成对象，若无法转成对象则会跳过。所以当 undefined 和 null 不在首参数时不会报错
let obj = {a: 1};
Object.assign(obj, undefined) === obj // true
Object.assign(obj, null) === obj // true
Object.assign 方法实行的是浅拷贝，而非深拷贝。所以如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用
const obj1 = {a: {b: 1}};
const obj2 = Object.assign({}, obj1);
obj1.a.b = 2;
obj2.a.b // 2
上面代码中，源对象 obj1 的 a 属性的值是一个对象，Object.assign 拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面
3、Object.keys()
返回一个数组，成员是参数对象自身的所有可遍历属性的键名
var obj = { name: 'Leophen', age: 22 };
Object.keys(obj) // ["name", "age"]
4、Object.values()
返回一个数组，成员是参数对象自身的所有可遍历属性的键值
var obj = { name: 'Leophen', age: 22 };
Object.values(obj) // ["Leophen", 22]
5、Object.entries()
返回一个数组，成员是参数对象自身的所有可遍历属性的键值对数组
var obj = { name: 'Leophen', age: 22 };
Object.entries(obj) // [ ["name", "Leophen"], ["age", 22] ]
6、Object.fromEntries()
这是 Object.entries() 的逆操作，用于将一个键值对数组转为对象
Object.fromEntries([ ["name", "Leophen"], ["age", 22] ])
// { name: 'Leophen', age: 22 }
7、Object.setPrototypeOf()
作用与proto相同，用来设置一个对象的 prototype 对象，返回参数对象本身
// 格式
Object.setPrototypeOf(object, prototype)
// 用法
const o = Object.setPrototypeOf({}, null);
举个例子
let proto = {};
let obj = { x: 10 };
Object.setPrototypeOf(obj, proto);
proto.y = 20;
proto.z = 40;
obj.x // 10
obj.y // 20
obj.z // 40
上面代码将 proto 对象设为 obj 对象的原型，所以从 obj 对象可以读取 proto 对象的属性。
8、Object.getPrototypeOf()
该方法与 Object.setPrototypeOf 方法配套，用于读取一个对象的原型对象
const obj1 = {a: 1};
const obj = Object.create(obj1);
console.log(obj.__proto__ === Object.getPrototypeOf(obj)); // true
