用來解決在ES5中 兩種相等運(yùn)算符的缺點(diǎn)。用來比較兩個(gè)值是否嚴(yán)格相等，行為和（===）基本一致。

在ES5中判斷兩個(gè)值是否相等，只能用（==）相等運(yùn)算符和（===）嚴(yán)格相等運(yùn)算符，但是這兩貨都有缺點(diǎn)，前者 兩邊的值都會(huì)轉(zhuǎn)換數(shù)據(jù)類型，后者 NaN不等于自身還有 +0 == -0。

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

// 在 Object.is()

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

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

用于對(duì)象的合并，將源對(duì)象的所有可枚舉屬性，復(fù)制到目標(biāo)對(duì)象，現(xiàn)在常用來進(jìn)行淺拷貝。

const t = {a: 1}
const s1 = {b: 2}
const s2= {c: 3}

Object.assign(t, s2, s2)
// t  {a:1, b:2, c:3}

// 在上面中第一個(gè)參數(shù)t是目標(biāo)對(duì)象，s1 s2是源對(duì)象

注意：如果目標(biāo)對(duì)象和源對(duì)象有同名屬性，或者多個(gè)同名，那么在后面的屬性會(huì)將前面的覆蓋。

const t = {a: 1, b: 2}
const s1 = {b: 3, c: 4}
const s2 = {c: 5}

Object.assign(t, s1, s2)
t // {a:1, b:3, c:5}

如果Object.assign的參數(shù)只有一個(gè)，那么就返回該參數(shù)，另外如果該參數(shù)不是對(duì)象，那么Object.assign會(huì)將其轉(zhuǎn)為對(duì)象在返回

const t = {a: 2}
Object.assign(t)
t // {a: 2}

Object.assigin(2)
// "object"

另外由于null 和 undefined 無法轉(zhuǎn)換位對(duì)象，那么如果他們作為第一個(gè)參數(shù)就會(huì)報(bào)錯(cuò)，如果不是在第一個(gè)參數(shù)則不會(huì)有這個(gè)問題

Object.assign(undefined)    // 報(bào)錯(cuò)
Object.assign(null)     //報(bào)錯(cuò)

這樣就不會(huì)報(bào)錯(cuò)：如下

const t = {a: 2}

Object.assign(t, undefined)     // true
Object.assign(t, null)      // true

其他（數(shù)值，字符串，布爾值）數(shù)值不再第一個(gè)也不會(huì)報(bào)錯(cuò)，但是字符串會(huì)以數(shù)組的形式被拷入目標(biāo)對(duì)象，兩外兩個(gè)則不會(huì)做任何操作。

const a = "abc"
const b = true
const c = 12

const o = Object.assign({}, a, b, c)
o // {"0": "a", "1": "b", "2": "c"}

// 因?yàn)椴紶栔祅umber 的原始值都在對(duì)象的內(nèi)部屬性[[PrimitiveValue]]
上面，這個(gè)屬性不能別Object.assign拷貝

Obeject.assign 拷貝的屬性是有限制的，只能拷貝源對(duì)象的自身屬性，也不能拷貝不可枚舉的屬性，另外 Symbol值的屬性也能被拷貝

1. 淺拷貝

Object.assign 實(shí)現(xiàn)的是淺拷貝，也就是說如果源對(duì)象的某個(gè)屬性值是對(duì)象，那么目標(biāo)對(duì)象拷貝得到的是這個(gè)對(duì)象的引用

2. 同名屬性的替換

如果遇到同名屬性，那Object.assign的處理方法是替換還不是追加

3. 數(shù)組的處理

在處理數(shù)組的時(shí)候，Object.assign是將其是為對(duì)象來處理，如果下標(biāo)相同則是覆蓋而不是追加

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

4. 取值函數(shù)的處理

Object.assign 只能進(jìn)行值的復(fù)制，如果復(fù)制的值是一個(gè)函數(shù)，那么就等函數(shù)求值執(zhí)行完在進(jìn)行值的復(fù)制

1. 為對(duì)象添加屬性
2. 為對(duì)象添加方法
3. 克隆對(duì)象
4. 合并多個(gè)對(duì)象
5. 為屬性指定默認(rèn)值

用來返回指定對(duì)象所有自身屬性（非繼承屬性）的描述對(duì)象

const o = {
    left: 123,
    top() {
        return "new"
    }
}

Object.getOwnPropertyDescriptors(o)

// {
    left:{
        configurable: true
        enumerable: true
        value: 123
        writable: true
    },
    top: {
        configurable: true
        enumerable: true
        value: ? top()
        writable: true
    }
}

Object.getOwnPropertyDescriptors() 返回一個(gè)對(duì)象，所有原對(duì)象的屬性名都是該
對(duì)象的屬性名，對(duì)應(yīng)的屬性值就是該屬性的描述對(duì)象。

用來讀取或設(shè)置當(dāng)前對(duì)象的prototype對(duì)象，另外這是一個(gè)內(nèi)部屬性。__proto__是調(diào)用的 Object.prototype.__proto__ 方法

