对象新增了哪些扩展？ - 图1

一、属性的简写

ES6中，当对象键名与对应值名相等的时候，可以进行简写

  1. const baz = {foo:foo}
  3. // 等同于
  4. const baz = {foo}

方法也能够进行简写

  1. const o = {
  2.   method() {
  3.     return "Hello!";
  4.   }
  5. };
  7. // 等同于
  9. const o = {
  10.   method: function() {
  11.     return "Hello!";
  12.   }
  13. }

在函数内作为返回值，也会变得方便很多

  1. function getPoint() {
  2.   const x = 1;
  3.   const y = 10;
  4.   return {x, y};
  5. }
  7. getPoint()
  8. // {x:1, y:10}

注意：简写的对象方法不能用作构造函数，否则会报错

  1. const obj = {
  2.   f() {
  3.     this.foo = 'bar';
  4.   }
  5. };
  7. new obj.f() // 报错

二、属性名表达式

ES6 允许字面量定义对象时，将表达式放在括号内

  1. let lastWord = 'last word';
  3. const a = {
  4.   'first word': 'hello',
  5.   [lastWord]: 'world'
  6. };
  8. a['first word'] // "hello"
  9. a[lastWord] // "world"
  10. a['last word'] // "world"

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

  1. let obj = {
  2.   ['h' + 'ello']() {
  3.     return 'hi';
  4.   }
  5. };
  7. obj.hello() // hi

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

  1. // 报错
  2. const foo = 'bar';
  3. const bar = 'abc';
  4. const baz = { [foo] };
  6. // 正确
  7. const foo = 'bar';
  8. const baz = { [foo]: 'abc'};

注意，属性名表达式如果是一个对象，默认情况下会自动将对象转为字符串[object Object]

  1. const keyA = {a: 1};
  2. const keyB = {b: 2};
  4. const myObject = {
  5.   [keyA]: 'valueA',
  6.   [keyB]: 'valueB'
  7. };
  9. myObject // Object {[object Object]: "valueB"}

三、super关键字

this关键字总是指向函数所在的当前对象，ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象

  1. const proto = {
  2.   foo: 'hello'
  3. };
  5. const obj = {
  6.   foo: 'world',
  7.   find() {
  8.     return super.foo;
  9.   }
  10. };
  12. Object.setPrototypeOf(obj, proto); // 为obj设置原型对象
  13. obj.find() // "hello"

四、扩展运算符的应用

在解构赋值中，未被读取的可遍历的属性，分配到指定的对象上面

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

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

解构赋值是浅拷贝

  1. let obj = { a: { b: 1 } };
  2. let { ...x } = obj;
  3. obj.a.b = 2; // 修改obj里面a属性中键值
  4. x.a.b // 2，影响到了结构出来x的值

对象的扩展运算符等同于使用Object.assign()方法

五、属性的遍历

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

  • for…in：循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）
  • Object.keys(obj)：返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名
  • Object.getOwnPropertyNames(obj)：回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名
  • Object.getOwnPropertySymbols(obj)：返回一个数组，包含对象自身的所有 Symbol 属性的键名
  • Reflect.ownKeys(obj)：返回一个数组，包含对象自身的（不含继承的）所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举

上述遍历，都遵守同样的属性遍历的次序规则：

  • 首先遍历所有数值键，按照数值升序排列
  • 其次遍历所有字符串键，按照加入时间升序排列
  • 最后遍历所有 Symbol 键，按照加入时间升序排
  1. Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })
  2. // ['2', '10', 'b', 'a', Symbol()]

六、对象新增的方法

关于对象新增的方法，分别有以下：

  • Object.is()
  • Object.assign()
  • Object.getOwnPropertyDescriptors()
  • Object.setPrototypeOf()，Object.getPrototypeOf()
  • Object.keys()，Object.values()，Object.entries()
  • Object.fromEntries()

Object.is()

严格判断两个值是否相等，与严格比较运算符（===）的行为基本一致，不同之处只有两个：一是+0不等于-0，二是NaN等于自身

  1. +0 === -0 //true
  2. NaN === NaN // false
  4. Object.is(+0, -0) // false
  5. Object.is(NaN, NaN) // true

Object.assign()

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

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

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

注意：Object.assign()方法是浅拷贝，遇到同名属性会进行替换

Object.getOwnPropertyDescriptors()

返回指定对象所有自身属性（非继承属性）的描述对象

  1. const obj = {
  2.   foo: 123,
  3.   get bar() { return 'abc' }
  4. };
  6. Object.getOwnPropertyDescriptors(obj)
  7. // { foo:
  8. //    { value: 123,
  9. //      writable: true,
  10. //      enumerable: true,
  11. //      configurable: true },
  12. //   bar:
  13. //    { get: [Function: get bar],
  14. //      set: undefined,
  15. //      enumerable: true,
  16. //      configurable: true } }

Object.setPrototypeOf()

Object.setPrototypeOf方法用来设置一个对象的原型对象

  1. Object.setPrototypeOf(object, prototype)
  3. // 用法
  4. const o = Object.setPrototypeOf({}, null);

Object.getPrototypeOf()

用于读取一个对象的原型对象

  1. Object.getPrototypeOf(obj);

Object.keys()

返回自身的（不含继承的）所有可遍历（enumerable）属性的键名的数组

  1. var obj = { foo: 'bar', baz: 42 };
  2. Object.keys(obj)
  3. // ["foo", "baz"]

Object.values()

返回自身的（不含继承的）所有可遍历（enumerable）属性的键对应值的数组

  1. const obj = { foo: 'bar', baz: 42 };
  2. Object.values(obj)
  3. // ["bar", 42]

Object.entries()

返回一个对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对的数组

  1. const obj = { foo: 'bar', baz: 42 };
  2. Object.entries(obj)
  3. // [ ["foo", "bar"], ["baz", 42] ]

Object.fromEntries()

用于将一个键值对数组转为对象

  1. Object.fromEntries([
  2.   ['foo', 'bar'],
  3.   ['baz', 42]
  4. ])
  5. // { foo: "bar", baz: 42 }

参考文献