理解ES6 第三章：对象 ---Object.assign给对象添加多个属性， super, 原型。。。

英文电子书点此阅读《understanding es6》

目录

对象

快速初始化属性

不用再专门定义Key-value，直接给出Key，es6会自动在上下文找同名的变量作为value

function createPerson(name, age) {
    return {
        name,
        age
    };
}

简洁的函数定义（只能用于对象method，不能用于全局）

var person = {
    name: "Nicholas",
    sayName() {
        console.log(this.name);
    }
};

可以计算的属性名

var suffix = " name";

var person = {
    ["first" + suffix]: "Nicholas",
    ["last" + suffix]: "Zakas"
};

Object.is()

• 主要是修正了之前的quirks。比如 +0和-0， 再比如 NaN === NaN

• 基本等于”===”， 会比较类型和值。仅在正负0和NaN上表现的不一致。

• 貌似没啥用。。。

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

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

Object.assign()

• 比Object.create() 更好用，用于merge多个对象

• 后者会覆盖前者，shallow copy, 简单复制，不是可迭代的。

• 会把后者(supplier)的访问器特性（getter/setter类型的）以数据特性的形式赋予前者（receiver）

同名属性

• ES5 的严格模式下，一个对象中的有同名属性会报错，但在ES6中不管是严格属性还是非严格属性都不会，后出现的会覆盖（overwrite）前者的值。

自有属性的枚举顺序

• 数字类型在前，以升序排列
• string类型和symbol类型的以被添加的顺序排列（怎么赋予的，怎么展示的）

var obj = {
    60:222,
    'work':'coding',
    '3tt':'number in string',
     2:25
}

obj[4]= 'bulabula'
obj[2] = 50

Object.getOwnPropertyNames(obj) //Array(5) ["2", "4", "60", "work", "3tt"]

Object.setPrototypeOf()

• 改变了对象的原型

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

let dog = {
    getGreeting() {
        return "Woof";
    }
};

// prototype is person
let friend = Object.create(person);
console.log(friend.getGreeting());                      // "Hello"
console.log(Object.getPrototypeOf(friend) === person);  // true

// set prototype to dog
Object.setPrototypeOf(friend, dog);
console.log(friend.getGreeting());                      // "Woof"
console.log(Object.getPrototypeOf(friend) === dog);     // true

super reference 继承更高一级的类

• super是一个指针，指向了当前对象的原型，即Object.getPrototypeOf(this)的值。但使用时必须要在对象内部的 简洁方法 中才可以使用，就是 someFunction(){} 这样的写法（吐槽一下，这是为毛啊。。。。用non-concise methods写居然还报语法错误）。

接上段person的代码————

let friend = {
    getGreeting() {
        // in the previous example, this is the same as:
        // Object.getPrototypeOf(this).getGreeting.call(this)
        return super.getGreeting() + ", hi!";
    }
};

Object.setPrototypeOf(friend, person)

let relative = Object.create(friend)

relative.getGreeting()  // Hello, hi!

// 这里如果friend 里的 getGreeting 方法没有用super定义，而是直接绑定的 this 就会因为迭代引用自身而导致栈溢出报错。而super的指向不是动态的，不管有多少子孙后代对象继承了getGreeting 方法，super 始终是person 对象。

正式定义了对象的方法(method)

• es6 正式定义了method的概念，它作为一个函数，有内置的[[HomeObject]]属性，包含了其所属的对象。这在运用super时非常重要。

• 一定要用 funcName(){} 式的简洁写法啊。。。

summary

• 对象字面量，简洁属性定义（找同名变量），计算式的属性名(key值)，省略 function 关键字和冒号的简洁方法定义。

• 允许一个对象中的同名属性，后者覆盖前者。

• Object.assign(receiver,…suppliers)融和多个属性， Object.is()严格相等

• 对象属性的枚举顺序：数字类型第一，以升序排列；字符串其次，以添加的顺序排列；symbol最后，以添加的顺序排列

• Object.setPrototypeOf(target,prototype) 改变对象的原型

• super 关键词 调用对象的原型上的方法。this会被自动绑定在当前对象上。注意要在简洁式方法定义中 使用。