js object 常用方法总结

Object.assign(target,source1,source2,...)

该方法主要用于对象的合并，将源对象source的所有可枚举属性合并到目标对象target上,此方法只拷贝源对象的自身属性，不拷贝继承的属性。

Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。同名属性会替换。

Object.assign只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。

Object.assign可以用来处理数组，但是会把数组视为对象。

Object.create(prototype[,propertiesObject])

使用指定的原型对象及其属性去创建一个新的对象

1 2 3 4 5 6 7 8 9 10 11 12

var parent = {     x : 1,     y : 1 } var child = Object.create(parent,{     z : {                           // z会成为创建对象的属性         writable:true,         configurable:true,         value: "newAdd"     } }); console.log(child)

Object.defineProperties(obj,props)

直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

1 2 3 4 5 6 7 8 9 10 11 12 13

var obj = {}; Object.defineProperties(obj, {   'property1': {     value: true,     writable: true   },   'property2': {     value: 'Hello',     writable: false   }   // etc. etc. }); console.log(obj)   // {property1: true, property2: "Hello"}

Object.defineProperty(obj,prop,descriptor)

在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Object.defineProperty(Object, 'is', {   value: function(x, y) {     if (x === y) {       // 针对+0 不等于 -0的情况       return x !== 0 || 1 / x === 1 / y;     }     // 针对NaN的情况     return x !== x && y !== y;   },   configurable: true,   enumerable: false,   writable: true  });  // 注意不能同时设置(writable，value) 和 get，set方法，否则浏览器会报错 ： Invalid property descriptor. Cannot both specify accessors and a value or writable attribute

Object.keys(obj)

 返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for...in 循环遍历该对象时返回的顺序一致 （两者的主要区别是 一个 for-in 循环还会枚举其原型链上的属性）。

1 2 3 4 5 6 7 8 9

let arr = ["a", "b", "c"]; console.log(Object.keys(arr)); // ['0', '1', '2'] /* Object 对象 */ let obj = { foo: "bar", baz: 42 },     keys = Object.keys(obj); console.log(keys); // ["foo","baz"]

Object.values()

方法返回一个给定对象自己的所有可枚举属性值的数组，值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

Object.values会过滤属性名为 Symbol 值的属性。

1 2 3 4 5

var an_obj = { 100: 'a', 2: 'b', 7: 'c' }; console.log(Object.values(an_obj)); // ['b', 'c', 'a'] var obj = { 0: 'a', 1: 'b', 2: 'c' }; console.log(Object.values(obj)); // ['a', 'b', 'c']

Object.entries()

返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环也枚举原型链中的属性）。

1 2 3 4 5

const obj = { foo: 'bar', baz: 42 }; console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ] const simuArray = { 0: 'a', 1: 'b', 2: 'c' }; console.log(Object.entries(simuArray)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

   

hasOwnProperty()

判断对象自身属性中是否具有指定的属性。

obj.hasOwnProperty('name')

Object.getOwnPropertyDescriptor(obj,prop)

返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）.

如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。

1 2 3 4 5 6

var arr = ['name','age'] ; arr.forEach(val => console.log(Object.getOwnPropertyDescriptor(obj,val))) // {value: "js", writable: true, enumerable: true, configurable: true} // undefined

 Object.getOwnPropertyDescriptors(obj)

获取一个对象的所有自身属性的描述符。

1 2 3 4 5

var obj = {     name : 'js',     age : 20 } console.log(Object.getOwnPropertyDescriptors(obj))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

const source = {   set foo(value) {     console.log(value);   } }; const target2 = {}; Object.defineProperties(target2, Object.getOwnPropertyDescriptors(source)); Object.getOwnPropertyDescriptor(target2, 'foo') const obj = Object.create(   some_obj,   Object.getOwnPropertyDescriptors({     foo: 123,   }) );

Object.getOwnPropertyNames()

返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

var obj = { 0: "a", 1: "b", 2: "c"}; Object.getOwnPropertyNames(obj).forEach(function(val) {   console.log(val); }); var obj = {     x : 1,     y : 2 } Object.defineProperty(obj,'z',{     enumerable : false }) console.log(Object.getOwnPropertyNames(obj))  // ["x", "y", "z"] 包含不可枚举属性 。 console.log(Object.keys(obj))                 // ["x", "y"]      只包含可枚举属性 。

Object.getOwnPropertySymbols()

返回一个给定对象自身的所有 Symbol 属性的数组。

Object.getPrototypeOf()

返回指定对象的原型（内部[[Prototype]]属性的值，即__proto__，而非对象的prototype）。

isPrototypeOf()

判断一个对象是否存在于另一个对象的原型链上。

Object.setPrototypeOf(obj,prototype)

设置对象的原型对象

Object.is()

判断两个值是否相同。

如果下列任何一项成立，则两个值相同：

• 两个值都是 undefined
• 两个值都是 null
• 两个值都是 true 或者都是 false
• 两个值是由相同个数的字符按照相同的顺序组成的字符串
• 两个值指向同一个对象
• 两个值都是数字并且
  • 都是正零 +0
  • 都是负零 -0
  • 都是 NaN
  • 都是除零和 NaN 外的其它同一个数字

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Object.is('foo', 'foo');     // true Object.is(window, window);   // true Object.is('foo', 'bar');     // false Object.is([], []);           // false var test = { a: 1 }; Object.is(test, test);       // true Object.is(null, null);       // true // 特例 Object.is(0, -0);            // false Object.is(-0, -0);           // true Object.is(NaN, 0/0);         // true

 

枚举是什么

• 枚举指对象的属性是否可以遍历出来，简单点说就是是否可以被列举出来。可枚举性决定了这个属性能否被for…in查找遍历到。
• js中基本包装类型的原型属性是不可枚举的，比如：

基本包装类型：Boolean,Number和String，就是即是基本类型，也是引用类型。基本包装类型还可以像引用类型一样通过对象的方法访问它自带的一些方法，但是不能像引用类型那样自定义方法。

var num = new Number();
for(var pro in num) {
    console.log("num." + pro + " = " + num[pro]);
}

结果为空，因为Number中内置的属性是不可枚举的；

• 判断一个属性是否可枚举，用Object.propertyIsEnumerable()来判断，但需要注意的一点是如果需要判断的属性在object的原型链上，不管它是否可枚举，Object.propertyIsEnumerable()都会返回false

propertyIsEnumerable() 方法返回一个布尔值，表示指定的属性是否可枚举。但是在原型链上propertyIsEnumerable不被考虑
hasOwnProperty()方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性