可枚举是什么意思？

可枚举属性是指在 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'

但是，只对 [[Enumerable]]属性为 true的属性计算其语句(在本例中为 console.log(prop);)。

这种情况是因为对象 拥有更多的财产，特别是 继承遗产:

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 中的不可枚举属性，但是显示了一个正在枚举的对象。属性可以是或不是可写的、可配置的或可枚举的。John Resig 在 ECMAScript 5对象和属性的范围内讨论了这个问题。

还有一个关于 为什么要将属性设置为不可枚举的的堆栈溢出问题。

如果你很难想象“可枚举是什么意思?”为什么不问问自己，成为 数不胜数意味着什么？

我认为它有点像这样，一个 不可数属性 存在，但是部分是 藏起来了; 这意味着 数不胜数是一个奇怪的属性。现在，您可以想象剩下的是可枚举的——自从我们发现 物品以来，我们已经习惯于遇到的更自然的属性。考虑一下

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 */的位置

这比想象中的无聊多了

  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'

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