摘要：等同于構(gòu)造函數(shù)與的用法很相似，幾乎一模一樣。實(shí)例對(duì)象的方法接受一個(gè)字符串作為參數(shù)，返回一個(gè)布爾值，表示該實(shí)例對(duì)象自身是否具有該屬性。等同于方法生成的對(duì)象，繼承了它的原型對(duì)象的構(gòu)造函數(shù)。

Object 本身是一個(gè)函數(shù)，用來(lái)將任意值轉(zhuǎn)為對(duì)象。

如果參數(shù)為空（或者為 undefined 和 null），Object() 返回一個(gè)空對(duì)象。

var obj = Object();
// 等同于
var obj = Object(undefined);
var obj = Object(null);

obj instanceof Object // true

如果參數(shù)是原始類型的值，Object 方法將其轉(zhuǎn)為對(duì)應(yīng)的包裝對(duì)象的實(shí)例。

var obj = Object(1);
obj instanceof Object // true
obj instanceof Number // true

var obj = Object("foo");
obj instanceof Object // true
obj instanceof String // true

var obj = Object(true);
obj instanceof Object // true
obj instanceof Boolean // true

如果 Object 方法的參數(shù)是一個(gè)對(duì)象，它總是返回該對(duì)象，即不用轉(zhuǎn)換。

var arr = [];
var obj = Object(arr);  // 返回原數(shù)組
obj === arr             // true

var value = {};
var obj = Object(value) // 返回原對(duì)象
obj === value           // true

var fn = function () {};
var obj = Object(fn);  // 返回原函數(shù)
obj === fn             // true

因此，可以寫一個(gè)判斷變量是否為對(duì)象的函數(shù)。這個(gè)方法常用于保證某個(gè)值一定是對(duì)象。

function isObject(value) {
  return value === Object(value);
}

isObject([]) // true
isObject(true) // false

Object 構(gòu)造函數(shù)的首要用途，是直接通過(guò)它來(lái)生成新對(duì)象。

var obj = new Object();

// 等同于
var obj = {}

new Object() 構(gòu)造函數(shù)與 Object() 的用法很相似，幾乎一模一樣。使用時(shí)，可以接受一個(gè)參數(shù)，如果該參數(shù)是一個(gè)對(duì)象，則直接返回這個(gè)對(duì)象；如果是一個(gè)原始類型的值，則返回該值對(duì)應(yīng)的包裝對(duì)象。

var o1 = {a: 1};
var o2 = new Object(o1);
o1 === o2 // true

var obj = new Object(123);
obj instanceof Number // true

兩者區(qū)別是語(yǔ)義不同。Object(value) 表示將 value 轉(zhuǎn)成一個(gè)對(duì)象，new Object(value) 則表示新生成一個(gè)對(duì)象，它的值是 value。

Object 對(duì)象的原生方法分成兩類：Object 本身的方法與Object 的實(shí)例方法。

本身的方法就是直接定義在 Object 對(duì)象的方法。

1. 遍歷對(duì)象屬性

Object.keys()：遍歷對(duì)象自身的（非繼承的）可枚舉屬性，返回屬性名。

Object.getOwnPropertyNames()：遍歷對(duì)象自身的（非繼承的）全部（可枚舉+不可枚舉歷）屬性。

Object.values()：遍歷對(duì)象自身的（非繼承的）可枚舉屬性，返回屬性值。

Object.entries()：遍歷對(duì)象自身的（非繼承的）可枚舉屬性，返回鍵值對(duì)。

2. 對(duì)象的屬性描述對(duì)象相關(guān)方法

Object.getOwnPropertyDescriptor()：獲取某個(gè)屬性的描述對(duì)象。

Object.getOwnPropertyDescriptors()：獲取對(duì)象的所有屬性的描述對(duì)象。

Object.defineProperty()：定義某個(gè)屬性的描述對(duì)象。

Object.defineProperties()：定義多個(gè)屬性的描述對(duì)象。

3. 控制對(duì)象狀態(tài)的方法

Object.preventExtensions()：防止對(duì)象擴(kuò)展，無(wú)法添加新屬性。

Object.isExtensible()：判斷對(duì)象是否可擴(kuò)展。

