首页
Javascript
Html
Css
Node.js
Electron
移动开发
工具类
服务端
浏览器相关
前端收藏
其他
关于

ECMA-262-5详述 第一章. 属性和属性描述符

2018年10月26日 发布 阅读(314) 作者:懒炖

英文原文: http://dmitrysoshnikov.com/ecmascript/es5-chapter-1-properties-and-property-descriptors/

简介

这一章专门讨论了ECMA-262-5 规范的新概念之一 — 属性特性及其处理机制 — 属性描述符

当我们说“一个对象有一些属性”的时候,通常指的是属性名属性值之间的关联关系。但是,正如在ES3系列文章中分析的那样,一个属性不仅仅是一个字符串名,它还包括一系列特性—比如我们在ES3系列文章中已经讨论过的{ReadOnly}{DontEnum}等。因此从这个观点来看,一个属性本身就是一个对象。

为了更充分地理解本章节的内容,我建议阅读ECMA-262-3系列文章中的 Chaper 7.2. OOP: ECMAScript implementation

新的API方法

为了处理属性及其特性,ES5标准化了一些新的API方法。稍后我们会详细讨论这些方法:

  1. // better prototypal inheritance
  2. Object.create(parentProto, properties);
  3. // getting the prototype
  4. Object.getPrototypeOf(o);
  5. // define properties with specific attributes
  6. Object.defineProperty(o, propertyName, descriptor);
  7. Object.defineProperties(o, properties);
  8. // analyze properties
  9. Object.getOwnPropertyDescriptor(o, propertyName);
  10. // static (or "frozen") objects
  11. Object.freeze(o);
  12. Object.isFrozen(o);
  13. // non-extensible objects
  14. Object.preventExtensions(o);
  15. Object.isExtensible(o);
  16. // "sealed": non-extensible
  17. // and non-configurable objects
  18. Object.seal(o);
  19. Object.isSealed(o);
  20. // lists of properties
  21. Object.keys(o);
  22. Object.getOwnPropertyNames(o);

我们一个一个地讲。

属性类型

在ES3中,属性名和属性值是直接相关联的。虽然在一些ES3的实现版本中提供了扩展概念:getters(访问器函数)和setters(设置器函数),即与属性值间接相关的函数 。ECMA-262-5标准化了这个概念,现在总共有三种属性类型。

并且你应该知道,属性可以是自己的,即直接由对象包含,也可以是继承的,即由原型链中的一个对象包含。

属性包括命名属性和内部属性。命名属性是供ECMAScript代码使用的。内部属性则只能被实现层级的代码使用(虽然通过一些特殊的方法也能在ECMAScript代码中操作部分内部属性)。我们稍后会介绍。

属性特性

命名属性是通过一系列特性区分的。 在ES3系列文章中讨论 过的{ReadOnly}{DontEnum}等特性,在ES5中被重新命名了,表示ES3中相应特性的相反布尔状态。在ECMA-262-5中,数据属性和存取器属性有两个共同的特性:

  • [[Enumerable]]可枚举

特性(对应ES3中{DontEnum}特性的相反布尔状态)的值如果是true,则可以被for-in枚举。

  • [[Configurable]]可配置

特性(对应ES3中{DontDelete}特性的相反布尔状态)在false的状态下不允许删除属性,把属性设置成存取器属性或者改变[[Value]]以外的特性。

需要注意的是,一旦[[Configurable]]特性被设置成false,就不能重新被设置成true。正如我们刚才说的,在 [[Configurable]]特性为false的情况下,不能改变[[Value]]以外的特性,当然也包括这里的[[Configurable]]。虽然可以改变[[Writable]]的值,但是只能把它从true改为false,反过来不行。也就是说如果一个属性是不可配置的,那么[[Writable]]不能从false变为true

稍后我们会讨论具体命名属性类型的其它特性。我们先详细介绍属性类型。

命名数据属性

这些属性我们已经在ES3中使用过了。这类属性包含一个名字(通常是字符串类型)以及名字和值之间的直接关联关系。

比如:

  1. // define in the declarative form
  2. var foo = {
  3. bar: 10 // direct Number type value
  4. };
  5. // define in the imperative form,
  6. // also direct, but Function type value, a "method"
  7. foo.baz = function () {
  8. return this.bar;
  9. };

