Wie kann die Anzahl der Schlüssel / Eigenschaften eines Objekts in JavaScript effizient gezählt werden?

Was ist der schnellste Weg, um die Anzahl der Schlüssel / Eigenschaften eines Objekts zu zählen? Ist es möglich, dies zu tun, ohne über das Objekt zu iterieren? dh ohne zu tun

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

(Firefox hat eine magische __count__Eigenschaft bereitgestellt , die jedoch irgendwo um Version 4 entfernt wurde.)

So tun Sie dies in jeder ES5-kompatiblen Umgebung wie Node , Chrome, IE 9+, Firefox 4+ oder Safari 5+:

Object.keys(obj).length

• Browser-Kompatibilität
• Object.keys-Dokumentation (enthält eine Methode, die Sie Nicht-ES5-Browsern hinzufügen können)

Sie könnten diesen Code verwenden:

if (!Object.keys) {
    Object.keys = function (obj) {
        var keys = [],
            k;
        for (k in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, k)) {
                keys.push(k);
            }
        }
        return keys;
    };
}

Dann können Sie dies auch in älteren Browsern verwenden:

var len = Object.keys(obj).length;

Wenn Sie Underscore.js verwenden , können Sie _.size verwenden (danke @douwe):
_.size(obj)

Alternativ können Sie auch _.keys verwenden, die für einige möglicherweise klarer sind:
_.keys(obj).length

Ich kann Underscore nur empfehlen, es ist eine enge Bibliothek für viele grundlegende Dinge. Wann immer möglich, stimmen sie mit ECMA5 überein und verschieben sich auf die native Implementierung.

Ansonsten unterstütze ich die Antwort von @ Avi. Ich habe es bearbeitet, um einen Link zum MDC-Dokument hinzuzufügen, der die keys () -Methode enthält, die Sie Nicht-ECMA5-Browsern hinzufügen können.

Die Standardobjektimplementierung ( ES5.1 Objektinterne Eigenschaften und Methoden ) erfordert keine ObjectVerfolgung der Anzahl der Schlüssel / Eigenschaften. Daher sollte es keine Standardmethode geben, um die Größe einer zu bestimmen, Objectohne explizit oder implizit über ihre Schlüssel zu iterieren.

Hier sind die am häufigsten verwendeten Alternativen:

1. Object.keys () von ECMAScript

Object.keys(obj).length;Funktioniert durch internes Durchlaufen der Schlüssel, um ein temporäres Array zu berechnen und dessen Länge zurückzugeben.

• Vorteile - Lesbare und saubere Syntax. Keine Bibliothek oder benutzerdefinierter Code erforderlich, außer einem Shim, wenn keine native Unterstützung verfügbar ist
• Nachteile - Speicheraufwand aufgrund der Erstellung des Arrays.

2. Bibliotheksbasierte Lösungen

Viele bibliotheksbasierte Beispiele an anderer Stelle in diesem Thema sind nützliche Redewendungen im Kontext ihrer Bibliothek. Unter dem Gesichtspunkt der Leistung gibt es jedoch nichts zu gewinnen im Vergleich zu einem perfekten Code ohne Bibliothek, da alle diese Bibliotheksmethoden entweder eine for-Schleife oder ES5 Object.keys(nativ oder shimmed) enthalten.

3. Optimieren einer for-Schleife

Der langsamste Teil einer solchen for-Schleife ist .hasOwnProperty()aufgrund des Funktionsaufrufaufwands im Allgemeinen der Aufruf. Wenn ich also nur die Anzahl der Einträge eines JSON-Objekts möchte, überspringe ich den .hasOwnProperty()Aufruf, wenn ich weiß, dass kein Code erweitert wurde oder wird Object.prototype.

Andernfalls könnte Ihr Code geringfügig optimiert werden, indem Sie klocal ( var k) erstellen und ++countanstelle von postfix den Präfix-Inkrement-Operator ( ) verwenden.

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

Eine andere Idee beruht auf dem Zwischenspeichern der hasOwnPropertyMethode:

