對象的新增方法 · ECMAScript 6 入門

# 對象的新增方法本章介紹 Object 對象的新增方法。 ## Object.is() ES5 比較兩個值是否相等，只有兩個運算符：相等運算符（`==`）和嚴格相等運算符（`===`）。它們都有缺點，前者會自動轉換數據類型，后者的`NaN`不等于自身，以及`+0`等于`-0`。JavaScript 缺乏一種運算，在所有環境中，只要兩個值是一樣的，它們就應該相等。 ES6 提出“Same-value equality”（同值相等）算法，用來解決這個問題。`Object.is`就是部署這個算法的新方法。它用來比較兩個值是否嚴格相等，與嚴格比較運算符（===）的行為基本一致。 ```javascript Object.is('foo', 'foo') // true Object.is({}, {}) // false ``` 不同之處只有兩個：一是`+0`不等于`-0`，二是`NaN`等于自身。 ```javascript +0 === -0 //true NaN === NaN // false Object.is(+0, -0) // false Object.is(NaN, NaN) // true ``` ES5 可以通過下面的代碼，部署`Object.is`。 ```javascript Object.defineProperty(Object, 'is', { value: function(x, y) { if (x === y) { // 針對+0 不等于 -0的情況 return x !== 0 || 1 / x === 1 / y; } // 針對NaN的情況 return x !== x && y !== y; }, configurable: true, enumerable: false, writable: true }); ``` ## Object.assign() ### 基本用法 `Object.assign()`方法用于對象的合并，將源對象（source）的所有可枚舉屬性，復制到目標對象（target）。 ```javascript 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()`方法的第一個參數是目標對象，后面的參數都是源對象。注意，如果目標對象與源對象有同名屬性，或多個源對象有同名屬性，則后面的屬性會覆蓋前面的屬性。 ```javascript 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()`會直接返回該參數。 ```javascript const obj = {a: 1}; Object.assign(obj) === obj // true ``` 如果該參數不是對象，則會先轉成對象，然后返回。 ```javascript typeof Object.assign(2) // "object" ``` 由于`undefined`和`null`無法轉成對象，所以如果它們作為參數，就會報錯。 ```javascript Object.assign(undefined) // 報錯 Object.assign(null) // 報錯 ``` 如果非對象參數出現在源對象的位置（即非首參數），那么處理規則有所不同。首先，這些參數都會轉成對象，如果無法轉成對象，就會跳過。這意味著，如果`undefined`和`null`不在首參數，就不會報錯。 ```javascript let obj = {a: 1}; Object.assign(obj, undefined) === obj // true Object.assign(obj, null) === obj // true ``` 其他類型的值（即數值、字符串和布爾值）不在首參數，也不會報錯。但是，除了字符串會以數組形式，拷貝入目標對象，其他值都不會產生效果。 ```javascript 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`分別是字符串、布爾值和數值，結果只有字符串合入目標對象（以字符數組的形式），數值和布爾值都會被忽略。這是因為只有字符串的包裝對象，會產生可枚舉屬性。 ```javascript Object(true) // {[[PrimitiveValue]]: true} Object(10) // {[[PrimitiveValue]]: 10} Object('abc') // {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"} ``` 上面代碼中，布爾值、數值、字符串分別轉成對應的包裝對象，可以看到它們的原始值都在包裝對象的內部屬性`[[PrimitiveValue]]`上面，這個屬性是不會被`Object.assign()`拷貝的。只有字符串的包裝對象，會產生可枚舉的實義屬性，那些屬性則會被拷貝。 `Object.assign()`拷貝的屬性是有限制的，只拷貝源對象的自身屬性（不拷貝繼承屬性），也不拷貝不可枚舉的屬性（`enumerable: false`）。 ```javascript Object.assign({b: 'c'}, Object.defineProperty({}, 'invisible', { enumerable: false, value: 'hello' }) ) // { b: 'c' } ``` 上面代碼中，`Object.assign()`要拷貝的對象只有一個不可枚舉屬性`invisible`，這個屬性并沒有被拷貝進去。屬性名為 Symbol 值的屬性，也會被`Object.assign()`拷貝。 ```javascript Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' }) // { a: 'b', Symbol(c): 'd' } ``` ### 注意點 **（1）淺拷貝** `Object.assign()`方法實行的是淺拷貝，而不是深拷貝。也就是說，如果源對象某個屬性的值是對象，那么目標對象拷貝得到的是這個對象的引用。 ```javascript const obj1 = {a: {b: 1}}; const obj2 = Object.assign({}, obj1); obj1.a.b = 2; obj2.a.b // 2 ``` 上面代碼中，源對象`obj1`的`a`屬性的值是一個對象，`Object.assign()`拷貝得到的是這個對象的引用。這個對象的任何變化，都會反映到目標對象上面。 **（2）同名屬性的替換** 對于這種嵌套的對象，一旦遇到同名屬性，`Object.assign()`的處理方法是替換，而不是添加。 ```javascript const target = { a: { b: 'c', d: 'e' } } const source = { a: { b: 'hello' } } Object.assign(target, source) // { a: { b: 'hello' } } ``` 上面代碼中，`target`對象的`a`屬性被`source`對象的`a`屬性整個替換掉了，而不會得到`{ a: { b: 'hello', d: 'e' } }`的結果。這通常不是開發者想要的，需要特別小心。一些函數庫提供`Object.assign()`的定制版本（比如 Lodash 的`_.defaultsDeep()`方法），可以得到深拷貝的合并。 **（3）數組的處理** `Object.assign()`可以用來處理數組，但是會把數組視為對象。 ```javascript Object.assign([1, 2, 3], [4, 5]) // [4, 5, 3] ``` 上面代碼中，`Object.assign()`把數組視為屬性名為 0、1、2 的對象，因此源數組的 0 號屬性`4`覆蓋了目標數組的 0 號屬性`1`。 **（4）取值函數的處理** `Object.assign()`只能進行值的復制，如果要復制的值是一個取值函數，那么將求值后再復制。 ```javascript const source = { get foo() { return 1 } }; const target = {}; Object.assign(target, source) // { foo: 1 } ``` 上面代碼中，`source`對象的`foo`屬性是一個取值函數，`Object.assign()`不會復制這個取值函數，只會拿到值以后，將這個值復制過去。 ### 常見用途 `Object.assign()`方法有很多用處。 **（1）為對象添加屬性** ```javascript class Point { constructor(x, y) { Object.assign(this, {x, y}); } } ``` 上面方法通過`Object.assign()`方法，將`x`屬性和`y`屬性添加到`Point`類的對象實例。 **（2）為對象添加方法** ```javascript Object.assign(SomeClass.prototype, { someMethod(arg1, arg2) { ··· }, anotherMethod() { ··· } }); // 等同于下面的寫法 SomeClass.prototype.someMethod = function (arg1, arg2) { ··· }; SomeClass.prototype.anotherMethod = function () { ··· }; ``` 上面代碼使用了對象屬性的簡潔表示法，直接將兩個函數放在大括號中，再使用`assign()`方法添加到`SomeClass.prototype`之中。 **（3）克隆對象** ```javascript function clone(origin) { return Object.assign({}, origin); } ``` 上面代碼將原始對象拷貝到一個空對象，就得到了原始對象的克隆。不過，采用這種方法克隆，只能克隆原始對象自身的值，不能克隆它繼承的值。如果想要保持繼承鏈，可以采用下面的代碼。 ```javascript function clone(origin) { let originProto = Object.getPrototypeOf(origin); return Object.assign(Object.create(originProto), origin); } ``` **（4）合并多個對象** 將多個對象合并到某個對象。 ```javascript const merge = (target, ...sources) => Object.assign(target, ...sources); ``` 如果希望合并后返回一個新對象，可以改寫上面函數，對一個空對象合并。 ```javascript const merge = (...sources) => Object.assign({}, ...sources); ``` **（5）為屬性指定默認值** ```javascript const DEFAULTS = { logLevel: 0, outputFormat: 'html' }; function processContent(options) { options = Object.assign({}, DEFAULTS, options); console.log(options); // ... } ``` 上面代碼中，`DEFAULTS`對象是默認值，`options`對象是用戶提供的參數。`Object.assign()`方法將`DEFAULTS`和`options`合并成一個新對象，如果兩者有同名屬性，則`options`的屬性值會覆蓋`DEFAULTS`的屬性值。注意，由于存在淺拷貝的問題，`DEFAULTS`對象和`options`對象的所有屬性的值，最好都是簡單類型，不要指向另一個對象。否則，`DEFAULTS`對象的該屬性很可能不起作用。 ```javascript const DEFAULTS = { url: { host: 'example.com', port: 7070 }, }; processContent({ url: {port: 8000} }) // { // url: {port: 8000} // } ``` 上面代碼的原意是將`url.port`改成 8000，`url.host`不變。實際結果卻是`options.url`覆蓋掉`DEFAULTS.url`，所以`url.host`就不存在了。 ## Object.getOwnPropertyDescriptors() ES5 的`Object.getOwnPropertyDescriptor()`方法會返回某個對象屬性的描述對象（descriptor）。ES2017 引入了`Object.getOwnPropertyDescriptors()`方法，返回指定對象所有自身屬性（非繼承屬性）的描述對象。 ```javascript 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()`方法返回一個對象，所有原對象的屬性名都是該對象的屬性名，對應的屬性值就是該屬性的描述對象。該方法的實現非常容易。 ```javascript function getOwnPropertyDescriptors(obj) { const result = {}; for (let key of Reflect.ownKeys(obj)) { result[key] = Object.getOwnPropertyDescriptor(obj, key); } return result; } ``` 該方法的引入目的，主要是為了解決`Object.assign()`無法正確拷貝`get`屬性和`set`屬性的問題。 ```javascript const source = { set foo(value) { console.log(value); } }; const target1 = {}; Object.assign(target1, source); Object.getOwnPropertyDescriptor(target1, 'foo') // { value: undefined, // writable: true, // enumerable: true, // configurable: true } ``` 上面代碼中，`source`對象的`foo`屬性的值是一個賦值函數，`Object.assign`方法將這個屬性拷貝給`target1`對象，結果該屬性的值變成了`undefined`。這是因為`Object.assign`方法總是拷貝一個屬性的值，而不會拷貝它背后的賦值方法或取值方法。這時，`Object.getOwnPropertyDescriptors()`方法配合`Object.defineProperties()`方法，就可以實現正確拷貝。 ```javascript const source = { set foo(value) { console.log(value); } }; const target2 = {}; Object.defineProperties(target2, Object.getOwnPropertyDescriptors(source)); Object.getOwnPropertyDescriptor(target2, 'foo') // { get: undefined, // set: [Function: set foo], // enumerable: true, // configurable: true } ``` 上面代碼中，兩個對象合并的邏輯可以寫成一個函數。 ```javascript const shallowMerge = (target, source) => Object.defineProperties( target, Object.getOwnPropertyDescriptors(source) ); ``` `Object.getOwnPropertyDescriptors()`方法的另一個用處，是配合`Object.create()`方法，將對象屬性克隆到一個新對象。這屬于淺拷貝。 ```javascript const clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)); // 或者 const shallowClone = (obj) => Object.create( Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj) ); ``` 上面代碼會克隆對象`obj`。另外，`Object.getOwnPropertyDescriptors()`方法可以實現一個對象繼承另一個對象。以前，繼承另一個對象，常常寫成下面這樣。 ```javascript const obj = { __proto__: prot, foo: 123, }; ``` ES6 規定`__proto__`只有瀏覽器要部署，其他環境不用部署。如果去除`__proto__`，上面代碼就要改成下面這樣。 ```javascript const obj = Object.create(prot); obj.foo = 123; // 或者 const obj = Object.assign( Object.create(prot), { foo: 123, } ); ``` 有了`Object.getOwnPropertyDescriptors()`，我們就有了另一種寫法。 ```javascript const obj = Object.create( prot, Object.getOwnPropertyDescriptors({ foo: 123, }) ); ``` `Object.getOwnPropertyDescriptors()`也可以用來實現 Mixin（混入）模式。 ```javascript let mix = (object) => ({ with: (...mixins) => mixins.reduce( (c, mixin) => Object.create( c, Object.getOwnPropertyDescriptors(mixin) ), object) }); // multiple mixins example let a = {a: 'a'}; let b = {b: 'b'}; let c = {c: 'c'}; let d = mix(c).with(a, b); d.c // "c" d.b // "b" d.a // "a" ``` 上面代碼返回一個新的對象`d`，代表了對象`a`和`b`被混入了對象`c`的操作。出于完整性的考慮，`Object.getOwnPropertyDescriptors()`進入標準以后，以后還會新增`Reflect.getOwnPropertyDescriptors()`方法。 ## `__proto__`屬性，Object.setPrototypeOf()，Object.getPrototypeOf() JavaScript 語言的對象繼承是通過原型鏈實現的。ES6 提供了更多原型對象的操作方法。 ### `__proto__`屬性 `__proto__`屬性（前后各兩個下劃線），用來讀取或設置當前對象的原型對象（prototype）。目前，所有瀏覽器（包括 IE11）都部署了這個屬性。 ```javascript // es5 的寫法 const obj = { method: function() { ... } }; obj.__proto__ = someOtherObj; // es6 的寫法 var obj = Object.create(someOtherObj); obj.method = function() { ... }; ``` 該屬性沒有寫入 ES6 的正文，而是寫入了附錄，原因是`__proto__`前后的雙下劃線，說明它本質上是一個內部屬性，而不是一個正式的對外的 API，只是由于瀏覽器廣泛支持，才被加入了 ES6。標準明確規定，只有瀏覽器必須部署這個屬性，其他運行環境不一定需要部署，而且新的代碼最好認為這個屬性是不存在的。因此，無論從語義的角度，還是從兼容性的角度，都不要使用這個屬性，而是使用下面的`Object.setPrototypeOf()`（寫操作）、`Object.getPrototypeOf()`（讀操作）、`Object.create()`（生成操作）代替。實現上，`__proto__`調用的是`Object.prototype.__proto__`，具體實現如下。 ```javascript Object.defineProperty(Object.prototype, '__proto__', { get() { let _thisObj = Object(this); return Object.getPrototypeOf(_thisObj); }, set(proto) { if (this === undefined || this === null) { throw new TypeError(); } if (!isObject(this)) { return undefined; } if (!isObject(proto)) { return undefined; } let status = Reflect.setPrototypeOf(this, proto); if (!status) { throw new TypeError(); } }, }); function isObject(value) { return Object(value) === value; } ``` 如果一個對象本身部署了`__proto__`屬性，該屬性的值就是對象的原型。 ```javascript Object.getPrototypeOf({ __proto__: null }) // null ``` ### Object.setPrototypeOf() `Object.setPrototypeOf`方法的作用與`__proto__`相同，用來設置一個對象的原型對象（prototype），返回參數對象本身。它是 ES6 正式推薦的設置原型對象的方法。 ```javascript // 格式 Object.setPrototypeOf(object, prototype) // 用法 const o = Object.setPrototypeOf({}, null); ``` 該方法等同于下面的函數。 ```javascript function setPrototypeOf(obj, proto) { obj.__proto__ = proto; return obj; } ``` 下面是一個例子。 ```javascript let proto = {}; let obj = { x: 10 }; Object.setPrototypeOf(obj, proto); proto.y = 20; proto.z = 40; obj.x // 10 obj.y // 20 obj.z // 40 ``` 上面代碼將`proto`對象設為`obj`對象的原型，所以從`obj`對象可以讀取`proto`對象的屬性。如果第一個參數不是對象，會自動轉為對象。但是由于返回的還是第一個參數，所以這個操作不會產生任何效果。 ```javascript Object.setPrototypeOf(1, {}) === 1 // true Object.setPrototypeOf('foo', {}) === 'foo' // true Object.setPrototypeOf(true, {}) === true // true ``` 由于`undefined`和`null`無法轉為對象，所以如果第一個參數是`undefined`或`null`，就會報錯。 ```javascript Object.setPrototypeOf(undefined, {}) // TypeError: Object.setPrototypeOf called on null or undefined Object.setPrototypeOf(null, {}) // TypeError: Object.setPrototypeOf called on null or undefined ``` ### Object.getPrototypeOf() 該方法與`Object.setPrototypeOf`方法配套，用于讀取一個對象的原型對象。 ```javascript Object.getPrototypeOf(obj); ``` 下面是一個例子。 ```javascript function Rectangle() { // ... } const rec = new Rectangle(); Object.getPrototypeOf(rec) === Rectangle.prototype // true Object.setPrototypeOf(rec, Object.prototype); Object.getPrototypeOf(rec) === Rectangle.prototype // false ``` 如果參數不是對象，會被自動轉為對象。 ```javascript // 等同于 Object.getPrototypeOf(Number(1)) Object.getPrototypeOf(1) // Number {[[PrimitiveValue]]: 0} // 等同于 Object.getPrototypeOf(String('foo')) Object.getPrototypeOf('foo') // String {length: 0, [[PrimitiveValue]]: ""} // 等同于 Object.getPrototypeOf(Boolean(true)) Object.getPrototypeOf(true) // Boolean {[[PrimitiveValue]]: false} Object.getPrototypeOf(1) === Number.prototype // true Object.getPrototypeOf('foo') === String.prototype // true Object.getPrototypeOf(true) === Boolean.prototype // true ``` 如果參數是`undefined`或`null`，它們無法轉為對象，所以會報錯。 ```javascript Object.getPrototypeOf(null) // TypeError: Cannot convert undefined or null to object Object.getPrototypeOf(undefined) // TypeError: Cannot convert undefined or null to object ``` ## Object.keys()，Object.values()，Object.entries() ### Object.keys() ES5 引入了`Object.keys`方法，返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名。 ```javascript var obj = { foo: 'bar', baz: 42 }; Object.keys(obj) // ["foo", "baz"] ``` ES2017 [引入](https://github.com/tc39/proposal-object-values-entries)了跟`Object.keys`配套的`Object.values`和`Object.entries`，作為遍歷一個對象的補充手段，供`for...of`循環使用。 ```javascript let {keys, values, entries} = Object; let obj = { a: 1, b: 2, c: 3 }; for (let key of keys(obj)) { console.log(key); // 'a', 'b', 'c' } for (let value of values(obj)) { console.log(value); // 1, 2, 3 } for (let [key, value] of entries(obj)) { console.log([key, value]); // ['a', 1], ['b', 2], ['c', 3] } ``` ### Object.values() `Object.values`方法返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值。 ```javascript const obj = { foo: 'bar', baz: 42 }; Object.values(obj) // ["bar", 42] ``` 返回數組的成員順序，與本章的《屬性的遍歷》部分介紹的排列規則一致。 ```javascript const obj = { 100: 'a', 2: 'b', 7: 'c' }; Object.values(obj) // ["b", "c", "a"] ``` 上面代碼中，屬性名為數值的屬性，是按照數值大小，從小到大遍歷的，因此返回的順序是`b`、`c`、`a`。 `Object.values`只返回對象自身的可遍歷屬性。 ```javascript const obj = Object.create({}, {p: {value: 42}}); Object.values(obj) // [] ``` 上面代碼中，`Object.create`方法的第二個參數添加的對象屬性（屬性`p`），如果不顯式聲明，默認是不可遍歷的，因為`p`的屬性描述對象的`enumerable`默認是`false`，`Object.values`不會返回這個屬性。只要把`enumerable`改成`true`，`Object.values`就會返回屬性`p`的值。 ```javascript const obj = Object.create({}, {p: { ? ?value: 42, ? ?enumerable: true ?} }); Object.values(obj) // [42] ``` `Object.values`會過濾屬性名為 Symbol 值的屬性。 ```javascript Object.values({ [Symbol()]: 123, foo: 'abc' }); // ['abc'] ``` 如果`Object.values`方法的參數是一個字符串，會返回各個字符組成的一個數組。 ```javascript Object.values('foo') // ['f', 'o', 'o'] ``` 上面代碼中，字符串會先轉成一個類似數組的對象。字符串的每個字符，就是該對象的一個屬性。因此，`Object.values`返回每個屬性的鍵值，就是各個字符組成的一個數組。如果參數不是對象，`Object.values`會先將其轉為對象。由于數值和布爾值的包裝對象，都不會為實例添加非繼承的屬性。所以，`Object.values`會返回空數組。 ```javascript Object.values(42) // [] Object.values(true) // [] ``` ### Object.entries() `Object.entries()`方法返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對數組。 ```javascript const obj = { foo: 'bar', baz: 42 }; Object.entries(obj) // [ ["foo", "bar"], ["baz", 42] ] ``` 除了返回值不一樣，該方法的行為與`Object.values`基本一致。如果原對象的屬性名是一個 Symbol 值，該屬性會被忽略。 ```javascript Object.entries({ [Symbol()]: 123, foo: 'abc' }); // [ [ 'foo', 'abc' ] ] ``` 上面代碼中，原對象有兩個屬性，`Object.entries`只輸出屬性名非 Symbol 值的屬性。將來可能會有`Reflect.ownEntries()`方法，返回對象自身的所有屬性。 `Object.entries`的基本用途是遍歷對象的屬性。 ```javascript let obj = { one: 1, two: 2 }; for (let [k, v] of Object.entries(obj)) { console.log( `${JSON.stringify(k)}: ${JSON.stringify(v)}` ); } // "one": 1 // "two": 2 ``` `Object.entries`方法的另一個用處是，將對象轉為真正的`Map`結構。 ```javascript const obj = { foo: 'bar', baz: 42 }; const map = new Map(Object.entries(obj)); map // Map { foo: "bar", baz: 42 } ``` 自己實現`Object.entries`方法，非常簡單。 ```javascript // Generator函數的版本 function* entries(obj) { for (let key of Object.keys(obj)) { yield [key, obj[key]]; } } // 非Generator函數的版本 function entries(obj) { let arr = []; for (let key of Object.keys(obj)) { arr.push([key, obj[key]]); } return arr; } ``` ## Object.fromEntries() `Object.fromEntries()`方法是`Object.entries()`的逆操作，用于將一個鍵值對數組轉為對象。 ```javascript Object.fromEntries([ ['foo', 'bar'], ['baz', 42] ]) // { foo: "bar", baz: 42 } ``` 該方法的主要目的，是將鍵值對的數據結構還原為對象，因此特別適合將 Map 結構轉為對象。 ```javascript // 例一 const entries = new Map([ ['foo', 'bar'], ['baz', 42] ]); Object.fromEntries(entries) // { foo: "bar", baz: 42 } // 例二 const map = new Map().set('foo', true).set('bar', false); Object.fromEntries(map) // { foo: true, bar: false } ``` 該方法的一個用處是配合`URLSearchParams`對象，將查詢字符串轉為對象。 ```javascript Object.fromEntries(new URLSearchParams('foo=bar&baz=qux')) // { foo: "bar", baz: "qux" } ```