Что означает многозначимое?

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

Затем я перешел на страницу Enumerability and ownership of properties, где он сказал: "Перечислимые свойства - это те, которые могут быть повторены с помощью. в цикле."

Словарь определяет перечисляемый как счетный, но я не могу реально представить, что это значит. Могу ли я получить пример того, что можно перечислить?

Ответы

Ответ 1

Перечислимое свойство - это свойство, которое может быть включено и посещено в течение 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 цикл for..in выполняет 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

Ответ 2

Если вы создаете объект через 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.

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

Ответ 3

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

Существует буквально атрибут для всех свойств, называемых "перечислимыми". Когда он установлен в 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".

Ответ 4

Если у вас возникли трудности с визуализацией "что значит быть перечислимым?" почему бы не спросить себя, что значит быть беспроигрышным?

Я думаю, что это немного похоже на невыносимое свойство существует, но частично скрыто; а это означает, что неузнаваемый является странным. Теперь вы можете представить себе перечислимое как то, что осталось - более естественное свойство, с которым мы привыкли сталкиваться, так как мы обнаружили объекты. Рассмотрим

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 */

Ответ 5

Я напишу одну строку определения ENUMERABLE

Enumerable : указывает, может ли свойство быть возвращено в цикле for/in.

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

Ответ 6

методы не перечислимы; или, скорее, встроенные методы не... после поиска того, что перечисляемый означает java script; он просто ссылается на атрибут свойства.. все созданные объекты в ecma3 перечислимы, и ecma5 u теперь может определить его.... что он..: D lol взял меня немного, чтобы найти ответ; но я верю, что его рассказывали в книге Дэвида Фланагана.. так что я думаю, что это означает "скрытый" или не "скрытый" в том, что методы не показаны в цикле for in и, таким образом, "скрыты"