为何 JS 中的对象字面量很酷

做者：Dmitri Pavlutin
译者：前端小智
来源：dmitripavlutin

点赞再看，养成习惯

本文 GitHub https://github.com/qq44924588... 上已经收录，更多往期高赞文章的分类，也整理了不少个人文档，和教程资料。欢迎Star和完善，你们面试能够参照考点复习，但愿咱们一块儿有点东西。

在 ES6 以前，JS 中的对象字面量(也称为对象初始化器)是很是基础的。能够定义两种类型的属性：

• 键值对 {name1: value1}
• 获取器 { get name(){..} } 和 设置器 { set name(val){..}} 的计算属性值

var myObject = {
  myString: 'value 1',
  get myNumber() {
    return this._myNumber;
  },
  set myNumber(value) {
    this._myNumber = Number(value);
  },
};
myObject.myString; // => 'value 1'
myObject.myNumber = '15';
myObject.myNumber; // => 15

JS 是一种基于原型的语言，所以一切都是对象。 在对象建立，配置和访问原型时，必须提供一种易于构造的语言。

定义一个对象并设置它的原型是一个常见的任务。最好的方式是直接在对象字面量使用一条语句来设置原型。

不幸的是，字面量的局限性不容许用一个简单的解决方案来实现这一点。必须结合使用object.create() 和对象字面量来设置原型。

var myProto = {
  propertyExists: function(name) {
    return name in this;
  }
};

var myNumbers = Object.create(myProto);
myNumbers['arrat'] = [1, 6, 7];
myNumbers.propertyExists('array'); // => true
myNumbers.propertyExists('collection'); // => false

我认为这种解决方案不够灵活。JS 是基于原型的，为何要用原型建立对象那么麻烦？

幸运的是，JS 也在慢慢完善。JS 中不少使人沮丧的问题都是逐步解决的。

本文演示了 ES 6 如何解决上述问题，并使用额外的功能改进对象字面量。

• 在对象构造上设置原型
• 方法的声明
• super 调用
• 计算属性名

1. 在对象构造上设置原型

如你所知，访问现有对象原型的一种方法是使用 getter 属性 __proto__：

var myObject = {
  name: 'Hello World!',
};
myObject.__proto__; // => {}
myObject.__proto__.isPrototypeOf(myObject); // => true

myObject.__ proto__ 返回 myObject 的原型对象。

请注意，不建议将 object.__ proto__ 用做 getter/setter。替代方法应考虑使用Object.getPrototypeOf() 和 Object.setPrototypeOf()。

ES6容许使用__proto__做为属性名，并在 {__proto__：protoObject}中设置原型。

接着，我们使用 __proto__ 属性进行对象初始化，并优化上面的代码：

var myProto = {
  propertyExists: function(name) {
    return name in this;
  },
};
var myNumbers = {
  __proto__: myProto,
  array: [1, 6, 7],
};
myNumbers.propertyExists('array'); // => true
myNumbers.propertyExists('collection'); // => false

myNumbers 对象是使用特殊属性名 proto 与建立原型 myProto，此次我们使用一条语句就建立，没有像上面还须要 object.create() 这样的附加函数。

如你所看，使用 __proto__ 进行编码很简单，我一直喜欢简单明了的解决方案。

说点脱离主题。 我以为奇怪的是，简单灵活的解决方案须要大量的工做和设计。若是解决方案很简单，你可能会认为设计起来很容易。可是反之亦然：

• 要使它简单明了是很复杂的
• 把它变得复杂和难以理解是很容易的

若是某些东西看起来太复杂或难以使用，则可能还须要进一步的完善。

你对简单性有何见解？ （请在下面随意写评论）

2.1 __proto__用法的特殊状况

即便__proto__看起来很简单，您也应该注意一些特殊状况。

在对象字面量中只能使用__proto__一次，不然 JS 会报错：

var object = {
  __proto__: {
    toString: function() {
      return '[object Numbers]'
    }
  },
  numbers: [1, 5, 89],
  __proto__: {
    toString: function() {
      return '[object ArrayOfNumbers]'
    }
  }
};

