Object的方法

1.Object.is(value1,value2）// true or false
NaN === NaN // false
{} === {} // false
+0 === -0 // true

所以出现了：es6的is
Object.is(NaN,NaN)

2.Object.assign(target,…source)
合并对象，类似数组concat，如果key值相同，后面的对象覆盖前面的
enumber枚举属性才合并

//将源对象可枚举属性赋值到target上，
2.1如果重名，后面的覆盖前面的，类似于css样式覆盖，或者mixins
var target={a:1}
var source1={a:10}
var source2={c:1}
Object.assign(target,source1,source2)
// {a:10,c:1}

2.2.继承属性不可复制
var obj = {‘name’:‘lisi’};
var obj2 = {age:12};
Object.setPrototypeOf(obj,obj2);

// obj.__proto__ = obj2

console.log(obj.age); //12
var obj3 = Object.assign({},obj);
console.log(obj3.age); //undefined

2.3不可枚举不能assign复制。
const obj = Object.create({foo: 1}, { // foo 是个继承属性。
bar: {
value: 2 // bar 是个不可枚举属性。
},
baz: {
value: 3,
enumerable: true // baz 是个自身可枚举属性。
}
});

const copy = Object.assign({}, obj);
console.log(copy)

2.4assign是浅拷贝，当源对象中有引用类型的属性值时，复制的是引用地址

3.Object.getPrototypeOf()// 获得参数对象的原型
Object.getPrototypeOf() === Object.prototype //true

4.Object.setPrototypeOf() //设置原型，返回该参数对象
接收2个参数
function Person(){
this.name = ‘dean’,
this.age = 18
}

let proto = {
    url: 'https://www.baidu.com'
}

Person.prototype.city = '广东广州'
var one = new Person();
var two = new Person();
Object.setPrototypeOf(one, proto);

console.log(one.city); // undefined
console.log(two.city); // 广东广州

5.B= Object.create(A)
//由一个实例对象作为原型生成另一个实例对象的需求
// B动态继承A，A修改了,B也发生变化
5.1var A={
print:function(){
console.log(‘hello’)
}
}
var B = Object.create(A) //等于 B.proto = A
Object.getPrototypeOf(B) === A // true
B.proto === A
B.print === A.print

5.2 var obj1 = Object.create(null)// 创建没有对象属性和方法的obj
obj1.valueOf() //TypeError: obj1.valueOf is not a function

5.3第二个参数
var obj = Object.create({},{
p1:{
value:123,
enumberable:true,
configurable:true,
writable:true
}
})
等于下面代码：
var obj =Object.create({})
obj.p1 = 123;

var newObj = Object.create(obj,{
      t1:{
        value:'yupeng',
        writable:true
      },
      bar: {
        configurable: false,
        get: function() { return bar; },
        set: function(value) { bar=value }
      }
       
    })
 
    console.log(newObj.a())
    newObj.bar =88

6.Object.prototype.isPrototypeOf()
//判断(前面)对象是否为参数对象的原型(后面)
var o1 ={}
var o2 = Object.create(o1)
var o3 = Object.create(o2)
o2.isPrototypeOf(o3) //true
o1.isPrototypeOf(o3) //true

7.Object.prototype.proto
var obj = {}
var p ={}
obj.proto = p
Object.getPrototypeOf(obj) === p

8.call
var A={name:‘张三’}
var B = {name:‘李四’}
var proto ={print:function(){console.log(this.name)}}

proto.print.call(A) //张三
或者直接修改原型链
A.proto =proto

9.Object.getOwnPropertyNames(A)
返回一个数组，成员是A的所有属性键名，不包括继承的键名
9.1和Object.keys()的区别
keys返回可枚举的属性键名
getOwnPropertyNames返回所有的
const obj = {};
Object.defineProperties(obj, {
property1: {enumerable: true, value: 1},
property2: {enumerable: false, value: 2},
});

console.log(Object.keys(obj)); // Array [“property1”]，不可枚举就没返回
console.log(Object.getOwnPropertyNames(obj)) Array [“property1”, “property2”]

10.Object.prototype.hasOwnProperty(属性名)
返回Boolean,判断某个属性在对象自身，还是在原型链上
Date.hasOwnProperty(‘length’) //true

11.Object.getOwnPropertyDescriptor
属性的可枚举性
var A ={
name:‘张三’
}
Object.getOwnPropertyDescriptor(A,‘name’)
//{value: “张三”, writable: true, enumerable: true, configurable: true}

最后总结ES6增加的方法有：
Object.is(value1,value2)
Object.assign(target,…source)
Object.create(,{value:1})

Object.getOwnPropertyDescriptors()
__proto__属性，

Object.setPrototypeOf()，Object.getPrototypeOf()
Object…isPrototypeOf()

Object.keys()，Object.values()，
//返回数组

var ent = Object.entries(obj)
//返回键值对的数组
var obj = (3) [Array(2), Array(2), Array(2)]
0: (2) [“mealA”, “Breakfast”]
1: (2) [“mealB”, “Lunch”]
2: (2) [“mealC”, “Dinner”]

Object.fromEntries(ent)
// 返回对象 {mealA: “Breakfast”, mealB: “Lunch”, mealC: “Dinner”}

Object.defineProperty(obj,key,{
6个handle
(1) 拥有布尔值的键 configurable、enumerable 和 writable 的默认值都是 false。
(2) 属性值和函数的键 value、get 和 set 字段的默认值为 undefined。
})
let obj = {
name: ‘zyp’,
likes: [‘sleep’, ‘read’]
};
function observe(obj) {
Object.keys(obj).map(key => {
reactive(obj, key, obj[key])
})
}
function reactive(obj, key, value) {
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
set(val) {
console.log(‘set’)
value = val
},
get() {
console.log(‘get’)
return value
}
})
}
observe(obj)
obj.name = ‘zyp1’
console.log(‘obj—>’, obj)

Object.freeze(obj);
Object.isFrozen(obj)