javascript - über - js objekt durchlaufen




Was bedeutet aufzählbar? (4)

Eine aufzählbare Eigenschaft ist eine Eigenschaft, die während for..in Schleifen (oder einer ähnlichen Iteration von Eigenschaften wie Object.keys() ) eingeschlossen und for..in werden kann.

Wenn eine Eigenschaft nicht als aufzählbar identifiziert wird, ignoriert die Schleife, dass sie sich innerhalb des Objekts befindet.

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"

Eine Eigenschaft wird durch ihr eigenes Attribut [[Enumerable]] als aufzählbar oder nicht [[Enumerable]] . Sie können dies als Teil des Deskriptors der Eigenschaft anzeigen:

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 }

Eine for..in Schleife for..in dann die Eigenschaftsnamen des Objekts.

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

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

Aber wertet nur seine Aussage aus - console.log(prop); In diesem Fall - für die Eigenschaften, deren Attribut [[Enumerable]] true .

Diese Bedingung ist vorhanden, da Objekte viele weitere Eigenschaften aufweisen , insbesondere aus der Vererbung :

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

Jede dieser Eigenschaften ist noch auf dem Objekt vorhanden :

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

Aber sie werden von der for..in Schleife übersprungen (oder " nicht gezählt "), weil sie nicht aufzählbar sind.

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

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

Ich wurde auf MDN for..in Seite verwiesen, als es sagte, "for..in iteriert über die aufzählbaren Eigenschaften eines Objekts."

Dann ging ich auf die Seite Enumerability and Ownership of properties, auf der stand: "Enumerable properties sind diejenigen, die durch eine for..in-Schleife iteriert werden können."

Das Wörterbuch definiert aufzählbar als zählbar, aber ich kann mir nicht wirklich vorstellen, was das bedeutet. Kann ich ein Beispiel dafür bekommen, dass etwas aufzählbar ist?


Ich werde eine Zeile Definition von ENUMERABLE schreiben

Enumerable: Gibt an, ob die Eigenschaft in einer For / In-Schleife zurückgegeben werden kann.

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

Wenn Sie Schwierigkeiten haben, sich vorzustellen, "was bedeutet es aufzuzählen?" Warum fragst du dich nicht selbst, was bedeutet es, nicht zahlbar zu sein ?

Ich denke ein bisschen so darüber nach, eine nicht- enumerierbare Eigenschaft existiert , ist aber teilweise verborgen ; was bedeutet, dass nicht- enumerierbar ist der komische. Jetzt können Sie sich das Aufzählbare als das vorstellen, was übrig ist - die natürlichere Eigenschaft, der wir seit der Entdeckung von Objekten gewohnt sind. Erwägen

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

Jetzt in einem for..in , stelle es sich vor wie Pseudocode

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

wo der Körper der Schleife, die Sie in JavaScript eingegeben haben, an Stelle von /* whatever */


Wenn Sie ein Objekt über myObj = {foo: 'bar'} oder etwas myObj = {foo: 'bar'} erstellen, sind alle Eigenschaften aufzählbar. Die einfachere Frage ist also, was nicht aufzählbar ist? Bestimmte Objekte haben einige nicht aufzählbare Eigenschaften, zum Beispiel, wenn Sie Object.getOwnPropertyNames([]) aufrufen (was ein Array aller Eigenschaften, aufzählbar oder nicht, auf []) zurückgibt, gibt es ['length'] , was einschließt die nicht aufzählbare Eigenschaft eines Arrays, 'length'.

Sie können Ihre eigenen nicht aufzählbaren Eigenschaften Object.defineProperty indem Sie Object.defineProperty aufrufen:

var person = { age: 18 };
Object.defineProperty(person, 'name', { value: 'Joshua', enumerable: false });

person.name; // 'Joshua'
for (prop in person) {
  console.log(prop);
}; // 'age'

Dieses Beispiel lehnt sich stark an nicht aufzählbare Eigenschaften in JavaScript an , zeigt jedoch ein Objekt an, für das eine Aufzählung durchgeführt wird. Eigenschaften können schreibbar, konfigurierbar oder aufzählbar sein oder nicht. John Resig diskutiert dies im Rahmen der ECMAScript 5-Objekte und -Eigenschaften .

Und es gibt eine -Frage darüber, warum Sie Objekte niemals aufzählbar machen möchten .







enumerable