JavaScirpt對象原生方法

Object.assign()

Object.assign()方法用於合並對象，只會合並可枚舉的屬性

const obj1= {a: 1}
const obj2 = Object.assign({}, obj1) // 將一個空對象和obj1合並在一起，相當於你復制對象
obj1.a = 2
console.log(obj2.a) // 1  兩個對象是獨立的。

const obj3 = {a: {b: 1}}
const obj4 = Object.assign({}, obj3) // 將obj3和一個空對象合並在一起
obj3.a.b = 2
console.log(obj.4.a.b) // 2  兩個對象又不是獨立的了，，合並的對象屬性里面如果還是對象，那么合並后就會存在這種情況。
const a = {a: 1} const b = {b: 2}
const c = Object.assgin(a, b, {c: 3})
console.log(c) // {a: 1, b: 2, c: 3}

如果合並的對象 都有某一個相同的屬性名，則后面的覆蓋掉前面的對象。

 

Object.create()

Object.create() 方法使指定的原型對象和屬性去創建一個新對象

const aa = Object.create(null)  
console.log(aa) // {}   以null為原型創建了一個對象，這個對象非常的干凈，不繼承任何東西
const bb = Object.create(Array.prototype)
bb 這個對象 將會擁有數組有的所有方法，因為是以數組的prototype為原型創建的對象。

 

Object.defineProperties()

Object.defineProperties()方法直接在一個對象上定義新的屬性或修改現有屬性，並返回該對象

const obj = {a: 1, b: 2}
Object.defineProperties(obj, {
    a: {value: ''hello, writable: false}, 
    c: {value: true, writable: true},
    d: {value: 'hello', writable: false}
})
// 上面value 是屬性的值，writable屬性是 是否可以修改屬性值
console.log(obj) // {a: 'hello', b: 2, c: true, d: 'hello'}
obj.c = 3
console.log(c) // 3
obj.a = 4
console.log(a) // 'hello'

 

Object.defineProperty()

Object.defineProperty() 方法會直接在對象上定義一個新屬性，或修改現有的屬性，並返回這個對象

const obj = {a: 1}
Object.defineProperty(obj, 'a', {
    enumerable: false,
    configurable: false,
    writable: false,
    value: 'hello wrod'
})
console.log(obj) // {a: 'hello wrod'}

enumerbale是否在對象的枚舉屬性中 默認false

configurable 是否可修改或刪除屬性特性(屬性特性就是這一堆值為false或則會true的東西)，默認false

wrtable 是否可以修改屬性的值 默認為false

如果你在對象中未使用 Object.defineProperty(), Object.defineProperties()或Objecr.create()函數的情況下添加對象屬性，則enumerbale，configurable，wrtable 默認都是true

 

Object.entries()

Object.entries()方法你可以簡單的理解為把對象可枚舉的屬性和值變成數組，

const obj = {foo: 'bar', too: 22}
console.log(Object.entries(obj)) // [['foo', 'bar'], ['too', 22]]

 

Object.getOwnpropertyDescriptor()

Object.getOwnpropertyDescriptor()返回一個對象上的一個屬性的 描述符，就是是否可枚舉是否可修改等等，

const obj = {a: 2}
const b = Object.getOwnpropertyDescriptor(obj, 'a')
console.log(b) //{value: 2, writable: true, enumerable: true, configurable: true}

 

Object.getOwnPropertyDescriptors()

Object.getOwnPropertyDescriptors()返回對象所有屬性的描述符

const obj = {a: 1, b: 2}
const o = Object.getOwnPropertyDescriptors(obj)
console.log(o) 
// {{value: 1, writable: true, enumerable: true, configurable: true},
{value: 2, writable: true, enumerable: true, configurable: true}}

 

Object.getOwnpropertyNames()

Object.getOwnpropertyNames()返回對象自身所有的屬性名組成的對象