Object.seal()：禁止對(duì)象配置，無(wú)法添加新屬性，無(wú)法刪除屬性。

Object.isSealed()：判斷一個(gè)對(duì)象是否可配置。

Object.freeze()：凍結(jié)一個(gè)對(duì)象，無(wú)法添加新屬性，無(wú)法刪除屬性，無(wú)法改變屬性值。

Object.isFrozen()：判斷一個(gè)對(duì)象是否被凍結(jié)。

4. 原型鏈相關(guān)方法

Object.create()：以參數(shù)為原型返回一個(gè)新的實(shí)例對(duì)象。

Object.getPrototypeOf()：獲取對(duì)象的原型對(duì)象。

Object.setPrototypeOf()：設(shè)置對(duì)象的原型對(duì)象。

5. 其它

Object.assign()

Object.is()

實(shí)例方法就是定義在 Object 原型對(duì)象 Object.prototype 上的方法。它可以被 Object 實(shí)例直接使用。

Object 實(shí)例對(duì)象的方法，主要有以下六個(gè)：

Object.prototype.valueOf()：返回當(dāng)前對(duì)象對(duì)應(yīng)的值。

Object.prototype.toString()：返回當(dāng)前對(duì)象對(duì)應(yīng)的字符串形式。

Object.prototype.toLocaleString()：返回當(dāng)前對(duì)象對(duì)應(yīng)的本地字符串形式。

Object.prototype.hasOwnProperty()：判斷某個(gè)屬性是否為當(dāng)前對(duì)象自身的屬性，還是繼承自原型對(duì)象的屬性。

Object.prototype.isPrototypeOf()：判斷當(dāng)前對(duì)象是否為另一個(gè)對(duì)象的原型。

Object.prototype.propertyIsEnumerable()：判斷對(duì)象自身的（非繼承的）屬性是否可枚舉。

Object.keys 方法和 Object.getOwnPropertyNames 方法都用來(lái)遍歷對(duì)象的屬性。

Object.keys 方法的參數(shù)是一個(gè)對(duì)象，返回一個(gè)數(shù)組。該數(shù)組的成員都是該對(duì)象自身的（非繼承的）所有屬性名，且只返回可枚舉的屬性。

var obj = Object.defineProperties({}, {
  p1: { value: 1, enumerable: true },
  p2: { value: 2, enumerable: false }
});

Object.keys(obj)  // ["p1"]

Object.getOwnPropertyNames 方法與 Object.keys 類似，也是接受一個(gè)對(duì)象作為參數(shù)，返回一個(gè)數(shù)組，該數(shù)組的成員是參數(shù)對(duì)象自身的（非繼承的）全部屬性的屬性名，不管該屬性是否可枚舉。

var a = ["Hello", "World"];

Object.keys(a)                   // ["0", "1"]
Object.getOwnPropertyNames(a)    // ["0", "1", "length"]

上面代碼中，數(shù)組的 length 屬性是不可枚舉的屬性，所以只出現(xiàn)在 Object.getOwnPropertyNames 方法的返回結(jié)果中。

由于 JavaScript 沒(méi)有提供計(jì)算對(duì)象屬性個(gè)數(shù)的方法，所以可以用這兩個(gè)方法代替。

var obj = { p1: 123, p2: 456 };

Object.keys(obj).length                  // 2
Object.getOwnPropertyNames(obj).length   // 2

一般情況下，幾乎總是使用 Object.keys 方法，遍歷對(duì)象的屬性。

Object.values() 方法返回一個(gè)數(shù)組，成員是參數(shù)對(duì)象自身的（非繼承的）所有可枚舉屬性的屬性值。

var obj = { p1: 123, p2: 456 };
Object.values(obj)   // [123, 456]

Object.entries() 方法返回一個(gè)數(shù)組，成員是參數(shù)對(duì)象自身的（非繼承的）所有可枚舉屬性的鍵值對(duì)數(shù)組。

var obj = { p1: 123, p2: 456 };
Object.entries(obj)  // [["p1", "123"], ["p2", 456]]

實(shí)例對(duì)象的 hasOwnProperty() 方法接受一個(gè)字符串作為參數(shù)，返回一個(gè)布爾值，表示該實(shí)例對(duì)象自身是否具有該屬性。有返回 true，沒(méi)有或是繼承的屬性都返回 false。

