ES6中对象的扩展以及新增方法

1.属性的简洁表示法

ES6允许直接写入变量和函数，作为对象的属性和方法。这样的书写更加简洁。

const foo = 'bar'; const baz = {foo}; baz//{foo:'bar'} //等同于 const baz = {foo:foo}

上面代码表明，ES6允许在对象之中，直接写变量。这时，属性名为变量名，属性值为变量的值。下面是另一个例子。

function f(x,y){ return {x,y} } //等同于 function f(x,y){ return {x:x,y:y}; } f(1,2)//{x:1,y:2}

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

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

下面是一个实际的例子。

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} } getPoint()//{x:1,y:10}

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, clearLclear }

属性的赋值器(setter)和取值器(getter),事实上也是采用这种写法。

const cart = { _wheels:4, get wheels(){ return this._wheels; }, set wheels (value){ if(value<this._wheels){ throw new Error('数值太小了！'); } this._whells = value; } }

2.属性名表达式

JavaScript定义对象的属性，有两种方法。

//方法一 obj.foo = true; //方法二 obj['a'+'bc'] = 123;

上面代码的方法一是直接用标识符作为属性名，方法二是用表达式作为属性名，这时将表达式放在方括号之内。
但是，如果使用字面量定义对象(使用大括号)，在ES5中只能使用方法一(标识符)定义属性。

var obj ={ foo:true, abc:123 }

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

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

下面是另一个例子：

let lastWord = 'last word'; const a = { 'first word':'hello', [lastWord]:'world' }; a['first word']//hello a[lastWord]//world a['last word']//world

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

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

注意：

属性名表达式与简洁表示法，不能同时使用，会报错。
属性名表达式如果是一个对象，默认情况下会自动将对象转为字符串[object object],这一点要特别小心。

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]属性。

方法的name属性

函数的name属性，返回函数名。对象方法也是函数，因此也有name属性。

const person = { sayName() { console.log('hello!'); }, }; person.sayName.name // "sayName"

属性的可枚举型和遍历

对象的每个属性都有一个描述对象，用来控制改属性的行为。Object.getOwnPropertyDescriptor(obj,'foo')方法可以获取该属性的描述对象。
描述对象的enumerable属性，称为可枚举性，如果该属性为false，就表示某些操作会忽略当前的属性。
目前，有四个操作会忽略enumerable为false的属性。

for...in循环：只遍历对象自身的和继承的可枚举的属性。(不包含Symbol属性) Object.keys():返回对象自身的所有可枚举的属性的键名,返回一个数组。(不包含Symbol) JSON.stringify():只串行化对象自身的可枚举的属性。 object.assign():忽略enumrable为false的属性，只拷贝对象自身的可枚举的属性。 

ES6一共有5种方法可以遍历对象的属性。
（1）for...in

for...in循环遍历对象自身的和继承的可枚举属性(不包含Symbol属性)。

（2）Object.keys(obj)

object.keys返回一个数组，包含对象自身的（不含继承的）所有可枚举属性（不包含Symbol属性）的键名。

（3）Object.getOwnPropertyNames(obj)

返回一个数组，包含对象自身的所有属性(不含Symbol属性，但是包括不可枚举属性)的键名。

（4）Object.getOwnPropertySymbols(obj)

返回一个数组，包含对象自身的所有Symbol属性的键名。

（5）Reflect.ownKeys(obj)

Reflect.ownKeys返回一个数组，包含对象自身的所有键名，不管键名是Symbol或字符串，也不管是否可枚举。 

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关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。目前，只有对象方法的简写法可以让Javascript引擎确认，定义的是对象的方法。
JavaScript引擎内部，super.foo等同于Object.getPrototypeOf(this).foo或Object.getPrototypeOf(this).foo.call(this)。

对象的扩展运算符

解构赋值
对象的解构赋值用于从一个对象取值，相当于将目标对象自身的所有可遍历、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。

let{x,y,...z} = {x:1,y:2,a:3,b；4}; x//1, y//2, z//{a:3,b:4}

上面代码中，变量z是解构赋值所在的对象。它获取等号右边的所有尚未读取的键（a和b）,将它们连同值一起拷贝过来。

