object方法集合

Object的新增方法

Object.is()

作用：用于判断两个值是否相等

语法：boolean = Object.is(a,b)

说明：判断a和b两个值是否相等，返回布尔值

举例：

Object.is('a','a') // true
Object.is([],[]) // false
Object.is(NaN,NaN) // true
Object.is(+0,-0) // false

备注：

1. 优化了 === 在判断 NaN 、NaN 为false的问题（现在为true）
2. 优化了 === 在判断 +1、-1 为true的问题（现在为false）
3. 如果传入多个值 Object.is(‘a’,‘a’,‘b’,‘c’) ，只判断前面两个，结果依然为true

Object.assign()

作用：用于合并（混入）对象

语法：Object.assign(target,obj1,obj2)

说明：把obj1和obj2合并到target中，也返回target

举例：

let target = {
    a:1,
    b:1
}
let obj1 = {
    b:2
}
let obj2 = {
    c:3
}
Object.assign(target,obj1,obj2) // target = {a: 1, b: 2, c: 3}

备注：

1. 如果对象中存在一样的属性，后面的属性值会替代前面的属性值

Object.create()

作用：主要用于继承

语法：newObj = Object.create(obj)

说明：

1. 创建一个新的空白对象，可以**继承**了obj 对象的属性
2. 支持第二参数为对象（必须严格按照数据劫持格式），可配置当前新对象的属性

举例：

// 1. 一般用法---继承
// es5 的继承写法
const newObj = {}
const obj = {
  a:1,
  b:2
};
newobj.__proto__ = obj;
// newobj { prototype:{a:1,b:2} }  newobj 本身是空对象，但原型上拥有a、b属性

// es6 的继承写法
const newObj = Object.create(obj);
// newobj 效果同上
                         


// 2. 特殊用法---传入第二参数。参数为对象（要求必须是严格按照数据劫持中的格式来），可配置newobj对象本身的属性
const obj = {
    a:1,
    b:2,
}
const configObj = {
    b:{
        value:3,
    },
    c:{
        value:3, // 默认值
        writable: true, // 可写入
        enumerable: true, // 可枚举
        configurable: true // 可配置
    }
}
let newObj = Object.create(obj,configObj)
// newobj { b:3 , c:3 , prototype:{a:1,b:2} }  newobj 本身拥有b和c两个属性，并且原型中拥有a、b 两个属性

Object.keys()

作用：获取对象中所有的键返回一个新数组

语法：let arr = Object.keys(obj)

举例：

const obj = {
    a: 1,
    b: 2,
    c: 3
}
let arr = Object.keys(obj) // [ 'a', 'b', 'c' ]

Object.values()

作用：获取对象中所有的值返回一个新数组

语法：let arr = Object.values(obj)

举例：

const obj = {
    a: 1,
    b: 2,
    c: 3
}
let arr = Object.values(obj) // [ '1', '2', '3' ]

Object.entries()

作用：获取对象中所有的键和值返回一个新二维数组

语法：let arr = Object.entries(obj)

举例：

const obj = {
    a: 1,
    b: 2,
    c: 3
}
let arr = Object.entries(obj) // [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ] ]

Object.hasOwn()

作用：判断当前对象本身是否包含这个属性，但不包含原型中的属性

语法：let boolean = Object.hasOwn(target,‘prop’)

举例：

const obj = {
    a:1
}
let newObj = Object.create(obj)
newObj.b = 2;
//newObj {b:2 , protoptye:{a:1}}
console.log(Object.hasOwn(newObj,'a')) //false
console.log(Object.hasOwn(newObj,'b')) //true

注意：

Object.hasOwn()和obj.hasOwnProperty()和in的区别

相同点：

Object.hasOwn()和obj.hasOwnProperty()和in 的功能基本一致，都可以判断是否包含属性

不同点：

1. Object.hasOwn()是obj.hasOwnProperty()的升级版，obj.hasOwnProperty()判断没有原形的对象时会报错

   // 正常使用
   const obj = {
       a:1
   }
   let newObj = Object.create(obj)
   newObj.b = 2;
   //newObj {b:2 , protoptye:{a:1}}
   console.log(newObj.hasOwnProperty('a')) //false
   console.log(newObj.hasOwnProperty('b')) //true
   
   // 报错情况：没有原型
   let newObj = Object.create(null)
   newObj.b = 2;
   //newObj {b:2}
   console.log(newObj.hasOwnProperty('b')) // 报错
   