var obj = { p: 123 };

obj.hasOwnProperty("p")            // true
obj.hasOwnProperty("toString")     // false

Object.getPrototypeOf() 方法返回參數(shù)對(duì)象的原型。這是獲取原型對(duì)象的標(biāo)準(zhǔn)方法。

var F = function () {};
var f = new F();
Object.getPrototypeOf(f) === F.prototype // true

Object.prototype 的原型是 null。

Object.getPrototypeOf(Object.prototype) === null // true

Object.setPrototypeOf() 方法為參數(shù)對(duì)象設(shè)置原型，返回該參數(shù)對(duì)象。它接受兩個(gè)參數(shù)，第一個(gè)是現(xiàn)有對(duì)象，第二個(gè)是原型對(duì)象。

var a = {};
var b = {x: 1};
Object.setPrototypeOf(a, b);

Object.getPrototypeOf(a) === b // true
a.x // 1

new 命令可以使用 Object.setPrototypeOf() 方法模擬。

var F = function () { this.foo = "bar"; };

var f = new F();
// 等同于
var f = Object.setPrototypeOf({}, F.prototype);
F.call(f);

實(shí)例對(duì)象的 __proto__ 屬性，返回該對(duì)象的原型。該屬性可讀寫。

var obj = {};
var p = {};

obj.__proto__ = p;
Object.getPrototypeOf(obj) === p   // true

根據(jù)語(yǔ)言標(biāo)準(zhǔn)，__proto__ 屬性只有瀏覽器才需要部署，其他環(huán)境可以沒(méi)有這個(gè)屬性。它前后的兩根下劃線，表明它本質(zhì)是一個(gè)內(nèi)部屬性，不應(yīng)該對(duì)使用者暴露。因此，應(yīng)該盡量少用這個(gè)屬性，而是用 Object.getPrototypeof() 和 Object.setPrototypeOf()，進(jìn)行原型對(duì)象的讀寫操作。

實(shí)例對(duì)象的 isPrototypeOf() 方法，用來(lái)判斷該對(duì)象是否為參數(shù)對(duì)象的原型。

var o1 = {};
var o2 = Object.create(o1);
var o3 = Object.create(o2);

o2.isPrototypeOf(o3)   // true
o1.isPrototypeOf(o3)   // true

只要實(shí)例對(duì)象處在參數(shù)對(duì)象的原型鏈上，isPrototypeOf() 方法都返回true。

Object.prototype.isPrototypeOf({})                   // true
Object.prototype.isPrototypeOf([])                   // true
Object.prototype.isPrototypeOf(/xyz/)                // true
Object.prototype.isPrototypeOf(Object.create(null))  // false

由于 Object.prototype 處于原型鏈的最頂端，所以對(duì)各種實(shí)例都返回 true，只有直接繼承自 null 的對(duì)象除外。

Object.create() 方法接受一個(gè)對(duì)象作為參數(shù)，目的是以參數(shù)對(duì)象為原型，返回一個(gè)實(shí)例對(duì)象。該實(shí)例完全繼承原型對(duì)象的屬性。

很多時(shí)候，需要從一個(gè)實(shí)例對(duì)象 A 生成另一個(gè)實(shí)例對(duì)象 B，如果 A 是由構(gòu)造函數(shù)創(chuàng)建的，那么可以很輕松的得到 A 的構(gòu)造函數(shù)重新生成實(shí)例 B，然而很多時(shí)候，A 只是一個(gè)普通的對(duì)象，并不是由構(gòu)造函數(shù)生成的，這時(shí)候就需要使用Object.create() 方法由 A 生成 B。

var A = {
  print: function () {
    console.log("hello");
  }
};

var B = Object.create(A);

Object.getPrototypeOf(B) === A    // true
B.print()                         // hello
B.print === A.print               // true

Object.create() 方法兼容性處理，即生成實(shí)例的本質(zhì)：

if (typeof Object.create !== "function") {
  Object.create = function (obj) {
    function F() {}       // 新建一個(gè)空的構(gòu)造函數(shù) F
    F.prototype = obj;    // 讓 F.prototype 屬性指向參數(shù)對(duì)象 obj
    return new F();       // 最后返回一個(gè) F 的實(shí)例
  };
}

