Що означає численні?

Мене скерували на сторінку MDN for..in, коли вона сказала: "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 , але показує об'єкт, який перераховується. Властивості можуть бути або не підлягати запису, конфігуруватися чи перелічуватися. Джон Резіг обговорює це в межах об'єктів та властивостей ECMAScript 5 .

І є запитання щодо переповнення стека щодо того, чому ви хочете коли-небудь зробити властивості незліченними .

Це набагато нудніше, ніж щось, що слід візуалізувати.

У всіх властивостях буквально є атрибут під назвою "перелічувальний". Якщо встановлено значення false, for..inметод пропустить це властивість, зробіть вигляд, що він не існує.

Існує маса властивостей об’єктів, у яких "кількість" встановлена ​​на помилку, як "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

Тепер у a 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 u тепер може це визначити .... ось це ..: D lol трохи взяв мене, щоб знайти відповідь; але я вважаю, що про це говорилося в книзі Девіда Фланагана .. тому я гадаю, що це означає «приховано», або не «приховано» в тому, що методи не відображаються в циклі «for in» і, таким чином, «приховуються»

Подумайте про тип даних enum, просто про структуру об'єктів, які відповідають різним числам. Декларувати щось як перелічувальне - це заявити, що воно відповідає певній кількості, що дозволяє йому відводити місце в словнику, що представляє лічильні компоненти об'єкта. Простіше кажучи, зробити об'єкт численним - це те саме, що сказати компілятору: "Ей, ця властивість рахується. Я хочу це побачити, коли я перевіряю дані про цей об'єкт".

Вбудовані методи, які успадковують об'єкти, не перелічуються, але властивості, які ваш код додає до об'єктів, перелічуються, якщо прямо не зазначено