ES6看完必会第九章------ 对象的扩展 （可私信解惑，不会来捶我）

• 属性的简洁表示法

ES6允许直接写入变量和函数，作为对象的属性和方法。这样的书写更加简洁。

var foo = 'bar';
var baz = {foo};
console.log( baz )        //  { foo: 'bar' } 

//等同于
var foo = 'bar';
var baz={ foo:foo};
console.log( baz )        //  { foo: 'bar' } 

 

除了属性简写，方法也可以简写。

var func= {
    method() {
        return "这里是ES6方法简写!";
   }
};

// 等同于
var func= {
    method: function() {
        return "这里是ES6以前的方法!";
    }
};

• 属性名表达式

JavaScript语言定义对象的属性，有两种方法。

// 方法一
obj.foo = true;
// 方法二
obj['a' + 'bc'] = 123;

上面代码的方法一是直接用标识符作为属性名，方法二是用表达式作为属性名，这时要将表达式放在方括号之内。

 

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

let propKey = 'foo';
let obj = {
    [propKey]: true,
    ['a' + 'bc']: 123        // ES5使用大括号时不能这样定义
}

表达式还可以用于定义方法名。

let obj = {
  ['f' + 'unc']() {
    return '欢迎来到w3cschool';
  }
};
obj.func()     // 欢迎来到w3cschool

注意，属性名表达式与简洁表示法，不能同时使用，会报错。

 

• 属性的遍历

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

 

• for...in

    for...in循环遍历对象自身的和继承的可枚举属性（不含Symbol属性）。

 

• Object.keys(obj)

    Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含Symbol属性）。

 

• Object.getOwnPropertyNames(obj)

    Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含Symbol属性，但是包括不可枚举属性）。

 

• Object.getOwnPropertySymbols(obj)

    Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有Symbol属性。、

 

• Reflect.ownKeys(obj)

    Reflect.ownKeys返回一个数组，包含对象自身的所有属性，不管是属性名是Symbol或字符串，也不管是否可枚举。

 

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

• 首先遍历所有属性名为数值的属性，按照数字排序。
• 其次遍历所有属性名为字符串的属性，按照生成时间排序。
• 最后遍历所有属性名为Symbol值的属性，按照生成时间排序。

• Object.assign()

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

Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。

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

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

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

var target = { a: 111, b: 111 };

var source1 = { b: 222, c: 222 };
var source2 = { c: 333 };
Object.assign(target, source1, source2);
target     // {a:111, b:222, c:333}

如果该函数只有一个参数，当参数为对象时，直接返回该对象；当参数不是对象时，会先将参数转为对象然后返回。

如果该参数不是对象，则会先转成对象，然后返回。由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。

• Object.assign()常见用途

（1）为对象添加属性

下面方法通过Object.assign方法，将x属性和y属性添加到Person 类的对象实例。

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

（2）为对象添加方法

Object.assign(Person.prototype, {
  method1(arg1, arg2) {
    ···
  },
  method2() {
    ···
  }
});
// 等同于下面的写法
Person.prototype.method1 = function (arg1, arg2) {
  ···
};
Person.prototype.method2 = function () {
  ···
};

（3）克隆对象

上面代码将原始对象拷贝到一个空对象，就得到了原始对象的克隆。此方法为浅拷贝，不能克隆它继承的值。

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

（4）合并多个对象

将多个对象合并到某个对象。

const merge =function(target, ...sources){
    Object.assign(target, ...sources);
 }

（5）为属性指定默认值

下面代码中，DEFAULTS对象是默认值，options对象是用户提供的参数。Object.assign方法将DEFAULTS和options合并成一个新对象，如果两者有同名属性，则option的属性值会覆盖DEFAULTS的属性值。

const DEFAULTS = {
  logLevel: 0,
  outputFormat: 'html'
};
function processContent(options) {
  options = Object.assign({}, DEFAULTS, options);
}

• Object.is()

ES5比较两个值是否相等，只有两个运算符：相等运算符（==）和严格相等运算符（===）。它们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。

JavaScript缺乏一种运算，在所有环境中，只要两个值是一样的，它们就应该相等。

ES6提出同值相等算法，用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。不同之处只有两个：一是+0不等于-0，二是NaN等于自身。

+0 === -0     //true
NaN === NaN     // false

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

 

• 对象的解构赋值

对象的解构赋值用于从一个对象取值，相当于将所有可遍历的、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。

var  { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }

上面代码中，变量z是解构赋值所在的对象(前面有三个点）。它获取等号右边的所有尚未读取的键（a和b），将它们连同值一起拷贝过来。

解构赋值必须是最后一个参数，否则会报错。

let { ...x, y, z } = obj; // 句法错误
let { x, ...y, ...z } = obj; // 句法错误

由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null，就会报错，因为它们无法转为对象。

 

注意，解构赋值的拷贝是浅拷贝，即如果一个键的值是复合类型的值（数组、对象、函数）、那么解构赋值拷贝的是这个值的引用，而不是这个值的副本。

let obj = { a: { b: 1 } };
let { ...x } = obj;    // 解构赋值
obj.a.b = 2;
x.a.b     // 2    

上面代码中，x是解构赋值所在的对象，拷贝了对象obj的a属性。a属性引用了一个对象，修改这个对象的值，会影响到解构赋值对它的引用。

• 扩展运算符

扩展运算符（ ... ）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中。

let z = { a: 3, b: 4 };
let n = { ...z };        // n的值 { a: 3, b: 4 }

// 相当于Object.assign方法
let m = Object.assign( {}, z );        // m的值 { a: 3, b: 4 }

扩展运算符可以用于合并两个对象。

let a = {a:"1"};
let b = {b:"2"};
let ab = { ...a, ...b };
console.log(ab);
Object { a: "1", b: "2" }

let ab = { ...a, ...b };
// 等同于
let ab = Object.assign({}, a, b);

如果用户自定义的属性，放在扩展运算符后面，则扩展运算符内部的同名属性会被覆盖掉。

let newobj= { ...obj, x: 1, y: 2 };    
// 等同于
let newobj= Object.assign({}, obj, { x: 1, y: 2 });

上面代码中，如果obj对象有x属性和y属性，拷贝到新对象后会被覆盖掉。

 

• 属性的可枚举性

对象的每个属性都有一个描述对象，用来控制该属性的行为。

Object.getOwnPropertyDescriptor方法可以获取该属性的描述对象。

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

ES5有三个操作会忽略enumerable为false的属性。

• for...in循环：只遍历对象自身的和继承的可枚举的属性。
• Object.keys()：返回对象自身的所有可枚举的属性的键名。
• JSON.stringify()：只串行化对象自身的可枚举的属性。

 

ES6新增了一个操作Object.assign()，会忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性。

 

第十章：ES6看完必会第十章------ Class 类 （可私信解惑，不会来捶我）