下面三種方式生成的新對(duì)象是等價(jià)的：

var obj1 = Object.create({});
var obj2 = Object.create(Object.prototype);
var obj3 = new Object();

如果想要生成一個(gè)不繼承任何屬性（比如沒(méi)有 toString 和 valueOf 方法）的對(duì)象，可以將 Object.create 的參數(shù)設(shè)為 null。因?yàn)樯傻膶?shí)例對(duì)象原型是 null，所以它就不具備定義在 Object.prototype 原型上面的方法。

var obj = Object.create(null);

Object.create() 方法還可以接受第二個(gè)參數(shù)。該參數(shù)是一個(gè)屬性描述對(duì)象，它所描述的對(duì)象屬性，會(huì)添加到實(shí)例對(duì)象，作為該對(duì)象自身的屬性。

var obj = Object.create({}, {
  p1: {
    value: 123,
    enumerable: true,
    configurable: true,
    writable: true,
  },
  p2: {
    value: "abc",
    enumerable: true,
    configurable: true,
    writable: true,
  }
});

// 等同于
var obj = Object.create({});
obj.p1 = 123;
obj.p2 = "abc";

Object.create() 方法生成的對(duì)象，繼承了它的原型對(duì)象的構(gòu)造函數(shù)。

function A() {}
var a = new A();
var b = Object.create(a);

b.constructor === A   // true
b instanceof A        // true

Object.getOwnPropertyDescriptor() 可以獲取某個(gè)屬性的屬性描述對(duì)象。它的第一個(gè)參數(shù)是對(duì)象，第二個(gè)參數(shù)是對(duì)象的某個(gè)屬性名。返回的是該屬性的屬性描述對(duì)象。

var obj = { p1: "a",  p2: "b"};

Object.getOwnPropertyDescriptor(obj, "p1")
// { value: "a",
//   writable: true,
//   enumerable: true,
//   configurable: true
// }

只能用于對(duì)象自身的（非繼承的）屬性。繼承的或不存在的屬性返回 undefined。

Object.getOwnPropertyDescriptor(obj, "toString")   // undefined

Object.getOwnPropertyDescriptors() 可以獲取參數(shù)對(duì)象的所有屬性的屬性描述對(duì)象。ES2017 引入標(biāo)準(zhǔn)。

Object.getOwnPropertyDescriptors(obj)
// { p1: {value: "a", writable: true, enumerable: true, configurable: true}
//   p2: {value: "b", writable: true, enumerable: true, configurable: true}
// }

Object.defineProperty() 方法允許通過(guò)屬性描述對(duì)象，定義或修改一個(gè)屬性，然后返回修改后的描述對(duì)象。

Object.defineProperty(object, propertyName, attributesObject)

Object.defineProperty() 方法接受三個(gè)參數(shù)，依次如下。

object：屬性所在的對(duì)象

propertyName：字符串，表示屬性名

attributesObject：屬性描述對(duì)象

var obj = Object.defineProperty({}, "p", {
  value: 123,
  writable: false,
  enumerable: true,
  configurable: false
});
obj.p         // 123
obj.p = 246;
obj.p         // 123

注意，上例中第一個(gè)參數(shù)是{ }（一個(gè)新建的空對(duì)象），p屬性直接定義在這個(gè)空對(duì)象上面，然后返回這個(gè)對(duì)象，這是 Object.defineProperty() 的常見用法。

如果屬性已經(jīng)存在，Object.defineProperty() 方法相當(dāng)于更新該屬性的屬性描述對(duì)象。

Object.defineProperties() 方法可以定義或修改多個(gè)屬性。接受兩個(gè)參數(shù)。

var obj = Object.defineProperties({}, {
  p1: { value: 123, enumerable: true },
  p2: { value: "abc", enumerable: true },
  p3: { get: function () { return this.p1 + this.p2 },
    enumerable:true,
    configurable:true
  }
});

obj.p1 // 123
obj.p2 // "abc"
obj.p3 // "123abc"