和ES3一样,如果一个属性的值是一个函数,那么这个属性叫做方法。但是,不要混淆直接的函数值和间接的特殊的存取器函数。存取器函数会在后面介绍。

除了命名属性的通用特性之外,数据属性还有下列特性:

  • [[Value]]

特性提供了一个值,这个值用于属性的读取操作。

  • [[Writable]]可写

特性(对应ES3中{ReadOnly}特性的反向布尔状态),如果是false,会阻止内部方法[[Put]]修改属性的[[Value]]特性。

带有默认值的命名数据属性的完整特性如下:

  1. var defaultDataPropertyAttributes = {
  2. [[Value]]: undefined,
  3. [[Writable]]: false,
  4. [[Enumerable]]: false,
  5. [[Configurable]]: false
  6. };

所以,在特性的默认状态下,属性是常量:

  1. // define a global constant
  2. Object.defineProperty(this, "MAX_SIZE", {
  3. value: 100
  4. });
  5. console.log(MAX_SIZE);
  6. // 100
  7. MAX_SIZE = 200;
  8. // error in strict mode, [[Writable]] = false,
  9. delete MAX_SIZE;
  10. // error in strict mode, [[Configurable]] = false
  11. console.log(MAX_SIZE);
  12. // still 100

不幸的是,在ES3中我们无法控制属性特性,这也导致了著名的内置原型扩大问题。由于ECMAScript对象可以动态修改的本质,所以可以非常方便地在原型上添加新的功能,然后使用它,就像对象本身就有这个功能一样。但是,因为无法控制ES3中的属性特性,比如{DontEnum},在使用for-in的时候就会出现问题。

  1. // ES3
  2. Array.prototype.sum = function () {
  3. // sum implementation
  4. };
  5. var a = [10, 20, 30];
  6. // works fine
  7. console.log(a.sum());
  8. // 60
  9. // but because of for-in examines the
  10. // prototype chain as well, the new "sum"
  11. // property is also enumerated, because has
  12. // {DontEnum} == false
  13. // iterate over properties
  14. for (var k in a) {
  15. console.log(k);
  16. // 0, 1, 2, sum
  17. }

ES5提供了特殊的元方法来操作属性特性:

  1. Object.defineProperty(Array.prototype, "sum", {
  2. value: function arraySum() {
  3. // sum implementation
  4. },
  5. enumerable: false
  6. });
  7. // now with using the same example this "sum"
  8. // is no longer enumerable
  9. for (var k in a) {
  10. console.log(k);
  11. // 0, 1, 2
  12. }

在上面的例子中,我们人为明确地设置了enumerable特性。然而,正如我们上面说过的,所有特性的默认状态是false,所以我们可以省略明确的false设置:

并且一个简单的赋值操作对应所有特性的相反默认状态(正如在ES3中的一样):

  1. // simple assignment (if we create a new property)
  2. foo.bar = 10;
  3. // the same as
  4. Object.defineProperty(foo, "bar", {
  5. value: 10,
  6. writable: true,
  7. enumerable: true,
  8. configurable: true
  9. });

可以发现,元方法Object.defineProperty不仅可以用来新建对象属性,还可以用来修改对象属性。另外,这个方法返回更新后的对象,所以我们可以使用这个方法同时把新创建的对象绑定到想要的变量名上。

  1. // create "foo"
  2. object and define "bar"
  3. property
  4. var foo = Object.defineProperty({}, "bar", {
  5. value: 10,
  6. enumerable: true
  7. });
  8. // alter value and enumerable attribute
  9. Object.defineProperty(foo, "bar", {
  10. value: 20,
  11. enumerable: false
  12. });
  13. console.log(foo.bar);
  14. // 20

有两个获取对象自身属性数组的元方法: Object.keys,只返回可枚举属性,和Object.getOwnPropertyNames,可枚举和不可枚举属性都返回:

  1. var foo = {bar: 10, baz: 20};
  2. Object.defineProperty(foo, "x", {
  3. value: 30,
  4. enumerable: false
  5. });
  6. console.log(Object.keys(foo));
  7. // ["bar", "baz"]
  8. console.log(Object.getOwnPropertyNames(foo));
  9. // ["bar", "baz", "x"]

