Ce n'est énumérable veux dire?
j'ai été dirigé vers le de MDN pour..à la page quand il a dit," pour..en Itérates sur les propriétés énumérables d'un objet."
puis je suis allé à la page Énumérabilité et propriété des propriétés où il est dit " propriétés énumérables sont ceux qui peuvent être itérés par un pour..en boucle."
le dictionnaire définit énumerable comme dénombrable, mais je ne peux pas vraiment visualiser ce que cela signifie. Pourrais-je obtenir un exemple de quelque chose qui est énumérable?
6 réponses
une propriété énumérable est une propriété qui peut être incluse dans et visitée pendant les boucles for..in (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 est 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 voir ceci comme partie du descripteur de 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 }
a for..in boucle puis itère à travers les noms de propriétés de l'objet.
var foo = { bar: 1, baz: 2};
for (var prop in foo)
console.log(prop); // outputs 'bar' and 'baz'
mais, évalue seulement son énoncé – console.log(prop); dans ce cas – pour les propriétés dont l'attribut [[Enumerable]] est true .
cette condition est en place parce que les objets ont beaucoup plus de propriétés , en particulier de l'héritage :
console.log(Object.getOwnPropertyNames(Object.prototype));
// ["constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", /* etc. */]
Chacune de ces propriétés encore existe sur l'objet :
console.log('constructor' in foo); // true
console.log('toString' in foo); // true
// etc.
mais, ils sont sautés par la boucle for..in parce qu'ils ne sont pas dénombrables.
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 aux alentours, toutes les propriétés sont dénombrables. Donc la question la plus facile à poser est, 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, on []), il retournera ['length'] , qui inclut la propriété non-énumérable d'un tableau, 'length'.
vous pouvez rendre votre propre non-énumérable propriétés 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 de des propriétés non-énumérables en JavaScript , mais montre un objet étant énuméré plus. Les propriétés peuvent être ou ne pas être inscriptibles, configurables ou énumérables. John Resig en parle dans le cadre de ECMAScript 5 Objects and Properties .
et, il y a une question de débordement de pile sur pourquoi vous ne voudriez jamais rendre les propriétés non-dénombrables .
C'est beaucoup plus ennuyeux que quelque chose qui devrait être visualisées.
il y a littéralement un attribut sur toutes les propriétés appelé" énumerable."Quand elle est définie à false la méthode for..in sautera cette propriété, prétendre qu'elle n'existe pas.
il y a beaucoup de propriétés sur les objets qui ont "énumerable" mis à false, comme "valueOf" et "hasOwnProperty," parce qu'il est présumé que vous ne voulez pas le Moteur JavaScript itérant par rapport à ceux-ci.
vous pouvez créer vos propres propriétés non-dénombrables en utilisant la méthode 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
});
maintenant, le fait qu'il y ait même un secret au sujet de la voiture est caché. Bien sûr, ils peuvent encore accéder à la propriété directement et obtenir la réponse:
console.log(car.mySecretAboutTheCar); // prints 'cat pee in back seat'
mais, ils devraient savoir que la propriété existe d'abord, parce que s'ils essaient d'y accéder par for..in ou Object.keys il restera complètement secret:
console.log(Object.keys(car)); //prints ['make', 'model', 'year', 'condition', 'mileage']
ils auraient dû l'appeler " forInAble."
si vous avez des difficultés à visualiser " que signifie être énumérable?"pourquoi ne pas se demander, Que signifie être non-cumulable ?
je pense à un peu comme ceci, un Non-numérable propriété existe mais est partiellement caché ; ce qui signifie que Non-numérable est le bizarre. Maintenant, vous pouvez imaginer énumérable comme ce qui reste - la propriété plus naturelle que nous sommes habitués à rencontrer depuis que nous avons découvert objets . Consider
var o = {};
o['foo'] = 0; // enumerable, normal
Object.defineProperty(o, 'bar', {value: 1}); // nonenumerable, weird
maintenant dans un for..in , imaginez comme 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é dans JavaScript est à la place de /* whatever */
je vais écrire une définition de ligne de énumérable
énumérable: spécifie si la propriété peut être retournée dans une boucle for/in.
var obj = {};
Object.defineProperties(data, {
set1: {enumerable: true},
set2: {enumerable: false},
});
Object.keys(obj); // ["set1"]
Object.getOwnPropertyNames(obj); // ["set1", "set2"]
ne sont pas dénombrables; ou plutôt les méthodes intégrées ne le sont pas.. tho après recherche sur ce que énumérable signifie À script java; il se réfère juste à un attribut de propriété.. tous les objets créés dans ecma3 sont énumérables, et ecma5 u peut maintenant définir....c'est tout.. : D lol m'a pris un peu pour trouver la réponse; mais je crois que c'est parlé dans le livre de David Flanagan.. donc je suppose que cela signifie "caché" ou pas "caché" dans les méthodes ne sont pas affichés dans la dans la boucle, et donc sont "cachés"