对象的新增方法

1.Object.is()
ES5比较两个值是否相等，只有两个运算符：相等运算符和严格相等运算符。它们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。JavaScript缺乏一种运算，在所有环境中，只要两个值是一样的，它们就应该相等。
ES6提出同值相等算法，用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较运算符的行为基本一致。（===）。

Object.is('foo','foo'); //true Object.is({},{}) //false

不同之处只有两个：一是+0不等于-0，二是NaN等于自身。

+0 === -0 //true NaN === NaN // false Object.is(+0, -0) // false Object.is(NaN, NaN) // true

ES5可以通过下面的代码，部署Object.is。

Object.defineProperty(Object,'is',{ value:function(x,y){ if(x===y){ return x!=0||1/x===1/y; } return x!==x&&y!==y; }, configurable:true, enumerable:false, writable:true })

2.Object.assign()
Object.assign方法用于对象的合并，将源对象的所有可枚举属性，复制到目标对象。

const target = {a:1}; const source1 = {b:2}; const source2 = {c:3}; Object.assign(target,source1,source2); target//{a:1,b:2,c:3}

Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。
注意：如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
如果只有一个参数，Object.assign会直接返回该参数。

const obj = {a:1}; Obejct.assign(obj) === obj//true

如果该参数不是对象，则会先转成对象，然后返回。

typeof Object.assign(2) // "object"

由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。

Object.assign(undefined) // 报错 Object.assign(null) // 报错

如果非对象参数出现在源对象的位置（即非首参数），那么处理规则有所不同。首先，这些参数都会转成对象，如果无法转成对象，就会跳过。这意味着，如果undefined和null不在首参数，就不会报错。

let obj = {a: 1}; Object.assign(obj, undefined) === obj // true Object.assign(obj, null) === obj // true

其它类型的值(即数值、字符串和布尔值)不在首参数，也不会报错。但是，除了字符串会以数组形式，拷贝入目标对象，其它值都不会产生效果。

const v1 = 'abc'; const v2 = true; const v3 = 10; const obj = Object.assign({}, v1, v2, v3); console.log(obj); // { "0": "a", "1": "b", "2": "c" }

上面代码中，v1,v2,v3分别是字符串、布尔值和数值，结果只有字符串合入目标对象(以字符串数组的形式)，数值和布尔值都会被忽略。这是因为只有字符串的包装对象，会产生可枚举属性。
Object.assign拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（enumerable:false）。

Object.assign({b: 'c'}, Object.defineProperty({}, 'invisible', { enumerable: false, value: 'hello' }) ) // { b: 'c' }

上面代码中，Object.assign要拷贝的对象只有一个不可枚举属性invisible，这个属性并没有被拷贝进去。
属性名为Symbol值的属性，也会被Object.assign拷贝。

Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' }) // { a: 'b', Symbol(c): 'd' }

注意点：
（1）浅拷贝
Object.assign方法实行的是浅拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。

const obj1 = {a: {b: 1}}; const obj2 = Object.assign({}, obj1); obj1.a.b = 2; obj2.a.b // 2

上面代码中，源对象obj1的a属性值是一个对象，Objec.assign拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面。
（2）同名属性的替换
对于这种嵌套的对象，一旦遇到同名属性，Obejct.assign的处理方法是替换，而不是添加。

const target = { a: { b: 'c', d: 'e' } } const source = { a: { b: 'hello' } } Object.assign(target, source) // { a: { b: 'hello' } }

（3）数组的处理
Object.assign可以用来处理数组，但是会把数组是为对象。

Object.assign([1,2,3],[4,5]); //[4,5,3]

上面代码中，Oject.assign把数组视为属性名为0，1，2的对象，因此源数组的0号属性4覆盖了目标数组的0号属性1.
（4）取值函数的处理
Obejct.assign只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。

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

上面代码中，source对象的foo属性是一个取值函数，Object.assign不会复制这个取值函数，只会拿到值以后，将这个值复制过去。

常见用途

（1）为对象添加属性

class Point{ constructor(x,y){ Object.assign(this,{x,y}) } }