命名存取器属性

命名存取器属性包括一个名字(同样只是一个字符串)和一到两个存取器函数:getter(访问器函数)和setter(设置器函数)。

存取器函数用于间接地设置或访问与属性名相关的值。

正如上面提到的,ES3的一些实现版本已经有了这个概念。但是ES5把这种属性类型的定义官方的具体化了并且提供了稍微不同的语法,比如和SpiderMonkey的相应扩展相比。

除了通用特性,存取器属性还有下面和访问器函数以及设置器函数相关的特性:

  • [[Get]]访问器

特性是一个函数对象,当每次间接获取属性名对应的值的时候会被调用。不要把属性特性和对象的同名内部方法—通用获取属性值的方法—混淆。对于存取器属性来说,对象内部的[[Get]]方法会调用对象属性的[[Get]]特性。

  • [[Set]]设置器

特性也是一个函数,它被用来给一个属性名对应的属性设置一个新值。这个特性会被对象的内部方法[[Put]]调用。

需要注意的是,[[Set]]可以,但不是必须的,影响后续属性[[Get]]特性的返回值。换句话说,如果我们通过设置器函数把属性值设置为10,访问器函数完全可以返回不同的值,比如20,因为这种关联是间接的。

带有默认值的命名存取器属性的完整特性如下:

  1. var defaultAccessorPropertyAttributes = {
  2. [[Get]]: undefined,
  3. [[Set]]: undefined,
  4. [[Enumerable]]: false,
  5. [[Configurable]]: false
  6. };

如果 [[Set]]特性缺省,那么这个存取器属性是只读的,和数据属性中[[Writable]]特性的状态为false一样。

存取器属性既可以通过上面已经提到的元方法Object.defineProperty定义:

  1. var foo = {};
  2. Object.defineProperty(foo, "bar", {
  3. get: function getBar() {
  4. return 20;
  5. },
  6. set: function setBar(value) {
  7. // setting implementation
  8. }
  9. });
  10. foo.bar = 10;
  11. // calls foo.bar.[[Set]](10)
  12. // independently always 20
  13. console.log(foo.bar);
  14. // calls foo.bar.[[Get]]()

也可以在对象初始化时使用声明式的形式定义:

  1. var foo = {
  2. get bar () {
  3. return 20;
  4. },
  5. set bar (value) {
  6. console.log(value);
  7. }
  8. };
  9. foo.bar = 100;
  10. console.log(foo.bar);
  11. // 20

同样需要注意和存取器属性的可配置特性相关的一个重要特点。正如在上面[[Configurable]]特性部分描述的那样,一旦[[Configurable]]被设置成false,那么这个属性的特性就不能再修改了(除了数据属性的[[Value]]特性)。下面的例子可能会让你很疑惑:

  1. // configurable false by default
  2. var foo = Object.defineProperty({}, "bar", {
  3. get: function () {
  4. return "bar";
  5. }
  6. });
  7. // trying to reconfigure the "bar"
  8. // property =>
  9. exception is thrown
  10. try {
  11. Object.defineProperty(foo, "bar", {
  12. get: function () {
  13. return "baz"
  14. }
  15. });
  16. } catch (e) {
  17. if (e instanceof TypeError) {
  18. console.log(foo.bar);
  19. // still "bar"
  20. }
  21. }

当设置属性特性的值和原先一样时,不会产生异常。虽然,这个知识点在实际中并不重要,甚至可以说毫无用处,因为我们不会给特性设置同样的值:

  1. function getBar() {
  2. return "bar";
  3. }
  4. var foo = Object.defineProperty({}, "bar", {
  5. get: getBar
  6. });
  7. // no exception even if configurable is false,
  8. // but practically such "re"-configuration is useless
  9. Object.defineProperty(foo, "bar", {
  10. get: getBar
  11. });