2. 运算符 in 可以判断当前对象本身和原型中是否包含这个属性

   const obj = {
       a:1
   }
   let newObj = Object.create(obj)
   newObj.b = 2;
   //newObj {b:2 , protoptye:{a:1}}
   console.log('a' in newObj) // true
   console.log('b' in newObj) // true
   

Object.setPrototypeOf()

作用：与 __proto__相同、给一个对象设置原形对象

语法：Object.setPrototypeOf(target,objprototype)

说明：和Object.getPrototypeOf()对立，给target对象设置一个原型对象proto

举例：

var target = {
	a:1
}
var proto = {
	b:2
}
target.__proto__ = {proto:2}
// 或
Object.setPrototypeOf(target,proto) 
console.log(target); // target { a:1 , prototype: { b:2 }}
console.log(target.a); // 1
console.log(target.b); // 2

Object.getPrototypeOf(target)

作用：与 __proto__相同、获取原形对象

语法：let proto = Object.getPrototypeOf(target)

说明：和setPrototypeOf()对立，获取target对象身上的原型对象

举例：

var target = {
	a:1
}
target.__proto__ = {c:3}
// 或
let proto = Object.setPrototypeOf(target,{c:3})
console.log(proto)  // {c:3}

Object.defineProperty()和Object.defineProperties()

作用：都可以用于数据劫持(劫持一个、劫持多个)

语法：Object.defineProperty(obj,‘prop’,configObj)和Object.defineProperties(obj,configObj)

说明：

1. 控制obj对象里面的各种属性，默认值、是否可写入、是否可枚举、是否可配置
2. 劫持obj对象里面的各种属性，给属性添加get、set方法，无论获取、设置属性都会触发方法
3. vue2.X版本中的 v-model 双向数据绑定原理就用到了 Object.defineProperty

举例：

var obj = { myname: 1 };
Object.defineProperty(obj,'myname',{
	  configurable: true, //是否可以删除或者修改该属性
	  enumerable: true, //是否可枚举该属性
	  writable: false, //是否可修改该属性，可以定义对象中的常量属性，默认是false
	  value: 4, // value就是该属性的默认值，如果value是一个函数，myname就是一个方法
      set: function (value) { //设置prop时被触发
		  this._c = value;
      },
      get: function () { //获取prop时被触发
          return this._c;
      },
})

var obj = {};
var c = Symbol();
Object.defineProperties(obj, {
    "a": {
        value: 1,
    },
    b: {
        enumerable: true,
        configurable: true,
        value: 5,
    },
    [c]: {
        writable: true,
        value: 10,
    },
});
// obj 现在同时 拥有a b c 3个属性。不可删除或修改描述对象以及不可枚举的属性有"a"和[c]，不可修改值的属性有"a"和b。

obj.isPrototypeOf()

作用：判断一个对象是否存在于另一个对象的原形链中

语法：let boolean = obj1.isPrototypeOf(obj2)

说明：某原型.isPrototypeOf(被测试的对象)

举例：

class Animal {
    constructor() {
        this.type = '动物'
    }
}
class Dog extends Animal{
    constructor(){
        super()
        this.name = '狗'
    }
}
class Cat extends Animal{
    constructor(){
        super()
        this.name = '猫'
    }
}
let dog = new Dog()
console.log(Animal.prototype.isPrototypeOf(dog)); // true  狗处于动物构造函数的原型上
console.log(Dog.prototype.isPrototypeOf(dog)); // true     狗处于狗构造函数的原型上
console.log(Cat.prototype.isPrototypeOf(dog)); // false    狗不处于猫构造函数的原型上
// 或 类似于 被检测的对象 instanceof 构造函数
console.log(dog instanceof Animal); // true  狗处于动物构造函数的原型上
console.log(dog instanceof Dog);// true     狗处于狗构造函数的原型上
console.log(dog instanceof Cat);// false    狗不处于猫构造函数的原型上
// 或  typof  无法区分数组的类型
console.log(typeof {}); // object
console.log(typeof []); // object
console.log([] instanceof Array); // true
console.log({} instanceof Object);// true

注意：

1. Animal.prototype.isPrototypeOf(dog) 检测dog这个对象是否存在于Animal.prototype的原形链上，只要是存在返回true，不存在返回false
2. 有些类似于 运算符 instanceof
3. instanceof 判断某对象是否是构造函数的实例、isPrototypeOf 判断某对象是否是处于某原形链上