Länge eines JavaScript-Objekts

Question

Wenn ich beispielsweise ein JavaScript-Objekt habe

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

Gibt es eine integrierte oder anerkannte Best-Practice-Methode, um die Länge dieses Objekts zu ermitteln?

Answer 1

Die aussagekräftigste Antwort (d. h.das die Absicht dessen erfasst, was Sie tun möchten, und gleichzeitig die wenigsten Fehler verursacht) wäre:

Object.size = function(obj) {
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

// Get the size of an object
var size = Object.size(myObj);

In JavaScript gibt es eine Art Konvention, dass Sie Fügen Sie Object.prototype keine Dinge hinzu, weil es Aufzählungen in verschiedenen Bibliotheken zerstören kann.Das Hinzufügen von Methoden zu Object ist jedoch normalerweise sicher.

---

Hier ist ein Update von 2016 und weitverbreiteter Einsatz von ES5 und darüber hinaus. Für IE9+ und alle anderen modernen ES5+-fähigen Browser können Sie verwenden Object.keys() Der obige Code wird also einfach zu:

var size = Object.keys(myObj).length;

Dadurch muss kein bestehender Prototyp geändert werden Object.keys() ist jetzt eingebaut.

Bearbeiten:Objekte können symbolische Eigenschaften haben, die nicht über die Object.key-Methode zurückgegeben werden können.Die Antwort wäre also unvollständig, ohne sie zu erwähnen.

Der Sprache wurde ein Symboltyp hinzugefügt, um eindeutige Bezeichner für Objekteigenschaften zu erstellen.Der Hauptvorteil des Symboltyps besteht darin, dass Überschreibungen verhindert werden.

Object.keys oder Object.getOwnPropertyNames funktioniert nicht für symbolische Eigenschaften.Um sie zurückzugeben, müssen Sie verwenden Object.getOwnPropertySymbols.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.log(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.log(propSymb.length); // 2

Answer 2

Wenn Sie es wissen, brauchen Sie sich darüber keine Sorgen zu machen hasOwnProperty prüft, können Sie dies ganz einfach tun:

Object.keys(myArray).length

Answer 3

Aktualisiert:Wenn Sie verwenden Underscore.js (empfohlen, es ist leicht!), dann können Sie es einfach tun

_.size({one : 1, two : 2, three : 3});
=> 3

Wenn nicht, und Sie aus irgendeinem Grund nicht mit Objekteigenschaften herumspielen möchten und bereits jQuery verwenden, ist ein Plugin gleichermaßen zugänglich:

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

Answer 4

Hier ist die browserübergreifendste Lösung.

Dies ist besser als die akzeptierte Antwort, da native Object.keys verwendet werden, sofern vorhanden.Somit ist es das schnellste für alle modernen Browser.

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

Object.keys(obj).length;

Answer 5

Ich bin kein JavaScript-Experte, aber es sieht so aus, als müssten Sie die Elemente durchlaufen und zählen, da Object keine Längenmethode hat:

var element_count = 0;
for (e in myArray) {  if (myArray.hasOwnProperty(e)) element_count++; }

@palmsey:Um dem OP gerecht zu werden, wird in der JavaScript-Dokumentation tatsächlich ausdrücklich darauf verwiesen, Variablen vom Typ Object auf diese Weise als „assoziative Arrays“ zu verwenden.

Answer 6

Diese Methode ruft alle Eigenschaftsnamen Ihres Objekts in einem Array ab, sodass Sie die Länge dieses Arrays ermitteln können, die der Länge der Schlüssel Ihres Objekts entspricht.

Object.getOwnPropertyNames({"hi":"Hi","msg":"Message"}).length; // => 2

Answer 7

Um sich nicht mit dem Prototyp oder anderem Code herumzuschlagen, können Sie Ihr eigenes Objekt erstellen und erweitern:

function Hash(){
    var length=0;
    this.add = function(key, val){
         if(this[key] == undefined)
         {
           length++;
         }
         this[key]=val;
    }; 
    this.length = function(){
        return length;
    };
}

myArray = new Hash();
myArray.add("lastname", "Simpson");
myArray.add("age", 21);
alert(myArray.length()); // will alert 2

Wenn Sie immer die Add-Methode verwenden, ist die Längeneigenschaft korrekt.Wenn Sie befürchten, dass Sie oder andere die Verwendung vergessen, können Sie auch den Eigenschaftszähler, den die anderen gepostet haben, zur Längenmethode hinzufügen.

Natürlich können Sie die Methoden jederzeit überschreiben.Aber selbst wenn Sie dies tun, würde Ihr Code wahrscheinlich merklich ausfallen, was das Debuggen erleichtert.;)

Answer 8

Das einfachste ist

Object.keys(myObject).length

Answer 9

Gehen Sie wie folgt vor und vergessen Sie nicht zu überprüfen, ob sich die Eigenschaft nicht in der Prototypenkette befindet:

var element_count = 0;
for(var e in myArray)
    if(myArray.hasOwnProperty(e))
        element_count++;

Answer 10

Verwenden Sie einfach dies, um das zu erhalten length:

Object.keys(myObject).length

Answer 11

In manchen Fällen ist es besser, die Größe einfach in einer separaten Variablen zu speichern.Vor allem, wenn Sie das Array um ein Element an einer Stelle erweitern und die Größe problemlos erhöhen können.Es würde natürlich viel schneller funktionieren, wenn Sie die Größe häufig überprüfen müssten.

Answer 12

Hier ist eine völlig andere Lösung, die nur in moderneren Browsern funktioniert (IE9+, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Sehen jsFiddle

Richten Sie Ihre Assoziative Array-Klasse ein

/**
 * @constructor
 */
AssociativeArray = function () {};

// Make the length property work
Object.defineProperty(AssociativeArray.prototype, "length", {
    get: function () {
        var count = 0;
        for (var key in this) {
            if (this.hasOwnProperty(key))
                count++;
        }
        return count;
    }
});

Jetzt können Sie diesen Code wie folgt verwenden ...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);

Answer 13

Verwenden:

var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
obj = Object.keys(myArray).length;
console.log(obj)

Answer 14

@palmsey:Um dem OP gerecht zu werden, beziehen sich die Javascript-Dokumente tatsächlich explizit auf die Verwendung von Variablen vom Typ Object auf diese Weise als „assoziative Arrays“.

Und um @palmsey gegenüber fair zu sein, hatte er völlig recht, es handelt sich nicht um assoziative Arrays, sondern definitiv um Objekte :) – die die Aufgabe eines assoziativen Arrays erfüllen.Aber was den weiteren Punkt angeht, scheinen Sie laut diesem ziemlich guten Artikel, den ich gefunden habe, definitiv Recht zu haben:

JavaScript-„Assoziative Arrays“ gelten als schädlich

Aber nach alledem ist das nicht der Fall akzeptierte Antwort selbst schlechte Praxis?

Geben Sie eine Prototyp-Size()-Funktion für Object an

Wenn dem Objekt .prototype noch etwas hinzugefügt wurde, schlägt der vorgeschlagene Code fehl:

<script type="text/javascript">
Object.prototype.size = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
Object.prototype.size2 = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
alert("age is " + myArray["age"]);
alert("length is " + myArray.size());
</script>

Ich denke nicht, dass diese Antwort akzeptiert werden sollte, da nicht darauf vertraut werden kann, dass sie funktioniert, wenn anderer Code im selben Ausführungskontext ausgeführt wird.Um dies auf robuste Weise zu tun, müssten Sie sicherlich die Größenmethode in myArray definieren und den Typ der Mitglieder überprüfen, während Sie sie durchlaufen.

Answer 15

Wie wäre es mit so etwas –

function keyValuePairs() {
    this.length = 0;
    function add(key, value) { this[key] = value; this.length++; }
    function remove(key) { if (this.hasOwnProperty(key)) { delete this[key]; this.length--; }}
}

Answer 16

Wenn wir den Hash haben

hash = {"a" :„b“, „c“:"D"};

Wir können die Länge mithilfe der Länge der Schlüssel ermitteln, die der Länge des Hashs entspricht:

Schlüssel(Hash).Länge

Answer 17

Wenn Sie verwenden AngularJS 1.x können Sie Dinge auf die AngularJS-Art erledigen, indem Sie einen Filter erstellen und den Code aus einem der anderen Beispiele verwenden, wie zum Beispiel dem folgenden:

// Count the elements in an object
app.filter('lengthOfObject', function() {
  return function( obj ) {
    var size = 0, key;
    for (key in obj) {
      if (obj.hasOwnProperty(key)) size++;
    }
   return size;
 }
})

Verwendung

In Ihrem Controller:

$scope.filterResult = $filter('lengthOfObject')($scope.object)

Oder aus Ihrer Sicht:

<any ng-expression="object | lengthOfObject"></any>

Answer 18

<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);
</script>

<p id="myObj">The number of <b>keys</b> in <b>myObj</b> are: <script>document.write(size)</script></p>

Das funktioniert bei mir:

var size = Object.keys(myObj).length;

Answer 19

Wenn Sie eine assoziative Datenstruktur benötigen, die ihre Größe offenlegt, verwenden Sie besser eine Karte anstelle eines Objekts.

var myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3

Answer 20

Eine Variation einiger der oben genannten ist:

var objLength = function(obj){    
    var key,len=0;
    for(key in obj){
        len += Number( obj.hasOwnProperty(key) );
    }
    return len;
};

Es ist eine etwas elegantere Möglichkeit, hasOwnProp zu integrieren.