正如我们上面提到的,即使[[Configurable]]特性是false的状态,数据属性的[[Value]]特性也可以被修改,当然前提是[[Writable]]特性是在为true的情况下。同样,对于不可配置属性来说,[[Writable]]可以由true变为false,但是不能由false变为true

  1. var foo = Object.defineProperty({}, "bar", {
  2. value: "bar",
  3. writable: true,
  4. configurable: false
  5. });
  6. Object.defineProperty(foo, "bar", {
  7. value: "baz"
  8. });
  9. console.log(foo.bar);
  10. // "baz"
  11. // change writable
  12. Object.defineProperty(foo, "bar", {
  13. value: "qux",
  14. writable: false // changed from true to false, OK
  15. });
  16. console.log(foo.bar);
  17. // "qux"
  18. // try to change writable again - back to true
  19. Object.defineProperty(foo, "bar", {
  20. value: "qux",
  21. writable: true // ERROR
  22. });

[[Configuragle]]特性是false的时候,属性类型不能在数据属性和存取器属性间转换。当[[Configuragle]]特性是true的时候,属性类型之间是可以相互转换的。因此,[[Writable]]特性的状态并不是很重要并且可以是false

  1. // writable false by default
  2. var foo = Object.defineProperty({}, "bar", {
  3. value: "bar",
  4. configurable: true
  5. });
  6. Object.defineProperty(foo, "bar", {
  7. get: function () {
  8. return "baz";
  9. }
  10. });
  11. console.log(foo.bar);
  12. // OK, "baz"

很明显,一个属性不能同时既是数据类型又是存取器类型。这也就意味着一个属性如果同时具有互斥的特性,那么就会抛出异常:

  1. // error, "get"
  2. and "writable"
  3. at the same time
  4. var foo = Object.defineProperty({}, "bar", {
  5. get: function () {
  6. return "baz";
  7. },
  8. writable: true
  9. });
  10. // also error: mutually exclusive "value"
  11. and "set"
  12. attributes
  13. var baz = Object.defineProperty({}, "bar", {
  14. value: "baz",
  15. set: function (v) {}
  16. })

让我们回忆一下,只有当我们需要封装使用了辅助数据的复杂计算时,为了简化属性的访问方式—就像一个简单的数据属性一样,使用访问器和设置器函数才更有意义。我们已经在专门的封装部分以属性element.innerHTML为例提到过:我们可以概括的说“现在html元素的内容如下”,但是在innerHTML属性的设置器函数里面会进行大量的计算和校验,然后引起DOM树的重建和用户界面的更新。

对于不抽象的,使用存取器特性就没有必要了。比如:

  1. var foo = {};
  2. Object.defineProperty(foo, "bar", {
  3. get: function getBar() {
  4. return this.baz;
  5. },
  6. set: function setBar(value) {
  7. this.baz = value;
  8. }
  9. });
  10. foo.bar = 10;
  11. console.log(foo.bar);
  12. // 10
  13. console.log(foo.baz);
  14. // 10

在上面的例子中,我们不仅给不抽象的属性定义了存取器函数,还在对象自身上创建了一个“baz”属性。在这个例子中一个简单的数据属性就足够了,同时也能提高性能。

真正值得使用访问器函数的情况通常和用于封装辅助数据的抽象程度的增加有关。最简单的例子如下:

  1. var foo = {};
  2. // encapsulated context
  3. (function () {
  4. // some internal state
  5. var data = [];
  6. Object.defineProperty(foo, "bar", {
  7. get: function getBar() {
  8. return "We have "
  9. + data.length + "
  10. bars: "
  11. + data;
  12. },
  13. set: function setBar(value) {
  14. // call getter first
  15. console.log('Alert from "bar"
  16. setter: '
  17. + this.bar);
  18. data = Array(value).join("bar-").concat("bar").split("-");
  19. // of course if needed we can update
  20. // also some public property
  21. this.baz = 'updated from "bar"
  22. setter: '
  23. + value;
  24. },
  25. configurable: true,
  26. enumerable: true
  27. });
  28. })();
  29. foo.baz = 100;
  30. console.log(foo.baz);
  31. // 100
  32. // first getter will be called inside the setter:
  33. // We have 0 bars:
  34. foo.bar = 3;
  35. // getting
  36. console.log(foo.bar);
  37. // We have 3 bars: bar, bar, bar
  38. console.log(foo.baz);
  39. // updated from "bar"
  40. setter: 3

当然上面的例子并没有实际意义,但是它说明了存取器函数的主要目的—把内部辅助数据封装起来。

