Что значит перечислимое?

Я был направлен в MDN для ... на странице, когда он сказал: "для ... итерации по перечисляемым свойствам объекта".

Затем я перешел на страницу « Перечислимость и владение свойствами», где говорилось: «Перечислимые свойства - это те, которые могут быть повторены циклом 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 , но показывает перечисляемый объект. Свойства могут быть или не быть записываемыми, настраиваемыми или перечисляемыми. Джон Резиг обсуждает это в рамках объектов и свойств ECMAScript 5 .

И есть вопрос переполнения стека о том, почему вы хотите сделать свойства не перечисляемыми .

Это намного скучнее, чем то, что нужно визуализировать.

Во всех свойствах буквально есть атрибут, называемый перечислимым. Когда установлено значение false, for..inметод пропускает это свойство, делая вид, что его не существует.

Существует множество свойств для объектов, для которых «enumerable» имеет значение 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 lol, мне понадобилось немного, чтобы найти ответ; но я верю, что об этом говорилось в книге Дэвида Фланагана ... поэтому я предполагаю, что это означает "скрытый" или не "скрытый" в том смысле, что методы не отображаются в цикле for in и, следовательно, "скрыты"

Представьте себе тип данных enum, просто структуру объектов, которые соответствуют разным числам. Объявить что-либо как перечисляемое означает объявить, что оно соответствует определенному числу, что позволяет ему получить место в Словаре, который представляет счетные компоненты объекта. Проще говоря, сделать объект перечисляемым - это то же самое, что сказать компилятору: «Эй, это свойство имеет значение, я хочу увидеть это, когда проверю данные этого объекта».

Встроенные методы, которые наследуют объекты, не перечисляются, но свойства, которые ваш код добавляет к объектам, перечислимы, если явно не указано