5. 对象的扩展

属性的简洁表示法

es6允许直接写入变量和函数作为对象的属性的方法

const name='tom';
const obj={
    name,
    sayHi(){
        console.log('hi');
    }
}
//es5
var obj={
    name:name,
    sayHi:function () {
        console.log("hi");
    }
}

使用这种语法可以极大的简化我们返回对象的写法

function getPoint() {
    const x=1;
    const y=2;
    return {x,y};
}
//es5
function getPoint() {
    var x=1;
    var y=2;
    return{
        x:x,
        y:y
    }
}

属性名表达式

在es6中允许我们在使用大括号内定义属性名/方法时使用变量

let key={
  a:1
}
let obj={
    ['name'+'Is']:'tom',
    ['say'+'Hi']:function () {
        console.log("hi");
    }
  [key]:'value'
  //如果属性名是一个对象，会被自动转换为[object Object]的形式
}
obj//{nameIs: "tom", sayHi: ƒ, [object Object]: "value"}

需要注意的是在使用了变量语法时不能使用简洁表达式，会报错

在es5中如果不是在大括号的形式下添加对象属性，同样可以使用变量定义属性名

var obj={};
obj['name']='tom';

方法的name属性

对象的方法也是一个函数，所以也会有name属性

 var obj={
    say:()=>{
        console.log(this);
    }
};
obj.say.name //say

Object.is()

用来比较两个值是否严格相等，与严格运算符'==='的行为基本一致，但是在判别时不会出现像前者一样的判断NaN不等于自身或+0等于-0的情况，也不会出现'=='的默认转换数据类型的情况

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

在es5中可以通过如下代码来部署Object.is

Object.defineProperty(Object,'is',{
    value:function (x,y) {
        if(x===y) {
            return x !== 0 || 1 / x === 1 / y;
        }
        return x!==x&&y!==y;
    },
    configurable:true,
    enumerable:false,
    writable:true
})

Object.assign()

Object.assign方法用于对象的合并，将源对象(source)的所有可枚举属性，复制到目标对象(target)

Object.assign(target,source1,source2)

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

如果只有一个参数，Object.assign会直接返回该参数

如果参数不是对象，该参数会被转换为对象然后返回，有undefined和null不是对象，所以如果它们作为参数，就会报错

const target={a:1,b:1};
const source1={b:2,c:2};
const source2={c:3};

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

Object.assign(undefined) //Uncaught TypeError
typeof Object.assign(2) //object

如果非对象属性参数出现在源对象的位置,那么这些参数如果能够被转换为对象，会被转换，如果不能转化，则会直接跳过，也就是说，null和undefined只要不出现在首参数，就不会报错，其它类型的值虽然不会报错，但是除了字符转以外，其它值都不会生效，字符串则会被认为是可枚举对象以数组对象拷贝到目标对象

Object.assign只拷贝源对象的自身属性，不拷贝继承属性，也不拷贝不可枚举的属性，而且该方法实行的是浅拷贝，最后的对象是对源对象的值的引用，也就是说如果源对象的值如果是对象，该值发生改变，那么都会反应到目标对象上

const target = {},
      obj = {
        a:{
            name:'tom'
        },
        age: 18
      };
Object.assign(target,obj);
console.log(target); //a:{name:'tom'}
obj.a.name="change";
console.log(target); //a:{name: "change"}

对于嵌套的对象，一旦遇到同名属性，Object.assign的处理方式是替换，而不是添加，这一点需要特别注意

在处理数组时，如果目标对象和源对象都是数组，那么目标对象的数组内的值会被源对象数组相对位置上的值替换掉

属性的可枚举性和遍历

对象的每一个属性都有一个描述对象，用来控制该属性的行为，Object.getOwnPropertyDescruotor方法可以获取该属性的描述对象

   let obj={name:'tom'};
   Object.getOwnPropertyDescriptor(obj,'name');
   //value: "tom", writable: true, enumerable: true, configurable: true

描述对象的enumerable属性，称为'可枚举行'，如果该属性为false，就表示某些操作会忽略当前属性

目前，有四个操作会忽略enumerable为false的属性。

• for...in循环：只遍历对象自身的和继承的可枚举的属性
• Object.keys()：以数组格式返回对象自身的所有可枚举的属性的键名
• JSON.stringify()：只串行化对象自身的可枚举的属性
• Object.assign()：忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性

这三个操作，前三个是es5就有的，其中for...in会返回继承的属性，其它三个方法都会忽略继承的属性，只处理对象自身的属性。实际上，引入"可枚举"这一概念的最初目的就是让某些属性可以规避掉for...in操作，不然所有内部属性和方法都会被遍历到，比如，对象原型的toString方法，以及数组的length属性，就通过设置"可枚举"为false来避免被for...in遍历到

另外，在es6中，所有class的原型的方法都是不可枚举的

总体来说，大多数时候我们只关心对象自身的属性，所以尽量使用Object.keys()来替代for...in循环

属性的遍历

ES6一共有5种可以遍历对象的属性

• for...in

  循环遍历对象自身的和继承的可枚举属性

• Object.keys()

  Object.keys返回一个数组，包含对象自身的(不包含继承的)所有可枚举属性的键名

• Object.getOwnPropetyNames(obj)

  返回一个数组，包含对象自身的所有属性（包含不可枚举属性）的键名

• Object.getOwnpropetySymbols(obj)

  返回一个数组，包含对象自身的所有Symbol属性的键名

• Reflet.ownKeys(obj)

  返回对象所有的键名，包括Symbol

  以上的五种方法遍历对象的键名，都遵守同样的属性遍历的次序规则

  1. 首先遍历所有的数值键，按照数值升序排列
  2. 其次遍历所有的字符串键，按照加入时间升序排列
  3. 最后遍历说有Symbol键，按照加入时间升序排列

super关键字

es6新加入一个关键字，用于指向当前对象的原型对象