ES6第十天

对象的新增方法

1. Object.is()，ES6 提出“Same-value equality”（同值相等）算法，用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。

		console.log(NaN === NaN)   //false
        console.log(Object.is(NaN,NaN))  //true
        
        console.log(Object.is(+0,-0))  //false
        console.log(+0 === -0) //true

2. Object.assign()，Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target），Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。

		let a = {a:5,b:10}
        let b = {a:10,c:15}
        // 后面的对象里的a与前面的a名字冲突，后者的值会覆盖前面的值
        console.log(Object.assign(a,b))  //{a: 10, b: 10, c: 15}

		// 如果只有一个参数，Object.assign会直接返回该参数。
        let b = {a:5}
        console.log(Object.assign(b)  === b)  //true
		
		// 如果该参数不是对象，则会先转成对象，然后返回。
        console.log(typeof Object.assign(2))  //"object"
        console.log(Object.assign(undefined)) //由于无法转成对象，所以会报错
		console.log(Object.assign(null)) // 由于无法转成对象，所以会报错

3. Object.getOwnPropertyDescriptors()，返回一个对象，所有原对象的属性名都是该对象的属性名，对应的属性值就是该属性的描述对象。

		let obj = {
            name:"Jack",
            age:18
        }
        console.log(Object.getOwnPropertyDescriptors(obj))  //{name: {…}, age: {…}}
        //age:
        // configurable: true
        // enumerable: true
        // value: 18
        // writable: true
        // __proto__: Object

        // name:
        // configurable: true
        // enumerable: true
        // value: "Jack"
        // writable: true
        // __proto__: Object

4. __proto__属性，Object.setPrototypeOf()，Object.getPrototypeOf()

	//__proto__属性（前后各两个下划线），用来读取或设置当前对象的原型对象（prototype）,__proto__调用的是Object.prototype.__proto__
	//Object.setPrototypeOf方法的作用与__proto__相同，用来设置一个对象的原型对象（prototype），返回参数对象本身
	let proto = {};
    let obj = { x: 10 };
    Object.setPrototypeOf(obj, proto);
    proto.y = 20;
    proto.z = 40;
    console.log(obj.x) // 10
    console.log(obj.y) // 20
    console.log(obj.z) // 40
    //Object.getPrototypeOf() ,与Object.setPrototypeOf方法配套，用于读取一个对象的原型对象。
    let proto = {};
    let obj = { x: 10 };
    Object.setPrototypeOf(obj, proto);
    proto.y =20
    console.log(Object.getPrototypeOf(obj))  //{y:20}

5. Object.keys()，Object.values()，Object.entries()

	//Object.keys(),返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名
	let { keys, values, entries } = Object;
    let obj = { a: 1, b: 2, c: 3 };
    for (let key of keys(obj)) {
        console.log(key);   //a  b  c
    }
	
	//Object.values(),返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值
	let obj = { name: 'Jack', age: 22 };
    console.log(Object.values(obj)) //["Jack", 22]

	//Object.entries() ,返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组
	const obj = { name: 'Mary', age: 25 };
    console.log(Object.entries(obj))    //[Array(2), Array(2)]
                                        // 0: (2) ["name", "Mary"]
                                        // 1: (2) ["age", 25]

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

		console.log(Object.fromEntries([
            ['name', 'Jack'],
            ['age', 22]
        ]))
        //{name: "Jack", age: 22}