Länge eines JavaScript-Objekts

Ich habe ein JavaScript-Objekt. Gibt es eine integrierte oder akzeptierte Best-Practice-Methode, um die Länge dieses Objekts zu ermitteln?

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

Die robusteste Antwort (dh sie erfasst die Absicht dessen, was Sie versuchen, während Sie die wenigsten Fehler verursachen) 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, nach der Sie Object.prototype keine Elemente hinzufügen , da dadurch Aufzählungen in verschiedenen Bibliotheken unterbrochen werden können. Das Hinzufügen von Methoden zu Object ist jedoch normalerweise sicher.

Hier ist ein Update ab 2016 und eine weit verbreitete Bereitstellung von ES5 und darüber hinaus. Für IE9 + und alle anderen modernen ES5 + -fähigen Browser können Sie Folgendes verwenden: Object.keys()Der obige Code lautet wie folgt :

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

Dies muss keinen vorhandenen Prototyp ändern, da dieser Object.keys()jetzt eingebaut ist.

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 ist die Verhinderung von Überschreibungen.

Object.keysoder Object.getOwnPropertyNamesfunktioniert 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

Wenn Sie wissen, dass Sie sich nicht um hasOwnPropertySchecks kümmern müssen , können Sie dies ganz einfach tun:

Object.keys(myArray).length

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

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

Wenn nicht und Sie aus irgendeinem Grund nicht mit den Objekteigenschaften herumspielen möchten und bereits jQuery verwenden, ist ein Plugin gleichermaßen verfügbar:

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

Hier ist die browserübergreifendste Lösung.

Dies ist besser als die akzeptierte Antwort, da native Object.keys verwendet werden, falls 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;

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: Aus Gründen der Fairness gegenüber dem OP bezieht sich die JavaScript-Dokumentation explizit auf die Verwendung von Variablen vom Typ Object auf diese Weise als "assoziative Arrays".

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

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

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 Methode add verwenden, ist die Eigenschaft length korrekt. Wenn Sie befürchten, dass Sie oder andere die Verwendung vergessen, können Sie den Eigenschaftszähler, den die anderen zur Längenmethode gepostet haben, ebenfalls hinzufügen.

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

So 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++;

Verwenden Sie dies einfach, um Folgendes zu erhalten length:

Object.keys(myObject).length

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

Siehe 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);

<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;

In einigen Fällen ist es besser, die Größe einfach in einer separaten Variablen zu speichern. Insbesondere, wenn Sie dem Array ein Element an einer Stelle hinzufügen und die Größe leicht erhöhen können. Es würde natürlich viel schneller funktionieren, wenn Sie die Größe häufig überprüfen müssen.

Verwenden:

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

@palmsey: Aus Fairness gegenüber dem OP beziehen sich die Javascript-Dokumente explizit auf die Verwendung von Variablen vom Typ Object auf diese Weise als "assoziative Arrays".

Und fairerweise zu @palmsey war er ganz richtig, sie sind keine assoziativen Arrays, sie sind definitiv Objekte :) - sie erledigen die Arbeit eines assoziativen Arrays. Aber was den weiteren Punkt betrifft, so scheinen Sie nach diesem ziemlich guten Artikel, den ich gefunden habe, definitiv das Recht darauf zu haben:

JavaScript "Assoziative Arrays" als schädlich eingestuft

Aber ist die akzeptierte Antwort nach alledem nicht selbst eine schlechte Praxis?

Geben Sie eine Prototype size () -Funktion für Object an

Wenn dem Objektprototyp 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 die akzeptierte sein sollte, da man nicht darauf vertrauen kann, dass sie funktioniert, wenn ein 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.

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

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

Was ist 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--; }}
}

Wenn wir den Hash haben

Hash = {"a": "b", "c": "d"};

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

Schlüssel (Hash). Länge

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

Wenn Sie AngularJS 1.x verwenden, können Sie die Dinge auf AngularJS-Weise ausführen, indem Sie einen Filter erstellen und den Code aus einem der anderen Beispiele wie dem folgenden verwenden:

// 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;
 }
})

Verwendungszweck

In Ihrem Controller:

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

Oder aus Ihrer Sicht:

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

Der einfachste Weg ist so

Object.keys(myobject).length

wobei myobject das Objekt dessen ist, was Sie die Länge wollen

Wenn Sie Internet Explorer 8 oder niedriger nicht unterstützen möchten, können Sie die Anzahl der Eigenschaften in einem Objekt leicht ermitteln, indem Sie die folgenden zwei Schritte ausführen:

1. Führen Sie entweder aus Object.keys(), um ein Array abzurufen, das nur die Namen der aufzählbaren Eigenschaften enthält, oder Object.getOwnPropertyNames()wenn Sie auch die Namen der nicht aufzählbaren Eigenschaften einschließen möchten.
2. Holen Sie sich die .lengthEigenschaft dieses Arrays.

Wenn Sie dies mehrmals tun müssen, können Sie diese Logik in eine Funktion einschließen:

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.

Verwenden Sie Object.keys(myObject).lengthdiese Option , um die Länge des Objekts / Arrays abzurufen

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

console.log(Object.keys(myObject).length); //3

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

console.log(Object.keys(myObject).length)

// o/p 3

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 etwas eleganter, hasOwnProp zu integrieren.

Hier ist eine andere Version von James Cogans Antwort. Anstatt ein Argument zu übergeben, erstellen Sie einfach einen Prototyp der Object-Klasse und machen 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/

Sie können einfach Object.keys(obj).lengthjedes Objekt verwenden, um seine Länge zu ermitteln. Object.keys kehrt ein Array alle Objekt enthaltenden Schlüssel (Eigenschaften) , die für die Suche nach der Länge des Objekts kann sich als nützlich , die Länge des entsprechenden Array verwendet wird . Sie können sogar eine Funktion dafür schreiben . Lassen Sie uns kreativ werden und auch eine Methode dafür schreiben (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()

Sie können immer Object.getOwnPropertyNames(myObject).lengthdas gleiche Ergebnis [].lengtherzielen, das für ein normales Array erzielt wird.

Wir können die Länge des Objekts ermitteln, indem wir Folgendes verwenden:

Object.values(myObject).length

Ein bisschen spät zum Spiel, aber eine gute Möglichkeit, dies zu erreichen (nur IE9 +), besteht darin, einen magischen 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.

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

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