枚举是什么意思？

当它说“ for..in遍历对象的可枚举属性”时，我被定向到MDN的for..in页面。

然后，我转到属性的可枚举和所有权页面，其中显示“可枚举的属性是可以通过for..in循环进行迭代的那些属性”。

字典将可枚举定义为可数，但我无法真正想象这意味着什么。我能举个例子吗？

可枚举的属性是可以在for..in循环（或类似的属性迭代，例如Object.keys()）中包含和访问的属性。

如果某个属性未标识为可枚举，则循环将忽略该属性在对象内。

var obj = { key: 'val' };

console.log('toString' in obj); // true
console.log(typeof obj.toString); // "function"

for (var key in obj)
    console.log(key); // "key"

属性通过其自身的[[Enumerable]]属性被标识为可枚举或不可枚举。您可以将其视为属性描述符的一部分：

var descriptor = Object.getOwnPropertyDescriptor({ bar: 1 }, 'bar');

console.log(descriptor.enumerable); // true
console.log(descriptor.value);      // 1

console.log(descriptor);
// { value: 1, writable: true, enumerable: true, configurable: true }

一for..in则遍历对象的属性名称进行迭代。

var foo = { bar: 1, baz: 2};

for (var prop in foo)
    console.log(prop); // outputs 'bar' and 'baz'

但是，console.log(prop);在这种情况下，仅对[[Enumerable]]属性为的那些属性评估其语句true。

之所以存在此条件，是因为对象具有更多的属性，尤其是继承的属性：

console.log(Object.getOwnPropertyNames(Object.prototype));
// ["constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", /* etc. */]

这些属性中的每一个仍然存在于对象上：

console.log('constructor' in foo); // true
console.log('toString' in foo);    // true
// etc.

但是，for..in由于它们不可枚举，因此被循环跳过了。

var descriptor = Object.getOwnPropertyDescriptor(Object.prototype, 'constructor');

console.log(descriptor.enumerable); // false

如果通过myObj = {foo: 'bar'}或其他方式创建对象，则所有属性都是可枚举的。因此，更容易提出的问题是，什么是不可数的？某些对象具有一些不可枚举的属性，例如，如果您调用Object.getOwnPropertyNames([])（将返回所有属性的数组，无论是否枚举，在[]上），它将返回['length']，其中包括数组的不可枚举的属性'length'。 。

您可以通过调用Object.defineProperty以下方法来创建自己的不可枚举的属性：

var person = { age: 18 };
Object.defineProperty(person, 'name', { value: 'Joshua', enumerable: false });

person.name; // 'Joshua'
for (prop in person) {
  console.log(prop);
}; // 'age'

此示例大量借鉴了JavaScript中的Non-enumerable属性，但显示了被枚举的对象。属性可以是可写，可配置或可枚举的，也可以是不可写的。John Resig在ECMAScript 5对象和属性的范围内对此进行了讨论。

而且，还有一个堆栈溢出问题，关于为什么您要使属性不可枚举。

它比应该可视化的东西更无聊。

实际上，所有属性上都有一个称为“可枚举”的属性。如果将其设置为false，则该for..in方法将跳过该属性，并假装该属性不存在。

对象上有许多属性将“可枚举”设置为false，例如“ valueOf”和“ hasOwnProperty”，因为假定您不希望JavaScript引擎在这些属性上进行迭代。

您可以使用以下Object.defineProperty方法创建自己的不可枚举的属性：

  var car = {
    make: 'Honda',
    model: 'Civic',
    year: '2008',
    condition: 'bad',
    mileage: 36000
  };

  Object.defineProperty(car, 'mySecretAboutTheCar', {
    value: 'cat pee in back seat',
    enumerable: false
  });

现在，关于汽车的秘密这个事实已经隐藏了。当然，他们仍然可以直接访问该属性并获得答案：

console.log(car.mySecretAboutTheCar); // prints 'cat pee in back seat'

但是，他们必须知道该属性首先存在，因为如果他们试图通过它进行访问，for..in否则Object.keys它将完全是秘密的：

console.log(Object.keys(car)); //prints ['make', 'model', 'year', 'condition', 'mileage']

他们应该将其称为“ forInAble”。

如果您难以想象“可枚举意味着什么？” 为什么不问自己，无数意味着什么呢？

我这样想，存在一个不可数的属性，但部分被隐藏了；意思是，无数是奇怪的。现在您可以想象剩下的可以枚举了-自从发现对象以来我们曾经遇到的更自然的属性。考虑

var o = {};
o['foo'] =  0;                               // enumerable, normal
Object.defineProperty(o, 'bar', {value: 1}); // nonenumerable, weird

现在在中for..in，将其想象为伪代码

for property in o:
    if not property enumerable continue // skip non-enumerable, "bar"
    else do /* whatever */              // act upon enumerable, "foo"

您在JavaScript中键入的循环的主体位于/* whatever */

我将写一个ENUMERABLE的行定义

Enumerable：指定是否可以在for / in循环中返回该属性。

var obj = {};
Object.defineProperties(obj, {
    set1: {enumerable: true},
    set2: {enumerable: false},
});
Object.keys(obj); // ["set1"]
Object.getOwnPropertyNames(obj); // ["set1", "set2"]

方法不可枚举；在搜索了 Java脚本的可枚举含义之后，就没有了。它只是指向属性属性。.在ecma3中创建的所有对象都是可枚举的，并且ecma5现在可以定义它了。。就是这样。：D哈哈，我花了点时间找到答案；但是我相信它在David Flanagan的书中已经讨论过了。所以我想它的意思是“隐藏”，或者说不是“隐藏”，因为方法不会在for循环中显示，因此被“隐藏”了

考虑枚举数据类型，只是对应于不同数字的对象的结构。将某事物声明为可枚举就是声明该事物对应于特定数字，从而允许它在字典中被赋予代表对象的可数组成部分的位置。简单地说，使对象可枚举与告诉编译器相同：“嘿，这个属性很重要，当我检查该对象上的数据时，我希望看到它。”

对象继承的内置方法不可枚举，但是代码中添加到对象的属性是可枚举的，除非明确说明