JS对象Object

常用方法

Object.assign(target, …sources)

介绍：此方法将所有可枚举（Object.propertyIsEnumerable() 返回 true）和自有（Object.hasOwnProperty() 返回 true）属性从一个或多个源对象复制到目标对象，返回修改后的对象。(修改目标对象)

/**
*target:目标对象,也是修改后的返回值。
*source:源对象，包含将被合并的属性。可以多个
*/
var target = { a:"1",b:"2"}
var source = {b:"3",c:"4"}
var result = Object.assign(target,source)
console.log(target) // {a:"1",b:"3",c:"4"}
console.log(result) // {a:"1",b:"3",c:"4"}
console.log(result === target) // true
typeof Object.assign(2) // "object"
Object.assign(undefined) // 报错
Object.assign(null) // 报错

如果该参数不是对象，则会先转成对象，然后返回。

Object.assign(2) // 2
typeof Object.assign(2) // "object"

由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。

Object.assign(undefined) // 报错
Object.assign(null) // 报错

undefined和null不在首参数，就不会报错，将会跳过。

Object.assign({},undefined,null) // 不报错

其他类型的值（即数值、字符串和布尔值）不在首参数，也不会报错。
但是，除了字符串会以数组形式，拷贝入目标对象，其他值都不会产生效果。

const obj1= { a: 1, b: 2 };
const obj2= 10;
const obj3= true;
const obj4= "abc"

Object.assign(obj2); // 10
Object.assign(obj1,obj2); // { a: 1, b: 2 } 不报错
Object.assign(obj3,obj2); // true
Object.assign(obj4,obj2,obj3); // { "abc" }
Object.assign({},obj4,obj2,obj3); // { 0: "a", 1: "b", 2: "c" }

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

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

只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。
若复制的值是一个赋值或取值函数，则为undefined

const target = {};
const source = {
  get foo() { return 1 }
  set bar(value) {}
};
Object.assign(target, source) //{ foo: 1 ,bar: undefined}

Object.is(value1, value2)

判断两个值是否为同一个值。
返回值：一个布尔值

Object.is(null, null);            // true
Object.is(undefined, undefined);  // true
var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, bar);              // false
Object.is(0, -0);                 // false
Object.is(+0, -0);                // false
Object.is(-0, -0);                // true
Object.is(NaN, 0/0);              // true
Object.is(NaN, Number.NaN)        // true

Object.create()

方法用于创建一个新对象，使用现有的对象来作为新创建对象的原型（prototype）。
返回值：一个新对象，带着指定的原型对象及其属性。

 // obj将在原型对象上，而不是直接属性
  var Obj ={
    name:'zhangsan',
    age:18,
    show:function () {
      console.log(this.name +" is " +this.age);
    }
  }
  var MyObj = Object.create(Obj,{
    hobby:{
      value:"football",        // 初始化赋值
      writable:true,       // 是否是可改写的
      configurable:true,   // 是否能够删除，是否能够被修改
      enumerable:true      //是否可以用for in 进行枚举
    }
  })
 

注意：Object.create(null) 创建的对象是一个空对象，在该对象上没有继承 Object.prototype 原型链上的属性或者方法

Object.create(null) //{} 
new Object()        // {[[Prototype]]: Object}
var obj = {}        // {[[Prototype]]: Object}

Object.getOwnPropertyNames()

方法返回一个由 指定对象的所有自身属性的属性名（包括不可枚举属性但不包括 Symbol 值作为名称的属性） 组成的数组。
注意：该方法不会获取到原型链上的属性

var arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr)); // ["0", "1", "2", "length"]
var obj = { 0: "a", 1: "b", 2: "c"};
console.log(Object.getOwnPropertyNames(obj)); // ["0", "1", "2"]

Object.keys()

返回一个数组，成员是参数对象自身的 （不含继承的） 所有 可遍历（enumerable） 属性的键名。
注意：在 ES5 里，如果此方法的参数不是对象（而是一个原始值），那么它会抛出 TypeError。在 ES2015 中，非对象的参数将被强制转换为一个对象。

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)  // ["foo", "baz"]
Object.keys("foo"); // TypeError: "foo" is not an object (ES5 code)
Object.keys("foo");  // ["0", "1", "2"]   (ES2015 code)

Object.values()

