ES6-----对象的扩展

属性的简洁表示

ES6中允许对象采用简写的方式。当一个对象的属性与本地变量同名时，不必再写冒号和值，简单的只写属性名就可以。

	        let name = 'banana',
	            color = 'yellow';
	        //属性名与本地变量同名
	        let fruit = {
	            name,
	            color
	        }
	        console.log(fruit);//{name: "banana", color: "yellow"}

当对象字面量里只有一个属性的时候，javascript引擎会在可访问作用域中查找其同名变量，如果找到，则该变量的值就被付给对象字面量里的同名属性；如果没找到，就会报错。

	        function createPerson(name, age) {
	            return {
	                name,
	                age
	            }
	        }
	        createPerson('lily', 18)；
	        
	        //如果在对象里面添加一个属性grade，并采用简写方式：
	        function createPerson(name, age) {
	            return {
	                name,
	                age,
	                grade   //没有在作用域中找到同名变量，报错grade is not defined
	            }
	        }
	        createPerson('lily', 18); 

在ES6中，对象的方法也可以采用简写的方式：可以把冒号和function省略。

	        //对象方法的简写:可以把冒号和function省略
	        var animal = {
	            name: 'dog',
	            getName() {
	                console.log(this.name);
	            }
	        }
	        animal.getName();//dog

属性名表达式

ES6 允许字面量定义对象时，使用方括号表示该属性名是可计算的，它的内容将被求值并转换成字符串。因而同样可以使用表达式属性作为对象的可计算名称。

	        var suffix = 'name';
	        var student= {
	            ['first' + name]: 'Amanda',
	            ['second' + name]: 'li'
	        }
	        console.log(student);//{first: "Amanda", second: "li"}

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

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

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

新增方法

Object.is()

比较两个值相等通常使用相等运算符(==) 和严格相等运算符 (===)。前者在比较时会进行类型转换，后者不会，但是后者比较NaN===NaN时，始终返回false

                console.log(0 == false);//true
	        console.log(null == false);//false
	        console.log(undefined == false);//false
	        console.log('' == false);//true
	        console.log([] == false);//true
	        console.log(1 == true);//true
	        console.log([2] == false);//false
	        
	        console.log(+0 == -0);//true
	        console.log(+0 === -0);//true
	        console.log(NaN == NaN);//false 
	        console.log(NaN === NaN);//false
	        console.log(5 == "5");//true
	        console.log(5 === "5");//false

Object.is方法也用来比较两个值是否严格相等，与严格比较运算符(===)的行为基本一致。但是不同的是+0不等于-0，NaN等于自身。

		console.log(Object.is(+0, -0));//false
		console.log(Object.is(NaN, NaN));//true
		console.log(Object.is(5, "5"));//false

Object.assign()

Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象(target)。第一个参数是目标对象，后面的参数都是源对象。Object.assign方法实行的是浅拷贝，而不是深拷贝。

	        let receiver = {};
	        let suplier = {
	            type: 'js',
	            name: 'index.js',
	            arr: {
	                es5: 'es5',
	                es6: 'es6'
	            }
	        }
	        Object.assign(receiver, suplier, {
	            type: 'css'
	        });
	        console.log(receiver.name);//index.js
	        receiver.arr.es2015 = 'es2015';
	        console.log(suplier.arr);// {es5: "es5", es6: "es6", es2015: "es2015"}

注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

		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会直接返回该参数。如果该参数不是对象，则会先转成对象，然后返回。由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。

	        //如果只有一个参数，Object.assign会直接返回该参数
	        const obj = { a: 1 };
	        console.log(Object.assign(obj) === obj);// true

		typeof Object.assign(2) // "object"  先转成对象
		Object.assign(undefined) // 报错
		Object.assign(null) // 报错Object.assign(null) // 报错

如果非对象参数出现在源对象的位置(即非首参数)，会先将其转成对象，如果无法转成对象不会报错直接跳过。但是，由于字符串的包装对象，会产生可枚举属性，所以字符串会以数组形式，拷贝入目标对象。

	        //如果非对象参数出现在源数据位置
	        const obj = { a: 1 };
	        console.log(Object.assign(obj, 12));
	        //{a: 1}
	        console.log(Object.assign(obj, 'abc'));
	        //{0: "a", 1: "b", 2: "c", a: 1}
	        console.log(Object.assign(obj, undefined, null, [1, 2, 3]));
	        //{0: 1, 1: 2, 2: 3, a: 1}

Object.assign只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。

		const source = {
		    get foo() { return 1 }
		};
		const target = {};
		Object.assign(target, source); 
		// { foo: 1 }

Object.keys()

ES5 引入了Object.keys方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名。

		var obj = { foo: 'bar', baz: 42 };
		Object.keys(obj)
		// ["foo", "baz"]

Object.values()

ES2017 引入了Object.values方法，其返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值。

		const obj = { foo: 'bar', baz: 4 };
		Object.values(obj)
		// ["bar", 4]
					
		Object.values('foo')
		// ['f', 'o', 'o']

Object.entries()

ES2017 引入的Object.entries方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性（enumerable）的键值对数组。

	        //Object.entries()
	        const obj = { foo: 'bar', baz: 4 };
	        Object.entries(obj);
	        //[["foo", "bar"],["baz", 4]]

对象的原型

以往我们操作对象的原型需要使用__proto__，但是__proto__本质上是一个内部属性，而不是一个正式的对外的 API，直接操作它并不好。使用Object.setPrototypeOf()、Object.getPrototypeOf()、Object.create()代替。

Object.getPrototypeOf()

Object.getPrototypeOf方法用于获取对象的原型。

	        let student = {
	            greeting() {
	                return "hello"
	            }
	        }
	        let dog = {
	            greeting() {
	                return "woof"
	            }
	        }
	        let friend = Object.create(student);
	        console.log(friend.greeting());//hello
	        console.log(Object.getPrototypeOf(friend) == student);//true

Object.setPrototypeOf()

Object.setPrototypeOf方法用于更改对象的原型。

	        //原型变更
	        let student = {
	            greeting() {
	                return "hello"
	            }
	        }
	        let dog = {
	            greeting() {
	                return "woof"
	            }
	        }
	        let friend = Object.create(student);
	        Object.setPrototypeOf(friend, dog);
	        console.log(friend.greeting());//woof
	        console.log(Object.getPrototypeOf(friend) == dog);//true
	        console.log(Object.getPrototypeOf(friend) == student);//false

super

ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象。

	        //super:指向当前对象的原型对象
	        const proto = {
	            foo: 'hello'
	        };
	        const obj = {
	            foo: 'world',
	            find() {
	                return super.foo;
	            }
	        };
	        Object.setPrototypeOf(obj, proto);
	        console.log(obj.find()); // "hello"

注意，super关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。

参考：http://es6.ruanyifeng.com/#docs/object