Wie man effizient die Anzahl der Schlüssel/Eigenschaften eines Objekts in JavaScript zählt

Question

Wie kann man am schnellsten die Anzahl der Schlüssel/Eigenschaften eines Objekts zählen? Ist es möglich, dies zu tun, ohne über das Objekt zu iterieren? D.h., ohne zu tun:

var count = 0;
for (k in myobj) if (myobj.hasOwnProperty(k)) ++count;

(Firefox hat eine magische __count__ Eigenschaft, aber diese wurde irgendwann in Version 4 entfernt).

Answer 1

Wenn Sie tatsächlich in ein Leistungsproblem laufen, würde ich vorschlagen, die Aufrufe, die Eigenschaften zu/von dem Objekt mit einer Funktion hinzufügen/entfernen, die auch eine entsprechend benannte (Größe?) Eigenschaft erhöht/verringert zu wickeln.

Sie müssen nur einmal die anfängliche Anzahl der Immobilien berechnen und können dann weitermachen. Wenn es kein wirkliches Leistungsproblem gibt, brauchen Sie sich nicht zu bemühen. Packen Sie dieses Stück Code einfach in eine Funktion getNumberOfProperties(object) und damit fertig sein.

Answer 2

Dies funktioniert sowohl für Arrays als auch für Objekte

function count(obj){
        return Object.keys(obj).length
     }

Answer 3

Wie in einer früheren Antwort beantwortet: Object.keys(obj).length

Aber: Da wir jetzt eine echte Karte Klasse in ES6, würde ich vorschlagen zu verwenden, anstatt die Eigenschaften eines Objekts zu nutzen.

const map = new Map();
map.set("key", "value");
map.size; // THE fastest way

Answer 4

Als angegeben von Avi Flax ,

Object.keys(obj).length

erfüllt den Zweck für alle aufzählbaren Eigenschaften Ihres Objekts, aber um auch die nicht aufzählbaren Eigenschaften einzubeziehen, können Sie stattdessen die Object.getOwnPropertyNames . Hier ist der Unterschied:

var myObject = new Object();

Object.defineProperty(myObject, "nonEnumerableProp", {
  enumerable: false
});
Object.defineProperty(myObject, "enumerableProp", {
  enumerable: true
});

console.log(Object.getOwnPropertyNames(myObject).length); //outputs 2
console.log(Object.keys(myObject).length); //outputs 1

console.log(myObject.hasOwnProperty("nonEnumerableProp")); //outputs true
console.log(myObject.hasOwnProperty("enumerableProp")); //outputs true

console.log("nonEnumerableProp" in myObject); //outputs true
console.log("enumerableProp" in myObject); //outputs true

Als hier angegeben hat die gleiche Browserunterstützung wie Object.keys .

In den meisten Fällen werden Sie die nicht-aufzählbaren Daten jedoch nicht in diese Art von Operationen einbeziehen wollen, aber es ist immer gut, den Unterschied zu kennen ;)

Answer 5

Zur Iteration von Avi Flax' Antwort , Object.keys(obj).length ist korrekt für ein Objekt, das keine Funktionen an sich gebunden hat.

Beispiel:

obj = {"lol": "what", owo: "pfft"};
Object.keys(obj).length; // should be 2

gegen

arr = [];
obj = {"lol": "what", owo: "pfft"};
obj.omg = function(){
    _.each(obj, function(a){
        arr.push(a);
    });
};
Object.keys(obj).length; // should be 3 because it looks like this
/* obj === {"lol": "what", owo: "pfft", omg: function(){_.each(obj, function(a){arr.push(a);});}} */

Schritte, um dies zu vermeiden:

1. Fügen Sie keine Funktionen in ein Objekt ein, in dem Sie die Anzahl der Schlüssel zählen wollen

2. ein separates Objekt verwenden oder ein neues Objekt speziell für Funktionen erstellen (wenn Sie zählen wollen, wie viele Funktionen in der Datei vorhanden sind, indem Sie Object.keys(obj).length )

Und ja, ich habe die _ o Underscore.js Modul von Node.js in meinem Beispiel.

Die Dokumentation ist zu finden unter aquí sowie den Quellcode auf GitHub und verschiedene andere Informationen.

Und schließlich eine Lodash-Implementierung https://lodash.com/docs#size

_.size(obj)