简述ES6对Object类型做的常用升级优化? ( 重要 )

参考回答

ES6 对 Object 类型做了多项优化和增强，新增了一些功能强大的特性，使得对象的操作更简洁和高效。以下是常用的升级和优化：

1. 对象字面量增强：
   • 简写属性（Shorthand Property Names）。
   • 简写方法（Shorthand Method Names）。
   • 计算属性名（Computed Property Names）。
2. Object.assign() 方法：
   • 用于浅拷贝对象或合并多个对象。
3. Object.is() 方法：
   • 精确比较两个值是否严格相等，类似于 ===，但修正了 NaN 和 -0/+0 的特殊情况。
4. 新增对象方法：
   • Object.keys()：获取对象的键名数组。
   • Object.values()：获取对象的值数组。
   • Object.entries()：获取键值对的数组。
5. Object.getOwnPropertyDescriptors()：
   • 返回对象的所有属性描述符，便于深拷贝或继承。
6. __proto__ 属性和 Object.setPrototypeOf() 方法：
   • 动态设置或获取对象的原型。

详细讲解与拓展

1. 对象字面量增强

• 简写属性：
  当属性名和变量名相同时，可以省略键和值的重复书写。

  const name = "Alice";
  const age = 25;
  
  // ES5
  const person = { name: name, age: age };
  
  // ES6
  const person = { name, age };
  console.log(person); // { name: "Alice", age: 25 }
  

• 简写方法：
  直接用简写方式定义对象的方法。

  const person = {
  greet() {
    console.log("Hello!");
  }
  };
  person.greet(); // 输出 "Hello!"
  

• 计算属性名：
  动态定义对象的属性名。

  const prop = "age";
  
  // ES5
  const obj = {};
  obj[prop] = 25;
  
  // ES6
  const obj = { [prop]: 25 };
  console.log(obj); // { age: 25 }
  

2. Object.assign()

Object.assign() 用于将一个或多个源对象的属性拷贝到目标对象，常用于浅拷贝或对象合并。

• 浅拷贝：

  const obj1 = { a: 1, b: 2 };
  const copy = Object.assign({}, obj1);
  console.log(copy); // { a: 1, b: 2 }
  

• 对象合并：

  const obj1 = { a: 1 };
  const obj2 = { b: 2 };
  const merged = Object.assign({}, obj1, obj2);
  console.log(merged); // { a: 1, b: 2 }
  

注意：Object.assign() 仅进行浅拷贝，深层次对象需要递归处理。

3. Object.is()

Object.is() 类似于 ===，但修复了以下特殊情况：
– NaN 被认为等于自身。
– +0 和 -0 被区分。

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

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

4. 新增的对象遍历方法

• Object.keys()：返回对象键名数组。

  const obj = { a: 1, b: 2 };
  console.log(Object.keys(obj)); // ["a", "b"]
  

• Object.values()：返回对象值数组。

  const obj = { a: 1, b: 2 };
  console.log(Object.values(obj)); // [1, 2]
  

• Object.entries()：返回键值对数组。

  const obj = { a: 1, b: 2 };
  console.log(Object.entries(obj)); // [["a", 1], ["b", 2]]
  

这些方法非常适合配合 for...of 遍历对象：

const obj = { a: 1, b: 2 };
for (const [key, value] of Object.entries(obj)) {
  console.log(key, value);
}
// 输出：
// a 1
// b 2

5. Object.getOwnPropertyDescriptors()

该方法返回对象所有属性的描述符，常用于实现深拷贝或继承。

• 示例：深拷贝

  const obj = { a: 1, get b() { return 2; } };
  const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj));
  console.log(copy); // { a: 1, b: [Getter] }
  

6. __proto__ 和 Object.setPrototypeOf()

• __proto__：直接访问或设置对象的原型。

  const obj = {};
  const proto = { greet() { console.log("Hello!"); } };
  obj.__proto__ = proto;
  obj.greet(); // 输出 "Hello!"
  

• Object.setPrototypeOf()：动态设置对象的原型。

  const obj = {};
  const proto = { greet() { console.log("Hi!"); } };
  Object.setPrototypeOf(obj, proto);
  obj.greet(); // 输出 "Hi!"
  

注意：频繁修改原型会影响性能，建议在对象创建时确定原型。

总结

ES6 对 Object 的优化和扩展极大地提高了对象操作的便利性和效率：
1. 字面量增强 简化了对象的定义方式；
2. Object.assign 提供了简单的浅拷贝和对象合并能力；
3. Object.is 提供了更精确的相等性判断；
4. 遍历方法（如 keys、values、entries）为对象的迭代提供了更多选择；
5. 属性描述符 和 动态原型设置 提供了更灵活的对象扩展方式。

这些特性让对象操作更加现代化和高效，是 ES6 中非常重要的升级内容，广泛应用于日常开发中。

帅地训练营会员

打赏 收藏 海报挣佣金 推广链接