上面方法通过Obejct.assign方法，将x属性和y属性添加到Point类的对象实例。
（2）为对象添加方法

Object.assign(SomeClass.prototype,{ someMethod(arg1,arg2){}, anotherMethod(){} }); //等同于下面的写法 SOmeClass.prototype.someMethod = function(arg1,arg2){ } SomeClass.prototype.anotherMethod = function () { ··· };

上面代码使用了对象属性的简洁表示法，直接将两个函数放在大括号中，再使用assign方法添加到SomeClass.prototype之中。
（3）克隆对象

function clone(origin){ return Object.assign({},origin) }

上面代码中将原始对象拷贝到一个空对象，就得到了原始对象的克隆。
不过，采用这种方法克隆，只能克隆原始对象自身的值，不能克隆它继承的值。如果想要保持继承链，可以采用下面的代码。

function clone(origin) { let originProto = Object.getPrototypeOf(origin); return Object.assign(Object.create(originProto), origin); }

（4）合并多个对象

const merge = (target, ...sources) => Object.assign(target, ...sources);

如果希望合并后返回一个新对象，可以改写上面函数，对一个空对象合并。

const merge = (...sources) => Object.assign({}, ...sources);

（5）为属性指定默认值

const DEFAULTS = { logLevel: 0, outputFormat: 'html' }; function processContent(options) { options = Object.assign({}, DEFAULTS, options); console.log(options); // ... }

上面代码中，DEFAULTS对象是默认值，options对象是用户提供的参数。Object.assign方法将DEFAULTS和options合并成一个新对象，如果两者有同名属性，则option的属性值会覆盖DEFAULTS的属性值。

3.Object.getOwnPropertyDescriptors()
ES5Object.getWonPropertyDescriptor()方法会返回某个对象属性的描述对象。ES2017Object.getOwnPropertyDescriptors()方法，返回指定对象所有自身属性的描述对象。

const obj = { foo: 123, get bar() { return 'abc' } }; Object.getOwnPropertyDescriptors(obj) // { foo: // { value: 123, // writable: true, // enumerable: true, // configurable: true }, // bar: // { get: [Function: get bar], // set: undefined, // enumerable: true, // configurable: true } }

上面代码中，Object.getOwnPropertyDescriptors()方法返回一个对象，所有原对象的属性名都是该对象的属性名，对应的属性值就是该属性的描述对象。
Object.defineProperties()方法。
Object.defineProperties(obj,props)方法直接在一个对象上定义新的属性或修改现有的属性，并返回该对象。
obj:在其上定义或修改属性的对象。
props:要定义其可枚举属性或修改属性描述的对象。
4.Object.setPrototypeOf()和Object.getPrototypeOf()。
Obejct.setPrototypeOf方法的作用与__proto__相同，用来设置一个对象的prototype对象，返回参数对象本身。它是ES6正式推荐的设置原型对象的方法。

//格式 Obejct.setPrototypeOf(object,prototype); //用法 const o = Object.setPrototypeOf({},null);

该方法等同于下面的函数。

function setPrototypeOf(obj,proto){ obj.__proto__ = proto; return obj; }

下面是一个例子。

let proto = {}; let obj = {x:10}; Obejct.setPrototypeOf(obj,proto); proto.y = 20; proto.z = 40; obj.x //10 obj.y//20 obj.z//40

上面代码将proto对象设为obj对象的原型，所以从obj对象可以读取proto对象的属性。
如果第一个参数不是对象，会自动转为对象。但是由于返回的还是第一个参数，所以这个操作不会产生任何效果。
由于undefined和null无法转为对象，所以如果第一个参数是undefined或null，就会报错。
Object.getPrototypeOf()
该方法与Object.setPrototypeOf方法配套，用于读取一个对象的原型对象。

Object.getPrototypeOf(obj);

下面是一个例子。

 

function Rectangle() { // ... } const rec = new Rectangle(); Object.getPrototypeOf(rec) === Rectangle.prototype // true Object.setPrototypeOf(rec, Object.prototype); Object.getPrototypeOf(rec) === Rectangle.prototype // false