Que signifie énumérable?

J'ai été dirigé vers la page for..in de MDN quand il a dit, "for..in Itère sur les propriétés énumérables d'un objet."

Ensuite, je suis allé à la page Énumérabilité et propriété des propriétés où il était dit "Les propriétés énumérables sont celles qui peuvent être itérées par une boucle for..in."

Le dictionnaire définit enumerable comme dénombrable, mais je ne peux pas vraiment visualiser ce que cela signifie. Puis-je avoir un exemple de quelque chose qui est énumérable?

Une propriété énumérable est une propriété qui peut être incluse et visitée pendant les for..inboucles (ou une itération similaire de propriétés, comme Object.keys()).

Si une propriété n'est pas identifiée comme énumérable, la boucle ignorera qu'elle se trouve dans l'objet.

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"

Une propriété est identifiée comme énumérable ou non par son propre [[Enumerable]]attribut . Vous pouvez l'afficher dans le cadre du descripteur de la propriété :

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 }

Une for..inboucle parcourt ensuite les noms de propriété de l'objet.

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

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

Mais, n'évalue son instruction - console.log(prop);dans ce cas - que pour les propriétés dont l' [[Enumerable]]attribut est true.

Cette condition est en place car les objets ont beaucoup plus de propriétés , en particulier d'héritage :

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

Chacune de ces propriétés existe toujours sur l'objet :

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

Mais, ils sont ignorés par la for..inboucle car ils ne sont pas énumérables.

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

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

Si vous créez un objet via myObj = {foo: 'bar'}ou quelque chose autour, toutes les propriétés sont énumérables. La question la plus facile à poser est donc: qu'est-ce qui n'est pas énumérable? Certains objets ont des propriétés non énumérables, par exemple si vous appelez Object.getOwnPropertyNames([])(qui renvoie un tableau de toutes les propriétés, énumérables ou non, sur []), il retournera ['length'], qui inclut la propriété non énumérable d'un tableau, 'length' .

Vous pouvez créer vos propres propriétés non énumérables en appelant 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'

Cet exemple emprunte fortement aux propriétés non énumérables en JavaScript , mais montre un objet en cours d'énumération. Les propriétés peuvent être ou non accessibles en écriture, configurables ou énumérables. John Resig en discute dans le cadre des objets et propriétés ECMAScript 5 .

Et il y a une question Stack Overflow sur la raison pour laquelle vous voudriez rendre les propriétés non énumérables .

C'est beaucoup plus ennuyeux que quelque chose qui devrait être visualisé.

Il y a littéralement un attribut sur toutes les propriétés appelé «énumérable». Lorsqu'il est défini sur false, lefor..in méthode ignore cette propriété, prétendant qu'elle n'existe pas.

Il y a beaucoup de propriétés sur les objets pour lesquels «énumérable» est défini sur false, comme «valueOf» et «hasOwnProperty», car il est présumé que vous ne voulez pas que le moteur JavaScript les répète.

Vous pouvez créer vos propres propriétés non énumérables à l'aide de la Object.definePropertyméthode:

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

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

Maintenant, le fait qu'il y ait même un secret sur la voiture est caché. Bien sûr, ils peuvent toujours accéder directement à la propriété et obtenir la réponse:

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

Mais, ils devraient d'abord savoir que la propriété existe, car s'ils essaient d'y accéder via for..inou Object.keyselle restera complètement secrète:

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

Ils auraient dû simplement l'appeler «forInAble».

Si vous rencontrez des difficultés pour visualiser "que signifie être énumérable?" pourquoi ne pas se demander ce que signifie être non- dénombrable ?

J'y pense un peu comme ça, une propriété non- innombrable existe mais est partiellement cachée ; ce qui signifie que non dénombrable est le plus étrange. Maintenant, vous pouvez imaginer énumérable comme ce qui reste - la propriété la plus naturelle que nous avons l'habitude de rencontrer depuis que nous avons découvert Objects . Considérer

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

Maintenant dans un for..in, imaginez-le comme un pseudocode

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

où le corps de la boucle que vous avez tapée en JavaScript est à la place de/* whatever */

J'écrirai une définition de ligne de ENUMERABLE

Enumerable: Spécifie si la propriété peut être renvoyée dans une boucle for / in.

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

les méthodes ne sont pas énumérables; ou plutôt les méthodes intégrées ne sont pas .. tho après avoir recherché ce que signifie énumérable au script java; il fait simplement référence à un attribut de propriété .. tous les objets créés dans ecma3 sont énumérables, et ecma5 vous pouvez maintenant le définir .... c'est tout ..: D lol m'a pris un peu de temps pour trouver la réponse; mais je crois que cela en a parlé dans le livre de David Flanagan .. donc je suppose que cela signifie «caché», ou pas «caché» en ce que les méthodes ne sont pas montrées dans la boucle for in, et sont donc «cachées»

Pensez au type de données enum, juste une structure d'objets qui correspondent à différents nombres. Déclarer quelque chose à comme énumérable, c'est déclarer qu'il correspond à un nombre spécifique, ce qui lui permet de se voir attribuer une place dans un dictionnaire qui représente les composants dénombrables d'un objet. Pour faire simple, rendre un objet énumérable équivaut à dire au compilateur: "Hé, cette propriété compte, je veux voir cela quand je vérifie les données sur cet objet."

Les méthodes intégrées dont les objets héritent ne sont pas énumérables, mais les propriétés que votre code ajoute aux objets sont énumérables sauf indication explicite