注意，一旦定義了取值函數(shù) get 或存值函數(shù) set，就不能同時(shí)定義 writable 屬性或 value 屬性，否則會(huì)報(bào)錯(cuò)。

元屬性默認(rèn)值

Object.defineProperty() 和 Object.defineProperties() 參數(shù)里面的屬性描述對(duì)象，writable、configurable、enumerable 這三個(gè)屬性的默認(rèn)值都為 false。

var obj = {};
Object.defineProperty(obj, "foo", {});
Object.getOwnPropertyDescriptor(obj, "foo")
// {
//   value: undefined,
//   writable: false,
//   enumerable: false,
//   configurable: false
// }

實(shí)例對(duì)象的 propertyIsEnumerable() 方法返回一個(gè)布爾值，用來(lái)判斷某個(gè)屬性是否可枚舉。

var obj = {};
obj.p = 123;

obj.propertyIsEnumerable("p")           // true
obj.propertyIsEnumerable("toString")    // false

注意，這個(gè)方法只能用于判斷對(duì)象自身的屬性，對(duì)于繼承的屬性一律返回 false。

有時(shí)需要凍結(jié)對(duì)象的讀寫狀態(tài)，防止對(duì)象被改變。JavaScript 提供了三種凍結(jié)方法，最弱的一種是 Object.preventExtensions()，其次是 Object.seal()，最強(qiáng)的是 Object.freeze()。

Object.preventExtensions() 方法可以使得一個(gè)對(duì)象無(wú)法再添加新的屬性。

var obj = new Object();
Object.preventExtensions(obj);

Object.defineProperty(obj, "p", { value: "hello" });
// TypeError: Cannot define property p, object is not extensible.

obj.p = 1;
obj.p      // undefined

Object.isExtensible() 方法用于檢查是否可以為一個(gè)對(duì)象添加屬性。可以添加返回 true，不可以添加返回 false。

var obj = new Object();

Object.isExtensible(obj) // true
Object.preventExtensions(obj);
Object.isExtensible(obj) // false

Object.seal() 方法使得一個(gè)對(duì)象既無(wú)法添加新屬性，也無(wú)法刪除舊屬性。

var obj = { p: "hello" };
Object.seal(obj);

delete obj.p;
obj.p // "hello"

obj.x = "world";
obj.x // undefined

Object.seal 實(shí)質(zhì)是把屬性描述對(duì)象的 configurable 屬性設(shè)為 false，因此屬性描述對(duì)象就不能再改變了。

var obj = { p: "a" };

// seal方法之前
Object.getOwnPropertyDescriptor(obj, "p")  // {... configurable: true }

Object.seal(obj);

// seal方法之后
Object.getOwnPropertyDescriptor(obj, "p")  // {... configurable: false }

Object.defineProperty(obj, "p", {
  enumerable: false
})
// TypeError: Cannot redefine property: p

Object.seal 只是禁止新增或刪除屬性，并不影響修改某個(gè)屬性的值。

var obj = { p: "a" };
Object.seal(obj);
obj.p = "b";
obj.p // "b"

Object.seal 方法對(duì) p 屬性的 value 無(wú)效，是因?yàn)榇藭r(shí) p 屬性的可寫性由writable 決定。

Object.isSealed() 方法用于檢查一個(gè)對(duì)象是否使用了 Object.seal 方法。未使用返回false，使用了返回 true。

var obj = { p: "a" };

Object.seal(obj);
Object.isSealed(obj) // true

此時(shí)，Object.isExtensible() 方法也返回 false。

Object.isExtensible(obj) // false

Object.freeze() 方法可以使得一個(gè)對(duì)象無(wú)法添加新屬性、無(wú)法刪除舊屬性、也無(wú)法改變屬性的值，使得這個(gè)對(duì)象實(shí)際上變成了常量。

var obj = { p: "hello" };

Object.freeze(obj);

obj.p = "world";
obj.p             // "hello"

obj.t = "hello";
obj.t             // undefined

delete obj.p     // false
obj.p            // "hello"

Object.isFrozen() 方法用于檢查一個(gè)對(duì)象是否使用了Object.freeze方法。未使用返回false，使用了返回 true。此時(shí) Object.isExtensible() 也返回 false。

var obj = { p: "hello" };

