es6 对象的扩展
1.属性的简洁表示法
function f(x,y) { return {x,y}; }
// 等同于
function f(x,y){ return {x:x,y:y}; } f(1,2) // Object {x:1,y:2}
例如：
let birth = '2000/01/01'; const Person = { name: '张三'， // 等同于 birth: birth birth, // 等同于hello: function()... hello() {console.log('我的名字'，this.name);} };
例如：用于函数的返回值
function getPoint() { const x = 1; const y = 10; return {x,y}; } console.log(getPoint()); // {x:1,y:10}
2.属性名表达式
表达式作为对象的属性名
let obj = { [propKey]: true, ['a' + 'bc']:123 }; console.log(obj[propKey]); // true console.log(obj['abc']); // 123
例如：
let lastWord = 'last word'; const a = { ‘first word’: 'hello', [lastWord]: 'world' } console.log(a['first word']); // "hello" console.log(a[lastWord]); // "world" console.log(a['last word']); // "world"
例如： 表达式可以用于定义方法名
let obj = { ['h'+'ello']() { return 'hi'; } }; console.log(obj.hello()); // 'hi'
3.方法的 name 属性
例如：函数的name 属性，返回函数名。
const person = { sayName() { console.log('hello'); } } console.log(person.sayName.name); // "sayName"
4.Object.is()
ES 比较两个值是否相等，只有两个运算符，相等运算符，相等运算符(==)
和严格相等运算符（===）
+0 === -0 // true NaN === NaN // false Object.is(+0,-0); // false Object.is(NaN,NaN) // true
5.Object.assign()
Object.assign 方法用于对象的合并，将源对象的所有的可枚举属性，赋值到目标对象
例如;
const target = {a:1};
const source1 = {b:2};
const source2 = {c:2};
Object.assign(target,source1,source2);
console.log(target); // {a:1,b:2,c:3}
例如：同名属性的替换，当遇到同名属性的时候，处理方法是替换。
const target = {a:{b:'c',d:'e'}}
const source = {a: {b:'hello'}}
console.log(Object.assign(target,source))
// {a: {b:'hello'}}
例如： 数组的处理
Object.assign 可以用来出来数组，把数组作为对象看
Object.assign([1,2,3],[4,5]) // [4,5,3]
常见用途(1) 为对象添加属性
class Point { constructor(x,y){ Object.assign(this,{x,y}); } }
常见用途(2) 为对象添加方法
Object.assign(SomeClass.prototype,{
someMethod(arg1,arg2){
.....
}
anotherMethod(){
...
}
})
常见用途(3) 克隆对象
function clone (origin) { return Object.assign({},origin); }
6.属性的可枚举行和遍历
可枚举性
Object.getOwnProperDescriptor 方法可以获取该属性的描述对象
let obj = {foo:123};
Object.getOwnPropertyDescriptor(obj,'foo')
// {
value: 123,
writable: true,
enumerable: true,
configurable:true
}
描述对象的enumerable 属性，称为“可枚举属性” 如果该属性的值为false,
就表示会忽略当前属性。
目前有四个操作会忽略 enumerable 为false 属性。
for...in ， Object.keys(), JSON.stringify(), Object.assign();
ES6一共有5种方法可以遍历对象的属性
(1) for ... in
循环遍历对象自身的和继承的可枚举属性
(2) Object.keys(obj)
Object.keys 返回一个数组，包括对象自身的所有可枚举属性
(3) Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames 返回一个数组，包含对象自身的所有属性
(4) Object.getOwnPropetrySymbols(obj)
Object.getOwnPropetrySymbols 返回一个数组，包含对象自身的所有
Symbol属性的键名。
(5) Reflect.ownKeys(Obj)
Reflect.ownKeys 返回一个数组，包含对象自身的所有键名。
8._proto_ 属性。
_proto_ 属性，用来读取和设置当前对象的protoype对象。
const obj = { method: function(){ console.log(111) } } obj._proto_= someOtherrObj; Object.setPrototypeOf()
Object.setPrototypeOf 方法的作用与 _proto_ 相同，用来设置一个对象的prototype对象
返回参数对象本身，。
// 格式
Object.setPrototypeOf(object,prototype)
// 用法
const o = Object.setPrototypeOf({},null);
Object.getPrototypeOf()
该方法与Object.setPrototypeOf 方法配套，用于读取一个对象的原型对象。
Object.getPrototypeOf(obj);
9.super 关键字
this 关键字总是指向函数所在的当前对象，super 指向当前对象的原型对象。
const proto = { foo: 'hello' }; const obj = { find(){ return super.foo; } } Object.setPrototypeOf(obj,proto); obj.find();
10.Object.keys() ,Object.values(),Object.entries()
let {keys,values,entries} = Object;
let object = {a:1,b:2,c:3};
for (let key of keys(obj)){
console.log(key); // 'a','b','c'
}
for(let key of keys(obj)){
console.log(key);// 'a','b','c'
}
for(let value of values(obj)){
console.log(key); // 1,2,3
}
for (let [key,value] of entries(obj)){
console.log([key,value]); // ['a',1],['b',2],['c',3]
}
11.对象的扩展运算
对象的结构赋值用于从一个对象取值，相当于将所有可遍历的，但尚未对齐的属性，
分配到指定的对象上面，所有的键和值他们的值，都会拷贝到新对象上面。
let {x,y,...z} = {x:1,y:2,a:3,b:4};
x // 1
y // 2
z // {a:3,b:4}
扩展运算
扩展运算符(...) 用于取出参数对象的多有可遍历属性，拷贝到当前对象之中。
let z = {a:3,b:4};
let n = {...z};
n // {a:3,b:4}
合并两个对象
let ab = {...a,...b};
// 等同于
let ab = Object.assign({},a,b)