//es5 寫法
const o = {
    method: function() {}
}
o.__proto__ = someOtherObj

//es6 寫法
var o = Object.create(someOtherObj)
o.method = function(){}

作用和 __proto__相同，用來設(shè)置一個(gè)對(duì)象的prototype對(duì)象，返回參數(shù)本身

// 格式
Object.setPrototypeOf(object, prototype)

// 用法
const o = Object.setPrototypeOf({}, null)

=== 以下寫法

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

// 例子
let proto = {}
let o = {
    x: 10
}
Object.setPrototypeOf(o, proto)

proto.y = 20
proto.z = 40

o.x // 10
o.y // 20
o.z // 40

// 上面 將proto設(shè)為 o 對(duì)象的原型，所以可以從o 中讀取proto 的屬性

注意：如果第一參數(shù)不是對(duì)象，將自動(dòng)轉(zhuǎn)換為對(duì)象，由于返回的還是第一個(gè)參數(shù)，所以這個(gè)操作不會(huì)產(chǎn)生任何效果，另外由于 undefined 和 null 無法轉(zhuǎn)換為對(duì)象，所以第一個(gè)參數(shù)如果是這兩個(gè)則會(huì)報(bào)錯(cuò)

Object.setPrototypeOf(1, {}) === 1 // true
Object.setPrototypeOf("foo", {}) === "foo" // true
Object.setPrototypeOf(true, {}) === true // true

Object.setPrototypeOf(undefined, {})
// TypeError: Object.setPrototypeOf called on null or undefined

Object.setPrototypeOf(null, {})
// TypeError: Object.setPrototypeOf called on null or undefined

用于讀取一個(gè)對(duì)象的原型對(duì)象和Object.setPrototypeOf 配套使用。所有的特性也和 上面一樣，第一個(gè)參數(shù)如果不是對(duì)象將轉(zhuǎn)換為對(duì)象，undefined和null 會(huì)報(bào)錯(cuò)

用于返回一個(gè)數(shù)組，成員的參數(shù)是對(duì)象自身的所有可遍歷屬性的鍵名

let obj = {
    x: 1,
    y: "b"
}

Object.keys(obj)
//?["x", "y"]

返回值是一個(gè)數(shù)組，成員是對(duì)象自身的（不含繼承的）所有可遍歷屬性的值。Objet.values只返回對(duì)象自身的可遍歷屬性。

let obj = {
    x: 1,
    y: "b"
}

Object.keys(obj)
//?[1, "b"]

另外Object.values遍歷的時(shí)候如果遇到屬性名為數(shù)值的屬性，那么將按照數(shù)值大小，從小到大遍歷，如下：

const obj = { 100: "a", 2: "b", 7: "c" };
Object.values(obj)
// ["b", "c", "a"]

注意：Object.values 會(huì)過濾屬性名為 Symbol的屬性

Object.values({ [Symbol()]: 123, foo: "abc" });
// ["abc"]

如果Object.values的參數(shù)是一個(gè)字符串 那么將返回字符串拆解的數(shù)組

Object.values("symbol")
["s", "y", "m", "b", "o", "l"]

注意： 如果Object.values 的參數(shù)為boolean值或者number，那么返回值是一個(gè)空數(shù)組，

Object.values(true)
[]
Object.values(2,null)
[]

返回一個(gè)數(shù)組，成員是對(duì)象自身（不含繼承的）所有可遍歷屬性的鍵值對(duì)數(shù)組，同樣 Symbol 屬性的值會(huì)被過濾。

const p = { f: "b", az: 22 };
Object.entries(p)
// [ ["f", "b"], ["az", 22] ]


Object.entries({ [Symbol()]: 456, o: "c" });
// [ [ "o", "c"] ]

Object.entries 可以用來遍歷對(duì)象的屬性

Object.entries 將對(duì)象轉(zhuǎn)為真正的Map結(jié)構(gòu)

const obj = { foo: "bar", baz: 42 };
const map = new Map(Object.entries(obj));
map // Map { foo: "bar", baz: 42 }

是Object.entries 的逆操作，將一個(gè)鍵值對(duì)數(shù)組轉(zhuǎn)為對(duì)象。主要是將鍵值對(duì)的數(shù)據(jù)結(jié)構(gòu)還原為對(duì)象，適用于將Map結(jié)構(gòu)轉(zhuǎn)為對(duì)象

Object.fromEntries([
  ["foo", "bar"],
  ["baz", 42]
])
// { foo: "bar", baz: 42 }

// 例二 將Map結(jié)構(gòu)轉(zhuǎn)為對(duì)象
const map = new Map().set("foo", true).set("bar", false);
Object.fromEntries(map)
// { foo: true, bar: false }

ES6入門系列

ES6入門之let、cont

ES6入門之變量的解構(gòu)賦值

ES6入門之字符串的擴(kuò)展

ES6入門之正則的擴(kuò)展

ES6入門之?dāng)?shù)值的擴(kuò)展

ES6入門之函數(shù)的擴(kuò)展

ES6入門之對(duì)象的擴(kuò)展

Git教程

前端Git基礎(chǔ)教程