var hasOwn = Object.prototype.hasOwnProperty;
var count = 0;
for (var k in myobj) if (hasOwn.call(myobj, k)) ++count;

Ob dies in einer bestimmten Umgebung schneller ist oder nicht, ist eine Frage des Benchmarking. Es ist ohnehin ein sehr begrenzter Leistungsgewinn zu erwarten.

Wenn Sie tatsächlich auf ein Leistungsproblem stoßen, würde ich empfehlen, die Aufrufe zum Hinzufügen / Entfernen von Eigenschaften zum / vom Objekt mit einer Funktion zu versehen, die auch eine Eigenschaft mit entsprechendem Namen (Größe?) Inkrementiert / dekrementiert.

Sie müssen die anfängliche Anzahl der Eigenschaften nur einmal berechnen und von dort aus fortfahren. Wenn es kein tatsächliches Leistungsproblem gibt, stören Sie sich nicht. Wickeln Sie einfach diesen Code in eine Funktion ein getNumberOfProperties(object)und fertig.

Wie von Avi Flax angegeben https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

führt den Trick für alle aufzählbaren Eigenschaften Ihres Objekts aus, aber um auch die nicht aufzählbaren Eigenschaften einzuschließen, können Sie stattdessen die verwenden 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

Wie hier angegeben, hat dies die gleiche Browserunterstützung wieObject.keys

In den meisten Fällen möchten Sie die nicht aufzählbaren Werte möglicherweise nicht in diese Art von Operationen einbeziehen, aber es ist immer gut, den Unterschied zu kennen;)

Mir ist keine Möglichkeit bekannt, dies zu tun. Um jedoch die Iterationen auf ein Minimum zu beschränken, können Sie versuchen, die Existenz von zu überprüfen. __count__Wenn diese nicht vorhanden sind (dh nicht Firefox), können Sie das Objekt durchlaufen und definieren es für die spätere Verwendung zB:

if (myobj.__count__ === undefined) {
  myobj.__count__ = ...
}

Auf diese Weise würde jeder Browser, der dies unterstützt, __count__dies verwenden, und Iterationen würden nur für diejenigen ausgeführt, die dies nicht tun. Wenn sich die Anzahl ändert und Sie dies nicht tun können, können Sie es jederzeit zu einer Funktion machen:

if (myobj.__count__ === undefined) {
  myobj.__count__ = function() { return ... }
  myobj.__count__.toString = function() { return this(); }
}

Auf diese Weise können Sie jederzeit auf myobj verweisen. __count__Die Funktion wird ausgelöst und neu berechnet.

Um mit Avi Flax zu iterieren, antworten Sie auf Object.keys (obj) .length ist für ein Objekt korrekt, an das keine Funktionen gebunden sind

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 möchten

2. Verwenden Sie ein separates Objekt oder erstellen Sie ein neues Objekt speziell für Funktionen (wenn Sie zählen möchten, wie viele Funktionen in der Datei enthalten sind Object.keys(obj).length)

auch ja ich habe das _ oder unterstreichen modul von nodejs in meinem beispiel verwendet

Dokumentation finden Sie hier http://underscorejs.org/ sowie die Quelle auf Github und verschiedene andere Informationen

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

_.size(obj)

wie oben beantwortet: Object.keys(obj).length

Aber: Da wir jetzt eine echte Map- Klasse in ES6 haben, würde ich vorschlagen , sie anstelle der Eigenschaften eines Objekts zu verwenden.

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

Für diejenigen, die Underscore.js in ihrem Projekt haben, können Sie Folgendes tun:

_({a:'', b:''}).size() // => 2

oder funktionaler Stil:

_.size({a:'', b:''}) // => 2

Hier sind einige Leistungstests für drei Methoden;

https://jsperf.com/get-the-number-of-keys-in-an-object

Object.keys (). Länge

20.735 Operationen pro Sekunde

Sehr einfach und kompatibel. Läuft schnell, aber teuer, weil es ein neues Array von Schlüsseln erstellt, die dann weggeworfen werden.