返回一个数组，成员是参数对象自身的 （不含继承的） 所有 可遍历（enumerable） 属性的键值。
如果参数是一个字符串，会返回各个字符组成的一个数组。
如果参数不是对象，Object.values会先将其转为对象。由于数值和布尔值的包装对象，都不会为实例添加非继承的属性。所以，Object.values会返回空数组。
属性名为数值的属性，是按照数值大小，从小到大遍历的

const obj = { foo: 'bar', baz: 42 };
Object.values(obj)  // ["b", "c", "a"]

Object.values('foo')  // ['f', 'o', 'o']
Object.values(42) // []
Object.values(true) // []
Object.values({ 100: 'a', 2: 'b', 7: 'c' }) // ["b", "c", "a"]

Object.entries()

返回一个数组，成员是参数对象自身的 （不含继承的） 所有 可遍历（enumerable） 属性的键值对数组。

const obj = { foo: 'bar', baz: 42 };
Object.entries(obj) // [ ["foo", "bar"], ["baz", 42] ]

基本用途是遍历对象的属性。

let obj = { one: 1, two: 2 };
for (let [k, v] of Object.entries(obj)) {
  console.log(
    `${JSON.stringify(k)}: ${JSON.stringify(v)}`
  );
}
// "one": 1
// "two": 2

Object.fromEntries()

此方法是Object.entries()的逆操作，用于将一个键值对数组转为对象。

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

Object.defineProperty(obj, prop, descriptor)

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

descriptor属性介绍：
value: 该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined
configurable: 仅当该属性的 configurable 为 true 时，该属性才能够被改变，也能够被删除。默认为 false
enumerable: 仅当该属性的 enumerable 为 true 时，该属性才能够出现在对象的枚举属性中。默认为 false
writable: 仅当仅当该属性的writable为 true 时，该属性才能被赋值运算符改变。默认为 false
get: 一个给属性提供 getter 的方法，如果没有 getter 则为 undefined。该方法返回值被用作属性值。undefined
set: 一个给属性提供 setter 的方法，如果没有 setter 则为 undefined。该方法将接受唯一参数，并将该参数的新值分配给该属性。默认为undefined。
注意：value和writable不能与get/set同时存在。

/**
* obj:要定义属性的对象。
* prop:对象中要定义或修改的属性
* descriptor:属性描述
*/
let obj = {}
Object.defineProperty(obj, 'myProp', {
  value: 42,
  writable: true,
  configurable:true,
  enumerable:true,
  get:function(){
  },
  set:function(value){
  }
});

Object.getOwnPropertyDescriptor(obj, prop)

方法会返回某个对象属性的描述对象（descriptor）

/**
* obj:需要查找的目标对象
* prop:对象的属性名
*/
let obj = {
	name:"zhangsan"
}
Object.getOwnPropertyDescriptor(obj,"name")
//{ value: "zhangsan", writable: true, enumerable: true, configurable: true }

Object.getOwnPropertyDescriptors(obj)

返回指定对象 所有 自身属性（非继承属性）的描述对象。

const obj = {
  foo: 123,
  get bar() { return 'abc' }
};

Object.getOwnPropertyDescriptors(obj)
// { foo:
//    { value: 123,
//      writable: true,
//      enumerable: true,
//      configurable: true },
//   bar:
//    { get: [Function: get bar],
//      set: undefined,
//      enumerable: true,
//      configurable: true } }

该方法的引入目的，主要是为了解决Object.assign()无法正确拷贝get属性和set属性的问题。

let obj = {
	set foo(value){}
}
let res = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj))
Object.getOwnPropertyDescriptors(res)
// { get: undefined,
//   set: [Function: set foo],
//   enumerable: true,
//   configurable: true }

Object.hasOwn(obj,prop)

可以判断是否为自身的属性。

/**
* obj:需要查找的目标对象
* prop:对象的属性名
*/
let obj = Object.create({name:"zhangsan"}) //name属性通过create方法继承而来
obj.age = 23
Object.hasOwn(obj,"name") // false
Object.hasOwn(obj,"age ") // true

与Object.prototype.hasOwnProperty()区别：
1.对于没有prototype的不继承任何属性的对象hasOwnProperty()会报错；而hasOwn()不会
2.hasOwnProperty()不能判断继承属性

const obj = Object.create(null);
obj.hasOwnProperty('foo') // 报错
Object.hasOwn(obj, 'foo') // false

Object.prototype.hasOwnProperty()

返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。
不能判断继承属性

let obj = Object.create({name:"zhangsan"}) //name属性通过create方法继承而来
obj.age = 23
obj.hasOwnProperty("zhangsan") // false
obj.hasOwnProperty("age ") // true