和存取器属性相关的另一个特点是给继承的存取器属性赋值。正如从ES3系列文章中了解的那样,继承数据属性只可用于读取操作,给一个数据属性赋值总是会在对象自身上新建一个属性:

  1. Object.prototype.x = 10;
  2. var foo = {};
  3. // read inherited property
  4. console.log(foo.x);
  5. // 10
  6. // but with assignment
  7. // create always own property
  8. foo.x = 20;
  9. // read own property
  10. console.log(foo.x);
  11. // 20
  12. console.log(foo.hasOwnProperty("x"));
  13. // true

和数据属性不同的是,继承的存取器属性也可用于对象属性的修改:

  1. var _x = 10;
  2. var proto = {
  3. get x() {
  4. return _x;
  5. },
  6. set x(x) {
  7. _x = x;
  8. }
  9. };
  10. console.log(proto.hasOwnProperty("x"));
  11. // true
  12. console.log(proto.x);
  13. // 10
  14. proto.x = 20;
  15. // set own property
  16. console.log(proto.x);
  17. // 20
  18. var a = Object.create(proto);
  19. // "a"
  20. inherits from "proto"
  21. console.log(a.x);
  22. // 20, read inherited
  23. a.x = 30;
  24. // set *inherited*, but not own
  25. console.log(a.x);
  26. // 30
  27. console.log(proto.x);
  28. // 30
  29. console.log(a.hasOwnProperty("x"));
  30. //false

然而,如果我们在创建以proto为原型的对象a的时候,把x 设置成了a本身的属性,那么赋值当然也是设置的a本身的属性:

  1. var a = Object.create(proto, {
  2. x: {
  3. value: 100,
  4. writable: true
  5. }
  6. });
  7. console.log(a.x);
  8. // 100, read own
  9. a.x = 30;
  10. // set also own
  11. console.log(a.x);
  12. // 30
  13. console.log(proto.x);
  14. // 20
  15. console.log(a.hasOwnProperty("x"));
  16. // true

通过元方法而不是赋值操作设置自身属性同样也能得到和上面相同的结果:

  1. var a = Object.create(proto);
  2. a.x = 30;
  3. // set inherited
  4. Object.defineProperty(a, "x", {
  5. value: 100,
  6. writable: true
  7. });
  8. a.x = 30;
  9. // set own

值得一提的是,当我们试图通过赋值操作覆盖不可写的继承属性时,无论数据属性还是存取器属性,严格模式下都会报错。然而,如果不是通过赋值操作,而是通过Object.defineProperty方法,就不会报错:

  1. "use strict";
  2. var foo = Object.defineProperty({}, "x", {
  3. value: 10,
  4. writable: false
  5. });
  6. // "bar"
  7. inherits from "foo"
  8. var bar = Object.create(foo);
  9. console.log(bar.x);
  10. // 10, inherited
  11. // try to shadow "x"
  12. property
  13. // and get an error in strict
  14. // mode, or just silent failure
  15. // in non-strict ES5 or ES3
  16. bar.x = 20;
  17. // TypeError
  18. console.log(bar.x);
  19. // still 10, if non-strict mode
  20. // however shadowing works
  21. // if we use "Object.defineProperty"
  22. Object.defineProperty(bar, "x", { // OK
  23. value: 20
  24. });
  25. console.log(bar.x);
  26. // and now 20

想了解严格模式可以查看ES5系列文章的Chapter 2. Strict Mode

内部属性

内部属性并不是ECMAScript语言的一部分。定义它们纯粹出于说明的目的。ES3系列文章中已经讨论过了。

ES5新增了一些新的内部属性。你可以在ECMA-262-5规范的8.6.2. 章节看到这些内部属性的详细定义。因为在ES3系列文章中已经讨论过一些内部属性了,所以在这里只讨论一些新增的内部属性。

比如,ES5中的对象可以被设置成密封的,冻结的或者不可扩展的,也就是静态的。这三种状态都和对象内部的[[Extensible]]属性相关。可以通过元方法进行操作:

  1. var foo = {bar: 10};
  2. console.log(Object.isExtensible(foo));
  3. // true
  4. Object.preventExtensions(foo);
  5. console.log(Object.isExtensible(foo));
  6. // false
  7. foo.baz = 20;
  8. // error in "strict"
  9. mode
  10. console.log(foo.baz);
  11. // undefined