上面示例中的对象字面量中使用两次__proto__属性，这是不容许的。在这种状况下，将在会抛出错误： SyntaxError: Duplicate __proto__ fields are not allowed in object literals 。

JS 约束只能用一个对象或 null 做为 __proto__ 属性的值。 任何使用原始类型（字符串，数字，布尔值）或 undefined 类型都将被忽略，而且不会更改对象的原型。

var objUndefined = {
  __proto__: undefined,
};
Object.getPrototypeOf(objUndefined); // => {}
var objNumber = {
  __proto__: 15,
};
Object.getPrototypeOf(objNumber); // => {}

对象字面量使用 undefined 和 数字 15 来设置 __proto__ 值。 由于仅容许将对象或 null 用做原型，因此__proto__值将被忽略，但 objUndefined 和 objNumber 仍具备其默认原型：纯 JS 对象 {}, 。

固然，尝试使用基本类型来设置对象的原型也会很奇怪。

当对象字面具备计算结果为'__proto__'的字符串时 {['__proto__']：protoObj }，也要当心。 以这种方式建立的属性不会更改对象的原型，而只是使用键 '__proto__' 建立一个拥有的属性

简写方法定义

可使用较短的语法在对象常量中声明方法，以省略 function 关键字和 ： 冒号的方式。 这被称为简写方法定义。

接着，我们使用简写的方法来定义一些方法：

var collection = {
  items: [],
  add(item) {
    this.items.push(item);
  },
  get(index) {
    return this.items[index];
  },
};
collection.add(15);
collection.add(3);
collection.get(0); // => 15

一个很好的好处是，以这种方式声明的方法被命名为函数，这对于调试目的颇有用。 从上面示例中执行 collection.add.name 会返回函数名称 “add”。

3. super 的使用

JS 一个有趣的改进是使用 super 关键字做为从原型链访问继承的属性的能力。 看下面的例子：

var calc = {
  numbers: null,
  sumElements() {
    return this.numbers.reduce(function(a, b) {
      return a + b;
    });
  },
};
var numbers = {
  __proto__: calc,
  numbers: [4, 6, 7],
  sumElements() {
    if (this.numbers == null || this.numbers.length === 0) {
      return 0;
    }
    return super.sumElements();
  },
};
numbers.sumElements(); // => 17

calc 是 numbers 对象的原型。 在 numbers 的 sumElements方法中，可使用 super关键字从原型访问方法：super.sumElements()

最终，super 是从对象原型链访问继承的属性的快捷方式。

在前面的示例中，能够尝试直接执行 calc.sumElements() 来调用原型，会报错。 然而，super.sumElements() 能够正确调用，由于它访问对象的原型链。并确保原型中的 sumElements() 方法使用 this.numbers 正确访问数组。

super 存在清楚地代表继承的属性将被使用。

你们都说简历没项目写，我就帮你们找了一个项目，还附赠【搭建教程】。

我和阿里云合做服务器，折扣价比较便宜：89/年，223/3年，比学生9.9每个月还便宜，买了搭建个项目，熟悉技术栈比较香（老用户用家人帐号买就行了，我用我妈的)推荐买三年的划算点，点击本条就能够查看。

3.1 super 使用限制

super 只能在对象字面量的简写方法定义内使用。

若是试图从普通方法声明{ name: function(){} } 访问它，JS 将抛出一个错误:

var calc = {
  numbers: null,
  sumElements() {
    return this.numbers.reduce(function(a, b) {
      return a + b;
    });
  },
};
var numbers = {
  __proto__: calc,
  numbers: [4, 6, 7],
  sumElements: function() {
    if (this.numbers == null || this.numbers.length === 0) {
      return 0;
    }
    return super.sumElements();
  },
};
// Throws SyntaxError: 'super' keyword unexpected here
numbers.sumElements();