Object.freeze(obj);
Object.isFrozen(obj)        // true
Object.isExtensible(obj)    // false

局限性

以上三個(gè)方法鎖定對(duì)象有局限性，并不是完全凍結(jié)。

可以通過(guò)改變?cè)蛯?duì)象，來(lái)為對(duì)象增加新屬性。

var obj = new Object();
Object.preventExtensions(obj);
  
var proto = Object.getPrototypeOf(obj);
proto.t = "hello";
obj.t    // hello

解決方案是，把 obj 的原型也凍結(jié)住。

Object.preventExtensions(proto);
      
proto.t = "hello";
obj.t   // undefined

如果屬性值是對(duì)象，以上三個(gè)方法只能凍結(jié)屬性指向的對(duì)象地址，而不能凍結(jié)對(duì)象本身。

 var obj = {
   foo: 1,
   bar: ["a", "b"]
 };
 Object.freeze(obj);
  
 obj.bar.push("c");
 obj.bar // ["a", "b", "c"]

obj.bar 屬性指向一個(gè)數(shù)組，obj 對(duì)象被凍結(jié)以后，這個(gè)指向無(wú)法改變，即無(wú)法指向其他值，但是所指向的數(shù)組是可以改變的。

完全凍結(jié)

var constantize = (obj) => {
  Object.freeze(obj);
  Object.keys(obj).forEach((key, i) => {
    if ( typeof obj[key] === "object" ) {
      constantize(obj[key]);
    }
  });
};

var obj = {
  foo: 1,
  bar: ["a", "b"]
};
constantize(obj);

obj.bar.push("c"); 
// TypeError: Cannot add property 2, object is not extensible

Object.assign() 方法用于對(duì)象的合并，將所有自身的（非繼承的）可枚舉屬性的值從一個(gè)或多個(gè)源對(duì)象復(fù)制到目標(biāo)對(duì)象。返回目標(biāo)對(duì)象。目標(biāo)對(duì)象自身也會(huì)改變。

Object.assign(target, ...sources)

target: 目標(biāo)對(duì)象。

sources: 源對(duì)象。

如果目標(biāo)對(duì)象中的屬性具有相同的鍵，則屬性將被源中的屬性覆蓋。后來(lái)的源的屬性將類似地覆蓋早先的屬性。

var o1 = { a: 1, b: 1, c: 1 };
var o2 = { b: 2, c: 2 };
var o3 = { c: 3 };

var obj = Object.assign({}, o1, o2, o3);
obj    // { a: 1, b: 2, c: 3 }

Object.assign() 不會(huì)跳過(guò)那些值為 null 或 undefined 的源對(duì)象。

var o1 = { a: null, b: 1};
var o2 = { c: undefined };
    
var obj = Object.assign({}, o1, o2);
obj   // {a: null, b: 1, c: undefined}

Object.assign() 拷貝的是屬性值。假如源對(duì)象的屬性值是一個(gè)指向?qū)ο蟮囊?，它也只拷貝那個(gè)引用值。

var obj1 = { a: 0 , b: { c: 0 } };
var obj2 = Object.assign({}, obj1);
obj2   // { a: 0, b: { c: 0 } };

obj2.b.c = 3;
obj1   // { a: 0, b: { c: 3 } };
obj2   // { a: 0, b: { c: 3 } };

因此針對(duì)深拷貝，需要使用其他方法。

var obj1 = { a: 0 , b: { c: 0}};
var obj2 = JSON.parse(JSON.stringify(obj1));
obj1.b.c = 4;
obj2    // { a: 0, b: { c: 0}}

Object.assign() 如果遇到存取器定義的屬性，會(huì)只拷貝值。

var obj = {
  foo: 1,
  get bar() { return 2; }
};

var copy = Object.assign({}, obj); 
copy  // { foo: 1, bar: 2 }

因此必須使用 Object.getOwnPropertyDescriptors() 方法配合 Object.defineProperties() 方法，就可以實(shí)現(xiàn)正確拷貝。但僅限于可拷貝 getter 和 setter ，對(duì)于屬性的引用類型還是屬于淺拷貝。

