es6笔记3^_^object

一、destructuring

　　ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构Destructuring。

//es5
if(1){
    let cat = 'ken';
    let dog = 'lili';
    let zoo = {cat: cat, dog: dog};
    console.log(zoo) ; //Object {cat: "ken", dog: "lili"}
}
//用ES6完全可以像下面这么写：
if(1){
    let cat = 'ken';
    let dog = 'lili';
    let zoo = {cat, dog};
    console.log(zoo) ; //Object {cat: "ken", dog: "lili"}
}
//反过来可以这么写：
if(1){
    let dog = {type: 'animal', many: 2};
    let { type, many} = dog;
    console.log(type, many) ;  //animal 2
}

二、属性名表达式

　　用方法、表达式作为对象的属性名;表达式还可以用于定义方法名。
　　JavaScript语言定义对象的属性，有两种方法。

    let obj1 = {};
// 方法一
    obj1.foo = true;
// 方法二
    obj1['a'+'bc'] = 123;
    console.log(obj1);

　　上面代码的方法一是直接用标识符作为属性名，方法二是用表达式作为属性名，这时要将表达式放在方括号之内。
 　　如果使用字面量方式定义对象（使用大括号），在ES5中只能使用方法一（标识符）定义属性。

    var obj2 = {
        foo: true,
        abc: 123
    }

　　ES6允许字面量定义对象时，用方法（表达式）作为对象的属性名，即把表达式放在方括号内。

    let propKey = 'foo';
    let obj3 = {
        [propKey]: true,
        ['a'+'bc']: 123
    };
    console.log(obj3);
//表达式还可以用于定义方法名。
    let ello='i';
    let obj4 = {
        ['h'+ello]() {
            return 'hi nick';
        }
    };
    console.log(obj4.hi()); // hi nick

三、Object.is()

　　Object.is()用来比较两个值是否严格相等。它与严格比较运算符（===）的行为基本一致，不同之处只有两个：一是+0不等于-0，二是NaN等于自身。

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

四、Object.assign()

　　Object.assign方法用来将源对象（source）的所有可枚举属性，复制到目标对象（target）。
　　它至少需要两个对象作为参数，第一个参数是目标对象，后面的参数都是源对象。只要有一个参数不是对象，就会抛出TypeError错误。

    let target = { a: 1 };
    let source1 = { b: 2 };
    let source2 = { c: 3 };
    Object.assign(target, source1, source2);
    console.log(target); // {a:1, b:2, c:3}

注意：如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

    let target1 = { a: 1, b: 1 };
    let source11 = { b: 2, c: 2 };
    let source21 = { c: 3 };

    Object.assign(target1, source11, source21);
    console.log(target1);  // {a:1, b:2, c:3}
    console.log(Object.assign({'name':'张三'},{'name':'nick','age':26,'sex':'男','sex':{'gander':'handsome'}}));

　　Object.assign只拷贝自身属性，不可枚举的属性（enumerable为false）和继承的属性不会被拷贝。

     let  obj1=Object.assign({b: 'c'},
                Object.defineProperty({}, 'invisible', {
                    enumerable: false,
                    value: 'hello'
                })
        );
        console.log(obj1);// { b: 'c' }

    let obj2 =Object.assign({b: 'c'},
            Object.defineProperty({}, 'invisible', {
                enumerable: true,
                value: 'hello'
            })
    );
    console.log(obj2);// {b: "c", invisible: "hello"}

　　属性名为Symbol值的属性，也会被Object.assign拷贝。

    let obj3=Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
    console.log(obj3);// { a: 'b', Symbol(c): 'd' }

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

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

　　其中，4覆盖1，5覆盖2，因为它们在数组的同一位置，所以就对应位置覆盖了。　　

　　Object.assign还有很多用处，下面就看一下吧：　　　

　　为对象添加属性

    class Point {
        constructor(x, y) {
            Object.assign(this, {x, y});
        }
    }

　　这样就给Point类的对象实例添加了x、y属性。

　　为对象添加方法

    let SomeClass={test:'nick'};
    SomeClass.prototype={};
    Object.assign(SomeClass.prototype, {
        someMethod:function(arg1, arg2) {

        },
        anotherMethod:function () {

        }
    });
    console.log(SomeClass);

　　等同于下面的写法

    let SomeClass2={test:'nick2'};
    SomeClass2.prototype={};
    SomeClass2.prototype.someMethod = function (arg1, arg2) {

    };
    SomeClass2.prototype.anotherMethod = function () {

    };
    console.log(SomeClass2);

　　上面代码使用了对象属性的简洁表示法，直接将两个函数放在大括号中，再使用assign方法添加到SomeClass.prototype之中。

　　克隆对象

    function clone1(origin) {
        return Object.assign({}, origin);
    }

　　上面代码将原始对象拷贝到一个空对象，就得到了原始对象的克隆。
　　不过，采用这种方法克隆，只能克隆原始对象自身的值，不能克隆它继承的值。如果想要保持继承链，可以采用下面的代码。

function clone2(origin) {
    let originProto = Object.getPrototypeOf(origin);
    return Object.assign(Object.create(originProto), origin);
}

　　在JS里子类利用Object.getPrototypeOf去调用父类方法,用来获取对象的原型。用它可以模仿Java的super。　

　　多个对象合并到某个对象

    const merge1 =(target, ...sources) => Object.assign(target, ...sources);

　　多个对象合并到一个新对象

    const merge2 = (...sources) => Object.assign({},...sources);

　　为属性指定默认值

    const DEFAULTS = {
        logLevel: 0,
        outputFormat: 'html'
    };

    function processContent(options) {
        let options1 = Object.assign({}, DEFAULTS, options);
    }

　　上面代码中，DEFAULTS对象是默认值，options对象是用户提供的参数。Object.assign方法将DEFAULTS和options合并成一个新对象，如果两者有同名属性，则option的属性值会覆盖DEFAULTS的属性值。
注: 由于存在深拷贝的问题，DEFAULTS对象和options对象的所有属性的值，都只能是简单类型，而不能指向另一个对象。否则，将导致DEFAULTS对象的该属性不起作用。
此篇全部代码：

View Code

此篇终，待续……