return Object.keys(objectToRead).length;

Schleife durch die Tasten

15.734 Operationen pro Sekunde

let size=0;
for(let k in objectToRead) {
  size++
}
return size;

Etwas langsamer, aber bei weitem nicht in der Nähe der Speichernutzung. Daher wahrscheinlich besser, wenn Sie an einer Optimierung für mobile oder andere kleine Maschinen interessiert sind

Karte anstelle von Objekt verwenden

953.839.338 Operationen pro Sekunde

return mapToRead.size;

Grundsätzlich verfolgt Map seine eigene Größe, sodass wir nur ein Zahlenfeld zurückgeben. Weit, weit schneller als jede andere Methode. Wenn Sie die Kontrolle über das Objekt haben, konvertieren Sie sie stattdessen in Karten.

Von: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

Object.defineProperty (obj, prop, deskriptor)

Sie können es entweder allen Ihren Objekten hinzufügen:

Object.defineProperty(Object.prototype, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

Oder ein einzelnes Objekt:

var myObj = {};
Object.defineProperty(myObj, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

Beispiel:

var myObj = {};
myObj.name  = "John Doe";
myObj.email = "leaked@example.com";
myObj.length; //output: 2

Auf diese Weise hinzugefügt, wird es nicht in for..in-Schleifen angezeigt:

for(var i in myObj) {
     console.log(i + ":" + myObj[i]);
}

Ausgabe:

name:John Doe
email:leaked@example.com

Hinweis: Es funktioniert nicht in <IE9-Browsern.

Ich habe dieses Problem gelöst, indem ich meine eigene Implementierung einer Basisliste erstellt habe, in der aufgezeichnet wird, wie viele Elemente im Objekt gespeichert sind. Es ist sehr einfach. Etwas wie das:

function BasicList()
{
   var items = {};
   this.count = 0;

   this.add = function(index, item)
   {
      items[index] = item;
      this.count++;
   }

   this.remove = function (index)
   {
      delete items[index];
      this.count--;
   }

   this.get = function(index)
   {
      if (undefined === index)
        return items;
      else
        return items[index];
   }
}

Sie können Object.keys(data).lengthdie Länge des JSON-Objekts mit Schlüsseldaten ermitteln

Für diejenigen, die Ext JS 4 in ihrem Projekt haben, können Sie Folgendes tun:

Ext.Object.getSize(myobj);

Dies hat den Vorteil, dass es auf allen Ext-kompatiblen Browsern (einschließlich IE6-IE8) funktioniert. Ich glaube jedoch, dass die Laufzeit nicht besser als O (n) ist, wie bei anderen Lösungsvorschlägen.

Sie können verwenden:

Object.keys(objectName).length; 

und

Object.values(objectName).length;

OP hat nicht angegeben, ob das Objekt eine Knotenliste ist. Wenn dies der Fall ist, können Sie einfach die Längenmethode direkt darauf verwenden. Beispiel:

buttons = document.querySelectorAll('[id=button)) {
console.log('Found ' + buttons.length + ' on the screen'); 

Wenn jQuery oben nicht funktioniert, versuchen Sie es

$(Object.Item).length

Ich denke nicht, dass dies möglich ist (zumindest nicht ohne einige Interna). Und ich glaube nicht, dass Sie durch die Optimierung viel gewinnen würden.

Ich versuche es allen Objekten wie folgt zur Verfügung zu stellen:

Object.defineProperty(Object.prototype, "length", {
get() {
    if (!Object.keys) {
        Object.keys = function (obj) {
            var keys = [],k;
            for (k in obj) {
                if (Object.prototype.hasOwnProperty.call(obj, k)) {
                    keys.push(k);
                }
            }
            return keys;
        };
    }
    return Object.keys(this).length;
},});

console.log({"Name":"Joe","Age":26}.length) //returns 2

Google Closure hat eine nette Funktion dafür ... goog.object.getCount (obj)

Schauen Sie sich die goog.Object-Dokumentation an