var obj = {
  foo: { a : 0 },
  get bar() { return 2; }
};
var target = Object.defineProperties({},
  Object.getOwnPropertyDescriptors(obj)
);
Object.getOwnPropertyDescriptor(target, "bar")
// { get : ? bar(),
   set : undefined,
   enumerable : true, 
   configurable : true }
   
obj.foo.a = 6
target.foo.a   // 6

如果屬性不可寫，會(huì)引發(fā)報(bào)錯(cuò)，如果在引發(fā)錯(cuò)誤之前添加了任何屬性，則可以更改target對(duì)象。

Object.is() 用來(lái)比較兩個(gè)值是否嚴(yán)格相等，與嚴(yán)格比較運(yùn)算符（===）的行為基本一致。返回布爾值，相等返回 true，不相等返回 false。

不同之處只有兩個(gè)：一是+0不等于-0，二是NaN等于自身。

+0 === -0 //true
NaN === NaN // false

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

詳情見 JavaScript 的相等比較。

ES5 可以通過(guò)下面的代碼，部署 Object.is。

Object.defineProperty(Object, "is", {
  value: function(x, y) {
    if (x === y) {
      // 針對(duì)+0 不等于 -0的情況
      return x !== 0 || 1 / x === 1 / y;
    }
    // 針對(duì)NaN的情況
    return x !== x && y !== y;
  },
  configurable: true,
  enumerable: false,
  writable: true
});

valueOf 方法的作用是返回一個(gè)對(duì)象的“值”，默認(rèn)情況下返回對(duì)象本身。

var obj = new Object();
obj.valueOf() === obj      // true

主要用途是，JavaScript 自動(dòng)類型轉(zhuǎn)換時(shí)會(huì)默認(rèn)調(diào)用這個(gè)方法。因此，如果給實(shí)例對(duì)象自定義 valueOf() 方法，覆蓋 Object.prototype.valueOf()，就可以得到想要的結(jié)果。

var obj = new Object();
obj.valueOf = function () {
  return 2;
};

1 + obj // 3

toString 方法的作用是返回一個(gè)對(duì)象的字符串形式，默認(rèn)情況下返回類型字符串。

var obj = {};
obj.toString()   // "[object Object]"

JavaScript 自動(dòng)類型轉(zhuǎn)換時(shí)也會(huì)調(diào)用這個(gè)方法。因此可以通過(guò)自定義實(shí)例對(duì)象的 toString 方法，覆蓋掉 Object.prototype.toString()，得到想要的字符串形式。

var obj = new Object();

obj.toString = function () {
  return "hello";
};

obj + " " + "world"     // "hello world"

數(shù)組、字符串、函數(shù)、Date 對(duì)象都分別部署了自定義的 toString 方法，覆蓋了 Object.prototype.toString() 方法。

[1, 2, 3].toString() // "1,2,3"

"123".toString() // "123"

(function () {
  return 123;
}).toString()
// "function () {
//   return 123;
// }"

(new Date()).toString()
// "Tue May 10 2016 09:11:31 GMT+0800 (CST)"

Object.prototype.toString.call(value) 可用于判斷數(shù)據(jù)類型，詳情見 判斷數(shù)據(jù)類型的各種方法。

Object.prototype.toLocaleString 方法與 toString 的返回結(jié)果相同，也是返回一個(gè)值的字符串形式。

var obj = {};
obj.toString(obj)         // "[object Object]"
obj.toLocaleString(obj)   // "[object Object]"

這個(gè)方法的主要作用是留出一個(gè)接口，讓各種不同的對(duì)象實(shí)現(xiàn)自己版本的 toLocaleString，用來(lái)返回針對(duì)某些地域的特定的值。

目前，主要有三個(gè)對(duì)象自定義了 toLocaleString 方法。

Array.prototype.toLocaleString()

Number.prototype.toLocaleString()

Date.prototype.toLocaleString()

日期的實(shí)例對(duì)象的 toString 和 toLocaleString 返回值就不一樣，而且 toLocaleString 的返回值跟用戶設(shè)定的所在地域相關(guān)。

var date = new Date();
date.toString()       // "Thu Nov 29 2018 16:50:00 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)"
date.toLocaleString() // "2018/11/29 下午4:50:00"

參考鏈接：JavaScript 教程 Object 對(duì)象