方法 sumElements 被定义为一个属性: sumElements: function(){…}。由于super 只能在简写方法中使用，因此在这种状况下调用它会抛出 SyntaxError: 'super' keyword unexpected here。

此限制在很大程度上不影响对象字面量的声明方式。 因为语法较短，所以一般最好使用简写方法定义。

4.计算属性名

在 ES6 以前，对象初始化使用的是字面量的形式，一般是静态字符串。 要建立具备计算名称的属性，就必须使用属性访问器。

function prefix(prefStr, name) {
  return prefStr + '_' + name;
}
var object = {};
object[prefix('number', 'pi')] = 3.14;
object[prefix('bool', 'false')] = false;
object; // => { number_pi: 3.14, bool_false: false }

固然，这种定义属性的方式是使人愉快的。

接着使用简写方式来改完上面的例子：

function prefix(prefStr, name) {
  return prefStr + '_' + name;
}
var object = {
  [prefix('number', 'pi')]: 3.14,
  [prefix('bool', 'false')]: false,
};
object; // => { number_pi: 3.14, bool_false: false }

[prefix（'number'，'pi'）]经过计算 prefix('number', 'pi') 表达式（即'number_pi'）来设置属性名称。

相应地，[prefix('bool', 'false')] 将第二个属性名称设置为'bool_false'。

4.1 symbol 做为属性名称

symbol 也能够用做计算的属性名称。 只要确保将它们包括在方括号中便可：{[Symbol（'name'）]：'Prop value'}

例如，用特殊属性 Symbol.iterator 并迭代对象自身的属性名称。 以下示例所示：

var object = {
   number1: 14,
   number2: 15,
   string1: 'hello',
   string2: 'world',
   [Symbol.iterator]: function *() {
     var own = Object.getOwnPropertyNames(this),
       prop;
     while(prop = own.pop()) {
       yield prop;
     }
   }
}
[...object]; // => ['number1', 'number2', 'string1', 'string2']

[Symbol.iterator]: function *() { } 定义一个属性，该属性用于迭代对象的自有属性。 展开运算符 [... object] 使用迭代器并返回自有的属性的列表

剩余和展开属性

剩余属性容许从对象中收集在分配销毁后剩下的属性。

下面的示例在解构对象以后收集剩余的属性：

var object = {
  propA: 1,
  propB: 2,
  propC: 3,
};
let { propA, ...restObject } = object;
propA; // => 1
restObject; // => { propB: 2, propC: 3 }

展开属性容许将源对象的自有属性复制到对象文字面量中。 在此示例中，对象字面量从源对象收集到对象的其余属性：

var source = {
  propB: 2,
  propC: 3,
};
var object = {
  propA: 1,
  ...source,
};
object; // => { propA: 1, propB: 2, propC: 3 }

6.总结

在 ES6 中，即便是做为对象字面量的相对较小的结构也获得了至关大的改进。

可使用__proto__ 属性名称直接从初始化器设置对象的原型。 这比使用 Object.create() 更容易。

请注意，__proto__ 是 ES6 标准附件B的一部分，不鼓励使用。 该附件实现对于浏览器是必需的，但对于其余环境是可选的。NodeJS 四、5和6支持此功能。

如今方法声明的形式更短，所以没必要输入 function 关键字。 在简化方法中，可使用 super关 键字，该关键字能够轻松访问对象原型链中的继承属性。

若是属性名称是在运行时计算的，那么如今您可使用计算的属性名称[expression]来初始化对象。

---

代码部署后可能存在的BUG无法实时知道，过后为了解决这些BUG，花了大量的时间进行log 调试，这边顺便给你们推荐一个好用的BUG监控工具 Fundebug。

原文：https://dmitripavlutin.com/wh...

---

交流

文章每周持续更新，能够微信搜索「 大迁世界 」第一时间阅读和催更（比博客早一到两篇哟），本文 GitHub https://github.com/qq449245884/xiaozhi 已经收录，整理了不少个人文档，欢迎Star和完善，你们面试能够参照考点复习，另外关注公众号，后台回复福利，便可看到福利，你懂的。

·