为什么 ES6 Symbol 属性可以被 Object.defineProperty 枚举？

Question

在 ES6 中属性可以定义为符号属性：

var symbol = Symbol();
var object = {};
object[symbol] = 'value';

MDN 将可枚举属性定义为“可以通过 for..in 循环迭代的属性”(1)。符号属性永远不会被 for...in 循环迭代，因此它们可以被认为是不可枚举的 (2)。

那么，您可以这样做是否有意义：

Object.defineProperty(object, symbol, {
    value: 'value',
    enumerable: true
});

并且查询对象的描述符确实确认该属性是可枚举的：

Object.getOwnPropertyDescriptor(object, symbol)
// -> { enumerable: true }

为什么？这有什么用？

(1)https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties

(2) for...in 使用[[Enumerate]]，它只包含字符串键。既然我们有了符号属性，可能应该更改 MDN 上的定义。

Answer 1

是的，允许Symbol 属性可枚举是有原因的：Object.assign：

let s1 = Symbol();
let s2 = Symbol();
let s3 = Symbol();
let original = {};
original[s1] = "value1";                // Enumerable
Object.defineProperty(original, s2, {   // Enumerable
  enumerable: true,
  value: "value2"
});
Object.defineProperty(original, s3, {   // Non-enumerable
  value: "value3"
});
let copy = {};
Object.assign(copy, original);
console.log("copy[s1] is " + copy[s1]); // value1, because it was enumerable
console.log("copy[s2] is " + copy[s2]); // value2, because it was enumerable
console.log("copy[s3] is " + copy[s3]); // undefined, because it wasn't enumerable

Live Copy 在 Babel 的 REPL 上。

为了清楚起见：

MDN 将可枚举属性定义为“可以通过 for..in 循环迭代的属性”(1)。

这对于 ES6 (ES2015) 来说是完全错误的。这是 ES5 和更早版本中的一个合理的定义，如果简单的话，不，因为Symbols，它甚至不再简单正确。我已经修复了这篇文章。

---

这是一个 CW，因为它是问题上的 cmets 的产物。

Answer 2

这是因为枚举规则包含一个需要字符串键的子句。请记住，枚举和请求键是具有完全不同规则的不同操作。

查看the section for for ... in/for ... of head evaluation (13.7.5.12)，它声明迭代已使用：

1. 如果iterationKind是枚举的，那么

   c。返回obj.[[Enumerate]]()。

The description of [[Enumerate]] (9.1.11) 非常清楚地表明它：

返回一个 Iterator 对象 (25.1.1.2)，其 next 方法迭代 O 的可枚举属性的所有字符串值键。

可枚举属性的检查出现在正文的后面，伪代码示例使这一点更加清晰：

function* enumerate(obj) {
  let visited=new Set;
  for (let key of Reflect.ownKeys(obj)) {
      if (typeof key === "string") { // type check happens first
          let desc = Reflect.getOwnPropertyDescriptor(obj,key);
          if (desc) {
              visited.add(key);
              if (desc.enumerable) yield key; // enumerable check later
          }
      }
  }
  ...
}

（我的cmets）

显然，具有非字符串键的属性将不会被枚举。使用这个例子：

var symbol = Symbol();
var object = {};

Object.defineProperty(object, symbol, {
    value: 'value',
    enumerable: true
});

Object.defineProperty(object, 'foo', {
  value: 'bar',
  enumerable: true
});

Object.defineProperty(object, 'bar', {
  value: 'baz',
  enumerable: false
});

Object.defineProperty(object, () => {}, {
  value: 'bin',
  enumerable: true
});

for (let f in object) {
  console.log(f, '=', object[f]);
}

for (let k of Object.getOwnPropertyNames(object)) {
  console.log(k);
}

你可以在 Babel 和 Traceur 中验证。

但是，您会看到两件有趣的事情：

1. getOwnPropertyNames 包括不可枚举的属性。这是有道理的，就像it follows completely different rules。
2. for...in 包括两个转译器下的非字符串属性。这似乎不符合规范，但符合 ES5 的行为。