Answer 21

Wenn Ihnen die Unterstützung von Internet Explorer 8 oder niedriger nicht wichtig ist, können Sie die Anzahl der Eigenschaften in einem Objekt ganz einfach ermitteln, indem Sie die folgenden zwei Schritte anwenden:

1. Führen Sie entweder aus Object.keys() um ein Array zu erhalten, das nur die Namen der Eigenschaften enthält, die vorhanden sind aufzählbar oder Object.getOwnPropertyNames() wenn Sie auch die Namen von Eigenschaften einbeziehen möchten, die nicht aufzählbar sind.
2. Bekommen das .length Eigenschaft dieses Arrays.

---

Wenn Sie dies mehr als einmal tun müssen, können Sie diese Logik in eine Funktion einbinden:

function size(obj, enumerablesOnly) {
    return enumerablesOnly === false ?
        Object.getOwnPropertyNames(obj).length :
        Object.keys(obj).length;
}

So verwenden Sie diese spezielle Funktion:

var myObj = Object.create({}, {
    getFoo: {},
    setFoo: {}
});
myObj.Foo = 12;

var myArr = [1,2,5,4,8,15];

console.log(size(myObj));        // Output : 1
console.log(size(myObj, true));  // Output : 1
console.log(size(myObj, false)); // Output : 3
console.log(size(myArr));        // Output : 6
console.log(size(myArr, true));  // Output : 6
console.log(size(myArr, false)); // Output : 7

Siehe auch diese Geige für eine Demo.

Answer 22

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

1. Object.values(myObject).length
2. Object.entries(myObject).length
3. Object.keys(myObject).length

Answer 23

Hier ist eine andere Version von James Cogans Antwort.Anstatt ein Argument zu übergeben, erstellen Sie einfach einen Prototyp der Object-Klasse und gestalten Sie den Code sauberer.

Object.prototype.size = function () {
    var size = 0,
        key;
    for (key in this) {
        if (this.hasOwnProperty(key)) size++;
    }
    return size;
};

var x = {
    one: 1,
    two: 2,
    three: 3
};

x.size() === 3;

jsfiddle-Beispiel: http://jsfiddle.net/qar4j/1/

Answer 24

Sie können es einfach verwenden Object.keys(obj).length auf ein beliebiges Objekt, um dessen Länge zu ermitteln.Object.keys gibt ein Array zurück, das das gesamte Objekt enthält Schlüssel (Eigenschaften), die nützlich sein können, um die Länge dieses Objekts mithilfe der Länge des entsprechenden Arrays zu ermitteln.Sie können sogar eine schreiben Funktion dafür.Lass uns ... Holen kreativ und schreibe ein Methode auch dafür (zusammen mit einer praktischeren Getter-Eigenschaft):

function objLength(obj)
{
  return Object.keys(obj).length;
}

console.log(objLength({a:1, b:"summit", c:"nonsense"}));

// Works perfectly fine
var obj = new Object();
obj['fish'] = 30;
obj['nullified content'] = null;
console.log(objLength(obj));

// It also works your way, which is creating it using the Object constructor
Object.prototype.getLength = function() {
   return Object.keys(this).length;
}
console.log(obj.getLength());

// You can also write it as a method, which is more efficient as done so above

Object.defineProperty(Object.prototype, "length", {get:function(){
    return Object.keys(this).length;
}});
console.log(obj.length);

// probably the most effictive approach is done so and demonstrated above which sets a getter property called "length" for objects which returns the equivalent value of getLength(this) or this.getLength()

Answer 25

Der einfachste Weg ist so

Object.keys(myobject).length

Dabei ist myobject das Objekt der gewünschten Länge

Answer 26

Das können Sie immer tun Object.getOwnPropertyNames(myObject).length um das gleiche Ergebnis zu erhalten wie [].length würde für normales Array geben.

Answer 27

Unten finden Sie eine Version von James Coglans Antwort in CoffeeScript für diejenigen, die reines JavaScript aufgegeben haben :)

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size

Answer 28

Eigentum

Object.defineProperty(Object.prototype, 'length', {
    get: function () {
        var size = 0, key;
        for (key in this)
            if (this.hasOwnProperty(key))
                size++;
        return size;
    }
});

Verwenden

var o = {a: 1, b: 2, c: 3};
alert(o.length); // <-- 3
o['foo'] = 123;
alert(o.length); // <-- 4

Answer 29

Wir können die Länge von Object ermitteln, indem wir Folgendes verwenden:

Object.values(myObject).length

Answer 30

Etwas spät im Spiel, aber eine gute Möglichkeit, dies zu erreichen (nur IE9+), besteht darin, einen Magic Getter für die Längeneigenschaft zu definieren:

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

Und Sie können es einfach so verwenden:

var myObj = { 'key': 'value' };
myObj.length;

Würde geben 1.