JS Object方法总结

create 创建一个对象

const obj = Object.create({a:1},{b:{value:2}})
//第一个参数为对象，对象为函数调用之后反回新对象的原型对象，第二个参数是对象本身的实例方法（默认不能修改，不能枚举）
console.log(obj)//{b:2}
console.log(obj.__proto__)//{a:1}

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

defineProperty定义对象属性

var obj = {}
//第一个参数是对象，第二个参数是要添加的属性名，第三个是属性
Object.defineProperty(obj,'newDataProperty',{
	value:101,//属性值
    writable:true,//是否可以重写值
    enumerable:true,//是否可以枚举
    configurable:true,//是否可以修改以上几项配置
})
console.log(obj.newDataProperty)//101

defineProperties//增加多个
Object.defineProperties(obj,{
     'property1': {
        value: true,
        writable: true
      },
      'property2': {
        value: 'Hello',
        writable: false
      }
})

keys 遍历可枚举的属性

//keys遍历可枚举的属性，只包含对象本身可枚举属性，不包含原型链可枚举属性
//遍历键
let arr = ['a','b','c']
let obj = {foo:'bar',baz:42}
let ArrayLink = {0:'a',1:'b',2:'c'};

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

values 遍历可枚举的属性值

//values遍历可枚举的属性值，只包含对象本身可枚举属性值，不包含原型链可枚举属性值
//遍历值
let arr = ['a','b','c']
let obj = {foo:'bar',baz:42}
let ArrayLink = {0:'a',1:'b',2:'c'};

console.log(Object.keys(arr))               //['a','b','c']
console.log(Object.keys(obj))               //['bar',42]
console.log(Object.keys(ArrayLike))         //['a','b','c']

assign 合并对象 拷贝

//Object.assign(target,source,source1)
//assign 用于合并对象,将对象source的所有可枚举的属性，复制到对象target上
//assign是浅拷贝
const target = {a:1,b:1}
const source1 = {b:2,c:2}
const source2 = {c:3}
Object.assign(target,source1,source2)
console.log(target)               //{a:1,b:2,c:3}
----------------------------------------------
let obj = {a:1}
Object.assign(obj,undefined)      //console.log(obj)      {a:1}
Object.assign(obj,null)           //console.log(obj)      {a:1}
----------------------------------------------
//浅拷贝
let obj1 = {a:1}
let obj2 = {b:2,c:{d:2}}
Object.assign(obj1,obj2)
console.log(obj1)             //{a:1,b:2,c:{d:2}}
obj2.c.d = 5
console.log(obj1)             //{a:1,b:2,c:{d:5}}

getPrototypeOf 获取指定对象的原型

const prototype1={a:1}
const object1 = Object.create(prototype1)
console.log(Object.getPrototypeOf(object1))                      //{a:1}
console.log(Object.getPrototypeOf(object1)===object1.__proto__)   //true

setPrototypeOf 设置一个指定的对象的原型

const obj = {a:1},proto = {b:2}
Object.setPrototypeOf(obj,proto)
console.log(obj.__proto__===proto)          //true

getOwnPropertyNames 遍历所有的属性

var obj = Object.create({},{
	getFoo:{
        value:123,
        enumerable:false
    }
})
obj.foo = 1
console.log(Object.getOwnPropertyNames(obj))         //['getFoo','foo']

getOwnPropertyDescriptor 获取该属性的描述对象

let obj = {a:1}
console.log(Object.getOwnPropertyDescriptor(obj,'a'))
//{value:1,writable:true,enumerable:true,configurable:true}
----------------------------------------------------------------
//getOwnPropertyDescriptor 返回对象所有属性的描述对象（非继承属性）
let obj = {a:1,b:2}
console.log(Object.getOwnPropertyDescriptors(obj))
//{a:{value:1,writable:true,enumerable:true,configurable:true},b:{value:2,writable:true,enumerable:true,configurable:true}}

entries 分割对象

//把每个键值对以数组的形式保存
const obj = {foo:'bar',baz:42}
console.log(Object.entries(obj))      //[['foo','bar'],['baz',42]]
const obj = {0:'a',1:'b',2:'c'}
console.log(Object.entries(obj))      //[['0','a'],['1','b'],['2','c']]
console.log(Object.entries('abc'))    //[['0','a'],['1','b'],['2','c']]
console.log(Object.entries(100))      //[]

is 用来比较两个值是否严格相等

//is与===相似
console.log(Object.is('foo','foo'))          //true
console.log(Object.is({},{}))                //false
//不同于===的地方
console.log(+0 === -0)                       //true
console.log(NaN === NaN)                     //false
console.log(Object.is(+0,-0))                //false
console.log(Object.is(NaN,NaN))              //true

preventExtensions 让一个对象变得不可扩展

isExtensible 判断一个对象是否可扩展

//不可扩展的意思就是不能再有新的属性
let obj ={}
console.log(Object.isExtensible(obj))      //true
obj.a = 1
console.log(obj)                           //{a:1}
Object.preventExtensions(obj)
obj.b = 2
console.log(obj)                          //{a:1}
obj.a = 3
console.log(obj)                           //{a:3}

seal 将一个对象密封

isSealed 判断一个对象是否为密封

//密封是指不能添加新的属性，不能删除已有属性，以及不能修改以后属性的可枚举性、可配置性、可写性，但可能可以修改已有属性的值的对象
let obj={a:1}
obj.b=2
console.log(obj)                //{a:1,b:2}
Object.seal(obj)
console.log(Object.isSealed(obj))         //true
obj.b = 22
console.log(obj)                //{a:1,b:22}
obj.c = 3
console.log(obj)                //{a:1,b:22}
delete obj.b
console.log(obj)                //{a:1,b:22}

freeze 冻结一个对象

isFrozen 判断一个对象是否已经被冻结

//冻结对象是指那些不能添加新的属性，不能修改已有属性的值，不能删除已有属性，以及不能修改以后属性的可枚举性、可配置性、可写性的对象。也就是说，这个对象永远是不可变的。
let obj = {a:1}
obj.b = 2
Object.freeze(obj)
console.log(Object.isFrozen(obj))       //true
obj.a=2
obj.c=3
delete obj.b
console.log(obj)               //{a:1,b:2}

hasOwnProperty 对象有没有指定的属性

//方法返回一个布尔值，指示对象自身有没有指定的属性
let obj={a:1}
console.log(obj.hasOwnProperty('a'))                //true
console.log(obj.hasOwnProperty('b'))				//false