Object方法总结

1、Object.assign(target,source,source2……)通过复制一个或多个对象来创建一个新的对象。

将源对象（source）的所有可枚举属性，复制到目标对象（target）。拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（enumerable: false）

同名属性将会被后面的源对象属性覆盖

实行的是浅拷贝，而不是深拷贝。

let obj1 = {
    a:1,
    b:2,
}
let obj2 = {
    a:3,
    b:4,
}
let obj3 = {
    e:1,
    f:2,
}
let newObj = Object.assign(obj1,obj2,obj3)
console.log(newObj)// {a: 3, b: 4, e: 1, f: 2}
console.log(obj1)// {a: 3, b: 4, e: 1, f: 2}

let obj4 = {
    a: {b:1}
}
let obj5 = {
    c:2
}
let newObj2 = Object.assign(obj4,obj5)
console.log(newObj2) // {a: {b: 1},c: 2}
obj4.a.b = 3
console.log(newObj2)// {a: {b: 3},c: 2}

let obj6 = {a: 1}
console.log(Object.assign(obj6, null)) // {a: 1}
console.log(Object.assign(obj6, undefined)) // {a: 1}

console.log(Object.assign(null, obj6)) 
console.log(Object.assign(undefined, obj6)) // {a: 1}
// Uncaught TypeError: Cannot convert undefined or null to object

2 Object.create(proto, propertiesObject) 这个方法用于创建一个新对象。被创建的对象继承另一个对象(proto)的原型，在创建新对象时可以指定一些属性( propertiesObject)，默认新对象的属性不可枚举，不可更改

如果不是继承一个原有的对象，而是创建一个全新的对象，就要把proto设置为null

let obj = Object.create({a:1}, {b:3})
// Uncaught TypeError: Property description must be an object: 3
let obj = Object.create({a:1}, {b:{value:2}})
console.log(obj) // {b: 2}
console.log(obj.a) // 1
obj.b = 3
console.log(obj.b) // 2
console.log(Object.keys(obj))// []


let obj2 = Object.create(null,{a:{
    value: 2,       // 属性值
    writable: true,     //  是否可以重写值
    enumerable: true,   //是否可枚举
    configurable: true  //是否可以修改以上几项配置
}})

console.log(obj2)//{a: 2}
obj2.a=3
console.log(obj2)// {a: 3}
Object.keys(obj2)// ["a"]

3、Object.defineProperty(object, prop, descriptor) 给对象（object）添加一个属性（prop）并指定该属性的配置（descriptor）

Object.defineProperties(object, {prop1 : descriptor1, prop2 : descriptor2, ...)给对象添加多个属性并指定属性的配置

          1、第一个参数必须为对象

           2、.descriptor 不能同时具有 （value 或 writable 特性）（get 或 set 特性）。

          3、configurable 为false 时，不能重新修改装饰器

var obj = {};
Object.defineProperty(obj, "newDataProperty", {
    value: 101,
    writable: true,
    enumerable: true,
    configurable: true
});
或
Object.defineProperty(obj, "newAccessorProperty", {
    set: function (x) {
        this.otherProperty = x;
    },
    get: function () {
        return this.otherProperty;
    },
    enumerable: true,
    configurable: true
});

var obj2 = {};
Object.defineProperties(obj2, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
});

4、Object.values(obj) 遍历可枚举的属性值，只包含对象本身可枚举属性值，不包含原型链可枚举属性值,返回属性值的数组

5、Object.keys() 遍历可枚举的属性，只包含对象本身可枚举属性，不包含原型链可枚举属性

let arr = ["a", "b", "c"];
let obj = { foo: "bar", baz: 42 };
let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};

Object.keys(arr)        // ['0', '1', '2']
Object.keys(obj)        // ["foo","baz"]
Object.keys(ArrayLike)  // ['0', '1', '2']

Object.values(arr)        // ["a", "b", "c"]
Object.values(obj)       // ["bar",42]
Object.values(ArrayLike) // ["a", "b", "c"]

 

6、Object.getPrototypeOf(obj) 获取指定对象(obj)的原型（内部[[Prototype]]属性的值)