注意,一旦对象的内部属性[[Extensible]]被设置成false,就不能重新变为true了。

但是不可扩展对象的一些属性仍然可以被移除。为了防止这种情况的发生,可以使用元方法Object.seal,该方法除了把[[Extensible]]设置成false之外,还会把对象的所有属性的[[Configurable]]特性设置成false

  1. var foo = {bar: 10};
  2. console.log(Object.isSealed(foo));
  3. // false
  4. Object.seal(foo);
  5. console.log(Object.isSealed(foo));
  6. // true
  7. delete foo.bar;
  8. // error in strict mode
  9. console.log(foo.bar);
  10. // 10

如果想要把对象完全变成静态的,也就是冻结对象,阻止已有属性的修改,可以使用相应的元方法Object.freeze。这个方法除了会修改上面提到的[[Configurable]]特性和内部属性[[Extensible]]之外,还会把数据属性的[[Writable]]特性改为false

  1. var foo = {bar: 10};
  2. print(Object.isFrozen(foo));
  3. // false
  4. Object.freeze(foo);
  5. print(Object.isFrozen(foo));
  6. // true
  7. delete foo.bar;
  8. // error in strict mode
  9. foo.bar = 20;
  10. // error in strict
  11. print(foo.bar);
  12. // 10

对象一旦被设置成密封或者冻结状态,就不能回到原先的状态了。

和在ES3中一样,我们仍然可以使用Object.prototype.toString方法的默认返回值获取内部属性[[Class]]的值:

  1. var getClass = Object.prototype.toString;
  2. console.log(
  3. getClass.call(1), // [object Number]
  4. getClass.call({}), // [object Object]
  5. getClass.call([]), // [object Array]
  6. getClass.call(function () {}) // [object Function]
  7. // etc.
  8. );

和ES3不同的是,ES5提供了获取内部属性[[Prototype]]的元方法Object.getPrototypeOf。在现行的规范版本中可以使用元方法Object.create创建一个以指定对象为原型的对象:

  1. // create "foo"
  2. object with two own
  3. // properties "sum"
  4. and "length"
  5. and which has
  6. // Array.prototype as its [[Prototype]] property
  7. var foo = Object.create(Array.prototype, {
  8. sum: {
  9. value: function arraySum() {
  10. // sum implementation
  11. }
  12. },
  13. // non-enumerable but writable!
  14. // else array methods won't work
  15. length: {
  16. value: 0,
  17. enumerable: false,
  18. writable: true
  19. }
  20. });
  21. foo.push(1, 2, 3);
  22. console.log(foo.length);
  23. // 3
  24. console.log(foo.join("-"));
  25. "1-2-3"
  26. // neither "sum", nor "length"
  27. // are enumerable
  28. for (var k in foo) {
  29. console.log(k);
  30. // 0, 1, 2
  31. }
  32. // getting prototype of "foo"
  33. var fooPrototype = Object.getPrototypeOf(foo);
  34. console.log(fooPrototype === Array.prototype);
  35. // true

不幸的是,使用这种方式并不能创建一个以Array.prototype为原型,具有所有普通数组功能的“类”,包括重载处理length属性的内部方法[[DefineOwnProperty]](参考15.4.5.1)。如上例子所述。

  1. foo[5] = 10;
  2. console.log(foo.length);
  3. // still 3

继承Array.prototype,同时具有所有相关重载内部方法的唯一方式仍然是使用普通数组(也就是内部属性[[Class]]"Array"的对象),然后使用不标准的__proto__属性。但是并不是所有的实现都提供了通过__proto__属性设置原型的功能:

  1. var foo = [];
  2. foo.__proto__= {bar: 10};
  3. foo.__proto__.__proto__= Array.prototype;
  4. console.log(foo instanceof Array);
  5. // true
  6. console.log(foo.bar);
  7. // 10
  8. console.log(foo.length);
  9. // 0
  10. foo.push(20);
  11. foo[3] = 30;
  12. console.log(foo.length);
  13. //4
  14. console.log(foo);
  15. // 20,,,30
  16. foo.length = 0;
  17. console.log(foo);
  18. // empty array

不幸的是,和一些ES3实现版本中的非标准__proto__扩展不同,ES5没有提供设置对象原型的方式。