const obj = {a: 1, b: 2, c: 3, d: 4}
const o = Object.getOwnpropertyNames(obj)
console.log(o) // ['a', 'b', 'c', 'b']

Object.getPrototypeOf()返回指定對象的原型

const proto = {}
const obj = Object.create(proto)
console.log(Object.getPrototypeOf(obj) === proto) // true

 

 

Object.is()

Object.is()方法傳遞兩個參數，判斷兩個參數是否相等。  

Object.is()和 === 的區別是Object.is() 會讓NaN和NaN相等+0和-0不相等。

===是+0和-0相等，NaN 和NaN 不想等。

console.log(Object.is(+0, -0)) // false

+0 === -0

 

Object.preventExtensions()

Object.preventExtensions()讓一個對象不可擴展(就是不讓添加新屬性)，並返回原對象，永遠不能添加新屬性，但可以刪除已有的屬性

const o ={}
Object.preventExtensions(o)

 

Object.isExtensble()

Object.isExtensble()方便判斷一個對象是否可擴展

const obj = {}
Object.isExtensble(obj) // true  可以添加新屬性

 

Object.freeze()

Object.freeze()方法 用於凍結對象，被凍結的對象，不可以添加新屬性，不可以刪除原有屬性，也不可以修改原有屬性，該對象永遠不變。

const obj = {a: 2}
Object.freeze(obj)
obj.a = 3
console.log(a) // 2 不可以修改

 

Object.isFrozen()

Object.isFrozen() 判斷一個對象是否被凍結
const obj = {}
Object.isFrozen(obj) // false  未凍結

 

Object.seal()

Object.seal()方法用於密封一個對象，密封只是不可以添加和刪除對象的屬性，不可以修改屬性的可枚舉可寫可讀配置，但是可以修改對象的已有屬性的值

 

Object.isSealed()

Object.isSealed()放啊判斷一個對象是否被密封，是的話返回true  否 返回false

 

Object.keys()

Object.keys()方法由對象的鍵 組成的一個數組，如果傳入的值不是對象，則會轉化為對象。

Object.keys('abc') // ['0', '1', '2']  'abc'是一個字符串，轉化為對象以后 他的鍵就是他的索引咯 所以 輸出了['0', '1', '2'] 
Object.keys([1, 2, 3]) // ['0', '1', '2']   數組的元素的鍵就是數組元素的索引
Object.keys({a: 'aa', b: 'bb'}) // ['a', 'b']

 

Object.prototype.hasOwnProperty()

hasOwnProperty()方法用於判斷對象里面是否有某屬性，只判斷自帶的屬性。

const  o = {a: 1}  
o.hasOwnProperty('a') // true   
o.hasOwnProperty('toString') //false

 

Object.prototype.hasOwnProperty()

hasOwnProperty()方法用於判斷對象里面是否有某屬性，只判斷自帶的屬性。

const  o = {a: 1}  
o.hasOwnProperty('a') // true   
o.hasOwnProperty('toString') //false

 

Object.prototype.isPrototypeOf()

isPrototypeOf()方法用於判斷一個對象是否在另一個對象的原型上。

const a = {amz: 1}      
const b = Object.create(a)     
a.isPrototypeOf(b) //true

 

Object.prototype.propertyIsEnumerable()

propertyIsEnumerable()方法判斷一個對象的自身屬性在當前對象是否可枚舉

const o = {a: 1}
o.propertyIsEnumerable('a') //true
Object.defineProperties(o, {b:{value:2,enumerbale:false}})
o.propertyIsEnumerbale('b') //false

 

Object.prototype.toString()

toString()方法返回一個對象的字符串表示

const  o = {a: 1}  o.toString()   //"[object Object]"

 

Object.prototype.toLocaleString()

toLocaleString()方法返回一個對象的字符串表示

const  o = {a: 1}  o.toLocaleString()   //"[object Object]"

toLocaleString() 方法在日期字符串對象數字數組都有，但是它們是有區別的。