7、Object.setPrototypeOf(obj,proto) 设置一个指定的对象(obj)的原型(proto)

 

8、Object.entries(obj)返回给定对象自身可枚举属性的 [key, value] 数组。

let obj = {
    a:1,
    b:2,
}
let arr = Object.entries(obj)
console.log(arr)  // [["a", 1],["b", 2]]

9、Object.freeze(obj) 冻结对象：其他代码不能删除或更改任何属性。不能添加新的属性，不能修改已有属性的值，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性。也就是说，这个对象永远是不可变的。

10、Object.isFrozen() 判断一个对象是否已经被冻结

11、Object.preventExtensions(obj)让一个对象变的不可扩展，也就是永远不能再添加新的属性

12、Object.isExtensible(obj) 判断一个对象是否可扩展

let o = {a: 1}

o.b = 2      //添加属性b成功
Object.freeze(o)

Object.isFrozen(o)    //true 对象已被冻结

o.a = 2       //修改属性a值失败
o.c = 5       //添加属性c失败
delete o.b   //删除属性b失败

// 当一个对象不可扩展且每一个属性值都设置configurable: false, writable: false，这个对象就已被冻结
let o2 = {a: 1}
o2.b = 2     // 添加属性b成功
Object.priventExtensions(o2)
Object.defineProperties(o2, {
    a: {configurable: false, writable: false},
    b: {configurable: false, writable: false}
})

Object.isFrozen(o2)    //true o4 已经被冻结


// freeze()方法是浅冻结，若要深冻结对象就要给对象中的每一个对象属性使用freeze()方法
let obj = {
    internal :{}
};
Object.freeze(obj);//浅冻结
obj.internal.a = "aValue";
console.log(obj.internal.a);//"aValue"
    
    
function deepFreeze(o){
   var prop,propKey;
    Object.freeze(o);//首先冻结第一层对象
    for(propKey in o){
        prop = o[propKey];
        if(!o.hasOwnProperty(propKey) || !(typeof prop === "object") || Object.isFrozen(prop)){
            continue;
        }
        deepFreeze(prop);//递归
    }
}
    
deepFreeze(obj);
obj.internal.b = "bValue";//静默失败
console.log(obj.internal.b);//undefined

13、Object.seal(obj)将一个对象密封,不能添加新的属性，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性，但可以修改已有属性的值。

14、Object.isSealed 判断一个对象是否为密封的

var o = {b: 1}
o.d = 2    //添加成功
var obj = Object.seal(o);
obj === o         //true  方法返回原对象，栈指针指向同一块内存
Object.isSealed(o)   // true
o.b = 111       //修改b属性值成功
o.f = 222       //静默失败,属性f没有成功添加
delete o.b      //静默失败,属性b没有成功删除

// 空对象通过Object.preventExtensions方法设置为不可扩展。该对象就是密封的
let o1 = {};
Object.isSealed(o1)    //false
Object.preventExtensions(o1);
Object.isSealed(o1)    // true

// 非空对象通过Object.preventExtensions方法设置为不可扩展,
//并且每一个属性设置configurable: false。该对象就是密封的
let o2 = {a: 1}
Object.preventExtensions(o2);
Object.isSealed(o2)    //false
Object.defineProperty(o2, "a", { configurable: false });
Object.isSealed(o2)    //true

 

15、Object.is() 比较两个值是否相同。所有 NaN 值都相等（这与==和===不同）

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

// 不同于 === 之处
+0 === -0                   //true
NaN === NaN                 //false

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

16、obj.hasOwnProperty(prop)方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性

let o = {a: 1 }
o.hasOwnProperty('a')   //true
o.hasOwnProperty('b')   //false   对象自身没有属性b
o.hasOwnProperty('toString');  //false  不能检测对象原型链上的属性


// 如何遍历一个对象的所有自身属性，例子：
var buz = {
    fog: 'stack'
};

let ownProp = []
for (var name in buz) {
    if (buz.hasOwnProperty(name)) {
       ownProp[name]
    }
}