对象的扩展

  对象（object）是 JavaScript 最重要的数据结构。ES6中对对象又有了重大的升级，下面我将从属性、属性名、super关键字这几方面进行总结，方便理解记忆。

一、属性的简洁表示法

ES6 允许直接写入变量和函数，作为对象的属性和方法。

    // ES6 允许在对象之中，直接写变量。
    const name = 'wjx';
    const names = {name};
    console.log(names);//{name: "wjx"}
 
    //等同于
    const names1 = {name: name};
    console.log(names1);//{name: "wjx"}

//又比如：
	function f(x, y) {
	  return {x, y};
	}
	// 等同于
	
	function f(x, y) {
	  return {x: x, y: y};
	}
	
	f(1, 2) // Object {x: 1, y: 2}

除了属性简写，方法也可以简写

	const o = {
	  method() {
	    return "Hello!";
	  }
	};
	
	// 等同于
	
	const o = {
	  method: function() {
	    return "Hello!";
	  }
	};

CommonJS 模块输出一组变量，就非常合适使用简洁写法。

	let ms = {};
	
	function getItem (key) {
	  return key in ms ? ms[key] : null;
	}
	
	function setItem (key, value) {
	  ms[key] = value;
	}
	
	function clear () {
	  ms = {};
	}
	
	module.exports = { getItem, setItem, clear };
	// 等同于
	module.exports = {
	  getItem: getItem,
	  setItem: setItem,
	  clear: clear
	};

二、属性名表达式

JavaScript 定义对象的属性，有两种方法。一是直接用标识符作为属性名，方法二是用表达式作为属性名，这时要将表达式放在方括号之内。
什么？你不清楚什么是标识符？

在JavaScript中，标识符只能包含字母或数字或下划线（“_”）或美元符号（“$”），且不能以数字开头。标识符与字符串不同之处在于字符串是数据，而标识符是代码的一部分。在
JavaScript 中，无法将标识符转换为字符串，但有时可以将字符串解析为标识符。

	// 方法一：标识符
	obj.foo = true;
	
	// 方法二：表达式
	obj['a' + 'bc'] = 123;

ES6 允许字面量定义对象时，用方法二（表达式）作为对象的属性名，即把表达式放在方括号内。

	let propKey = 'foo';
	
	let obj = {
	  [propKey]: true,
	  ['a' + 'bc']: 123
	};

表达式还可以用于定义方法名。

	let obj = {
	  ['h' + 'ello']() {
	    return 'hi';
	  }
	};
	
	obj.hello() // hi

	const keyA = {a: 1};
	const keyB = {b: 2};
	
	const myObject = {
	  [keyA]: 'valueA',
	  [keyB]: 'valueB'
	};
	
	myObject // Object {[object Object]: "valueB"}

上面代码中，[keyA]和[keyB]得到的都是[object Object]，所以[keyB]会把[keyA]覆盖掉，而myObject最后只有一个[object Object]属性。

三、super 关键字

我们知道，this关键字总是指向函数所在的当前对象，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关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。

	const proto = {
	  x: 'hello',
	  foo() {
	    console.log(this.x);
	  },
	};
	
	const obj = {
	  x: 'world',
	  foo() {
	    super.foo();
	  }
	}
	
	Object.setPrototypeOf(obj, proto);
	
	obj.foo() // "world"

上面代码中，super.foo指向原型对象proto的foo方法，但是绑定的this却还是当前对象obj，因此输出的就是world。