ES6对象的个人总结

属性初始值的简写：

当一个对象的属性与本地变量同名时，不需要再写冒号和值，直接写属性名即可

let fullName = '杨三', age = 19;

let obj = {
    fullName: fullName,
    age: age
};

// 1. 当一个对象的属性与本地变量同名时，不需要再写冒号和值，直接写属性名即可。
let obj = {
    fullName,
    age
};

对象方法的简写：

// 在 ES 5 中，如果为对象添加方法，必须要通过指定名称并完整定义函数来实现。
let obj = {
    fullName: '张三',
    sayName: function () {
        return this.fullName;
    }
};

// 在 ES 6 中，语法更简洁，取消了冒号和 function 关键字。如下所示：
let obj = {
    fullName: '张三',
    sayName () {
        return this.fullName;
    }
};

可计算的属性名：

// 在对象字面量中使用方括号表示该属性名是可计算的，方括号中的内容会被计算求值，最终转化成一个字符串，该字符串就是最终的属性名。
let suffix = 'name';

let person = {
    ['first' + suffix]: '张三',
    ['last' + suffix]: '泰坦尼'
};

console.log(person)

新增的两个方法：

Object.is（）             Object.assgin（）

1 . 在有些情况下，即是全等运算符比较出来的结果也是不正确的。

　　+0 和 -0 在 JS 解析引擎中被表示为两个完全不同的实体，而如果使用全等运算符（===）对两者进行比较，得到的结果是两者相等 。

console.log(+0 == -0);           // true
console.log(+0 === -0);          // true
console.log(Object.is(+0, -0));  // false

　　NaN 和 NaN 在 JS 解析引擎中被表示为两个完全相同的实体，但是无论使用等于（==）还是全等于（===），得到的结果都是 false。

console.log(NaN == NaN);           // false
console.log(NaN === NaN);          // false
console.log(Object.is(NaN, NaN));  // true

　　在大多数情况下，Object.is（）方法的比较结果与全等运算符完全相同，唯一的区别在于 +0 和 -0 会被识别为不相等，NaN 和 NaN 会被识别为相等。

------------------------------------------------------------------------------------------------------------------------------

2.  Object,assign（）方法可以接收任意数量的源对象（obj2,obj3），并按照指定的顺序将属性复制到接收对象（obj1）。

如果多个源对象具有同名属性，则排位靠后的源对象会覆盖排外靠前的对象。

let obj1 = {
    fullName: '陈世美',
    sayName () {
        return this.fullName;
    }
};

let obj2 = {
    fullName: '武大郎',
    age: 20
};

let obj3 = {
    fullName: '武则天',
    gender: '女'
};

// 通过自定义方法实现了一个可以合并多个对象的方法，
function mixin(receiver, ...suppliers) {
    suppliers.forEach(supplier => {
        Object.keys(supplier).forEach(key => {
            receiver[key] = supplier[key]
        })
    })
    return receiver;
}
console.log(mixin(obj1, obj2, obj3))

// 使用 ES6 新增 Object.assgin() 方法将多个对象的属性合并到第一个对象中。
Object.assign(obj1, obj2, obj3);

console.log(obj1)
console.log(obj2)
console.log(obj3)

重复的对象字面量属性：

// 对于每一组重复属性，都会选取最后一个取值。
let obj = {
    fullName: '张三',
    fullName: '李四',
    age: 18,
    age: 20
};

console.log(obj.fullName);   // '李四'
console.log(obj.age);        //

自有属性枚举属性：

ES5 中并没有定义对象属性的枚举顺序，有 JavaScript 引擎厂商自行决定。

ES6 中明确规定了对象的自有属性被枚举时的返回顺序。

自有属性枚举顺序的基本规则：

　　1. 所有数字按升序

　　2. 所有字符串按照它们被加入对象时顺序排序

let obj = {
    a: 1,
    0: 2,
    c: 3,
    2: 4,
    b: 5,
    1: 6
};

console.log(Object.getOwnPropertyNames(obj));  // ["0", "1", "2", "a", "c", "b"]

改变对象的原型：

let person = {
    getGreeting () {
        return 'Hello';
    }
};

let dog = {
    getGreeting () {
        return 'woof';
    }
};

// 使用 create() 方法将 person 对象作为原型对象
let friend = Object.create(person);  // {}
console.log(friend.getGreeting());  // 'Hello'
console.log(Object.getPrototypeOf(friend) === person);  // true

// 使用 setPrototypeOf() 方法将 friend 对象的原型对象修改成 dog
Object.setPrototypeOf(friend, dog);
console.log(friend.getGreeting());  // 'Hello'
console.log(Object.getPrototypeOf(friend) === dog);  // true

使用 super 关键字访问原型对象：

let person = {
    getGreeting () {
        return 'Hello';
    }
};

let dog = {
    getGreeting () {
        return 'woof';
    }
};

let friend = {
    getGreeting () {
        return Object.getPrototypeOf(this).getGreeting.call(this) + ', hi';
    }
};

// ES 6 引入了 super 关键字，super 指向当前对象的原型对象，实际上也就是 Object.getPrototypeOf(this) 的值，于是，上面的代码可以简化成如下形式：
let friend = {
    getGreeting () {
        return super.getGreeting() + ', hi';
    }
};

// 使用 setPrototypeOf() 方法将 friend 对象的原型对象修改成 person
Object.setPrototypeOf(friend, person);
console.log(friend.getGreeting());  // 'Hello'
console.log(Object.getPrototypeOf(friend) === person);  // true

// 使用 setPrototypeOf() 方法将 friend 对象的原型对象修改成 dog
Object.setPrototypeOf(friend, dog);
console.log(friend.getGreeting());  // 'Hello'
console.log(Object.getPrototypeOf(friend) === dog);  // true