属性描述符和属性标识符类型

正如上面描述的,ES5允许操作属性特性。属性特性以及它们的值在ES5中被叫做属性描述符。

和命名属性类型一样,描述符要么是数据描述符要么是存取器描述符。

规范也定义了一个通用属性描述符,这个描述符要么是数据描述符要么是存取器描述符。一个完全填充的属性描述符要么是属性描述符要么是数据描述符并且具有相应类型的所有特性。但是那主要和实现层级相关。

因为特性都有默认值,如果描述符是一个空对象,则会创建一个数据属性。显然,当描述符对象包含writable或者value属性的时候,会创建一个数据属性。当描述符对象有get或者set属性的时候,会创建一个存取器属性。可以使用元方法Object.getOwnPropertyDescriptor获取属性描述符:

  1. // define several properties at once
  2. Object.defineProperties(foo, {
  3. bar: {}, // "empty"
  4. descriptor,
  5. baz: {get: function () {}}
  6. });
  7. var barProperty = Object.getOwnPropertyDescriptor(foo, "bar");
  8. var hasOwn = Object.prototype.hasOwnProperty;
  9. console.log(
  10. barProperty.value, // undefined
  11. hasOwn.call(barProperty, "value"), // true
  12. barProperty.get, // undefined
  13. hasOwn.call(barProperty, "get"), // false
  14. barProperty.set, // undefined
  15. hasOwn.call(barProperty, "set"), // false
  16. );
  17. console.log(foo.bar);
  18. // undefined (correct), in Rhino 1.73 - null
  19. console.log(foo.nonExisting);
  20. // undefined and in Rhino too
  21. // in contrast "baz"
  22. property is an accessor property
  23. var bazProperty = Object.getOwnPropertyDescriptor(foo, "baz");
  24. console.log(
  25. bazProperty.value, // undefined
  26. hasOwn.call(bazProperty, "value"), // false
  27. bazProperty.get, // function
  28. hasOwn.call(bazProperty, "get"), // true
  29. bazProperty.set, // undefined
  30. hasOwn.call(bazProperty, "set"), // false
  31. );

属性标识符类型用来关联属性名和属性描述符。所以,属性,也就是属性标识符类型的值,可以用形式(name, descriptor)描述:

也就是:

  1. foo.bar = 10;
  2. // property is an object of
  3. // the Property Identifier type
  4. var barProperty = {
  5. name: "bar",
  6. descriptor: {
  7. value: 10,
  8. writable: true,
  9. enumerable: true,
  10. configurable: true
  11. }
  12. };

总结

在这一章中,我们深入了解了ECMA-262-5规范的一个新概念。接下来的章节会专门介绍执行上下文的新细节,比如词法环境、环境记录等。一如既往,如果你有问题或补充,我们可以在评论中讨论。

作者: Dmitry A. Soshnikov 发布日期: 2010-04-28


译文原文: https://www.zcfy.cc/article/ecma-262-5-in-detail-chapter-1-properties-and-property-descriptors

版权声明:本站文章除特别声明外,均采用署名-非商业性使用-禁止演绎 4.0 国际 许可协议,如需转载,请注明出处

评论

  •  
  • ECMA-262-5 详解 - 3.1 词法环境:通用理论 – ds.laboratory

    这一节,我们会讨论词法环境的细节,它是在一些编程语言中用于管理静态作用域的一种机制。为了确保能充分理解这一主题,我们会简要讨论下其对立面:动态作用域(并没有直接用于 ECMAScript)。我们会看到环境是如何管理代码中的词法嵌套结构,以及为闭包提供全面支持。

    发布:2018-11-03 阅读(367)

  • ECMA-262-5详述 第一章. 属性和属性描述符

    这一章专门讨论了ECMA-262-5 规范的新概念之一 — 属性特性及其处理机制 — 属性描述符。 当我们说“一个对象有一些属性”的时候,通常指的是属性名和属性值之间的关联关系。但是,正如在ES3系列文章中分析的那样,一个属性不仅仅是一个字符串名,它还包括一系列特性—比如我们在ES3系列文章中已经讨论过的{ReadOnly},{DontEnum}等。因此从这个观点来看,一个属性本身就是一个对象

    发布:2018-10-26 阅读(314)