Eine eingehende Analyse von Objektliteralen in JavaScript

In diesem Artikel lernen Sie Objektliterale in JavaScript kennen und analysieren, warum Objektliterale cool sind. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Vor ECMAScript 2015 waren Objektliterale (auch Objektinitialisierer genannt) in Javascript recht einfach. Es konnten zwei Arten von Eigenschaften definiert werden:

• Paare statischer Eigenschaftsnamen und -werte { name1 : value1
{ name1: value1 }
• 通过 getters { get name(){..} } 和 setters { 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 是基于原型的，为什么要用原型创建对象那么麻烦？

幸运的是，JavaScript 也在慢慢完善。JS 中许多相当令人不舒服的特性正在一步步的被解决。

这篇文章演示了 ES2015 是如何解决以上描述的难题，并增加了哪些特性来提升对象字面量的能力：

• 在对象构造函数中设置原型
• 速写式方法声明
• 进行 super 调用
• 可计算的属性名

另外，还有我们可以展望一下将来，看看 (草案2) 里的新提议： 可收集可展开的属性。

1. 在对象构造函数中设置原型

正如你已知的，访问已创建对象的原型有一种方式是引用 __proto__ 这个 getter 属性：

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

myObject.__proto__ 返回 myObject 的原型对象。

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

好消息是， ES2015 允许使用 __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__ 进行编码很简单。我通常推荐简洁直观的解决方案。

说点一些题外话，我认为有点奇怪的是，简单可扩展的解决方案依赖大量的设计和工作。如果一个方案很简洁，你也许认为它是容易设计的。然而事实完全相反:

• 让事情变得简单直接很复杂
• 让事情变得复杂难以理解很容易

如果一些事情看起来很复杂或者很难使用，可能它是没有被充分考虑过。关于返璞归真，你怎么看？（随意留言评论）

1.1 特殊的情况下 __proto__ 的使用手册

即使 __proto__via getters

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

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

Entwurf 2 Neuer Vorschlag in 🎜): Sammelbar und erweiterbar Eigenschaften. 🎜🎜🎜

1. Legen Sie den Prototyp im Objektkonstruktor fest

🎜Wie Sie wissen, besteht eine Möglichkeit, auf den Prototyp eines erstellten Objekts zuzugreifen, darin, darauf zu verweisen__proto__ Dieses Getter-Attribut: 🎜

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

Nach dem Login kopieren

Nach dem Login kopieren

🎜myObject.__proto__ Gibt das Prototypobjekt von myObject zurück.
🎜🎜Bitte beachten Sie, dass die Verwendung von object.__ proto__ als Getter/Setter nicht empfohlen wird. Alternativen sollten mit Object.getPrototypeOf() und Object.setPrototypeOf() in Betracht gezogen werden. 🎜🎜Die gute Nachricht ist:

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

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

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

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

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

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();

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 }

Symbols 也可以作为可计算的属性名。只要确保将它们包括在方括号中即可： { [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] 使用了迭代器来返回自有属性的数组。

5. 对未来的一个展望: 可收集可展开的属性

对象字面量的可收集可展开的属性 目前是草案第二阶段 (stage 2) 中的一个提议，它将被选入下一个 Javascript 版本。

它们等价于 ECMAScript 2015 中已可用于数组的 展开和收集操作符 。

可收集的属性 允许收集一个对象在解构赋值后剩下的属性们。

下面这个例子收集了 object 解构后留下的属性：

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

可展开的属性 允许从一个源对象拷贝它的自有属性到另一个对象字面量中。这个例子中对象字面量的其它属性合集是从 source 对象中展开的：

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

6. 总结

JavaScript 正在迈出重要的一步。

在ECMAScript 2015中，即使是作为对象字面量的相对较小的结构也得到了相当大的改进。提案草案中还包含了许多新功能。

你可以在对象初始化时直接通过 __proto__ 属性名设置其原型。比用 Object.create() 简单很多。

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

现在方法声明有个更简洁的模式，所以你不必输入 function 关键字。而且在速写式声明里，你可以使用 super 关键字，它允许你十分容易得通过对象的原型链访问父类属性。

如果属性名需要在运行时计算，现在你可以用可计算的属性名 [expression] 来初始化对象。

对象字面量现在确实很酷！

英文原文地址：https://dmitripavlutin.com/why-object-literals-in-javascript-are-cool/

作者：Dmitri Pavlutin

译文地址：https://segmentfault.com/a/1190000020669949

更多编程相关知识，请访问：编程视频！！

Das obige ist der detaillierte Inhalt vonEine eingehende Analyse von Objektliteralen in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!