Länge eines JavaScript-Objekts

2384

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;
Gareth Simpson
quelle
15
Objektliterale in Javascript sind standardmäßig assoziative Arrays, z. B. object.propertyName.propertyValue ist dasselbe wie object [propertyName] [propertyValue]
neitony
6
In Underscore.js wurde ein Einzeiler
hinzugefügt
31
Sobald die Zeilenantwort lautet, verwenden Sie Object.keys (myArray) .length, wie @aeosynth sagte.
Ranadheer Reddy
67
ok, wie wäre esObject.keys(obj).length
Muhammad Umer
5
Warum ist object.length nicht gültig? Es gibt das richtige Ergebnis für mich zurück.
Adrian M

Antworten:

2623

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

quelle
65
@Tres - Ihr Code kann beschädigt werden, wenn jemand kommt und die Eigenschaft 'size' überschreibt, ohne zu wissen, dass Sie sie bereits irgendwo im Code deklariert haben. Es lohnt sich also immer zu überprüfen, ob sie bereits definiert ist
vsync
19
@vsync Du bist sehr korrekt. Man sollte immer die notwendigen Gesundheitsprüfungen durchführen :)
Tres
132
Warum ignorieren alle dies:Object.keys(obj).length
Muhammad Umer
33
@ MuhammadUmer Wahrscheinlich, weil diese Methode nicht einmal existierte, als diese Antwort geschrieben wurde. Noch heute wird für die Verwendung wahrscheinlich eine Polyfüllung für alte Browser erforderlich sein.
Chris Hayes
21
@stonyau IE8, IE9, IE10 sind tote Browser, die von Microsoft nicht unterstützt werden. Benutzer von IE8, IE9, IE10 erhalten von Microsoft eine Benachrichtigung, dass sie einen alten, nicht unterstützten Browser verwenden und erwarten sollten, dass diese für sie nicht funktionieren. support.microsoft.com/en-us/kb/3123303
Lukas Liesis
1706

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

Object.keys(myArray).length
aeosynth
quelle
23
warum nicht?
Soweit
104
Es ist keine universell implementierte Methode, aber Sie können mit dieser Tabelle überprüfen, welcher Browser sie unterstützt .
Aeosynth
51
Keine IE8-Unterstützung = kein Los.
Ripper234
22
Zeit für einen Wechsel zu Firefox = Leider bedeutet ein Wechsel nicht, dass die Benutzer Ihrer Website ...
mdup
82
@ Ripper234 keine IE-Unterstützung = Zeit zum Polyfill
John Dvorak
287

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;
};
ripper234
quelle
7
_.size()war die perfekte Lösung für mein Meteor- Projekt, das von underscore.j unterstützt wird.
tokyovariable
4
Ich benutze Unterstrich und dieser Beitrag hat mich nur daran erinnert, dass ich ihn in diesem Projekt nicht genug benutze. Wenn Sie mit Objekten umgehen, sollte underscore.js verfügbar sein.
Jbolanos
3
Unterstrich> (alle - ['lo-dash'])
Rayjax
Unterstriche, Dinge, die unter js sein sollten :)
Minhajul
1
@Babydead, um reale Eigenschaften des Objekts von geerbten zu unterscheiden. developer.mozilla.org/en/docs/Web/JavaScript/Reference/…
ripper234
56

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;
Joon
quelle
6
Object.keys()Gibt ein Array zurück, das nur die Namen der aufzählbaren Eigenschaften enthält. Wenn Sie ein Array mit ALLEN Eigenschaften möchten, sollten Sie Object.getOwnPropertyNames()stattdessen verwenden. Siehe developer.mozilla.org/en/docs/Web/JavaScript/Reference/…
John Slegers
35

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".

jj33
quelle
8
Funktioniert nicht, da auch Methoden gezählt werden, die über den Prototyp hinzugefügt werden.
Lajos Meszaros
30

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
venkat7668
quelle
Die @PatrickRoberts-Schlüsselmethode gibt keine Eigenschaften aus der Prototypenkette zurück. Warum also hier hasOwnProperty? Auch getOwnProperty gibt versteckte Eigenschaften zurück, da die Länge im Array usw. ist.
Muhammad Umer
24

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

DanMan
quelle
Ich denke, dies ist die beste Lösung, da keine Schleife mit 'for' erforderlich ist, was teuer sein kann, wenn das Array groß ist
Emeka Mbah
20

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++;
Doekman
quelle
20

Verwenden Sie dies einfach, um Folgendes zu erhalten length:

Object.keys(myObject).length
saurabhgoyal795
quelle
7
Bitte erklären Sie, wie sich Ihre Antwort von stackoverflow.com/a/6700/8632727
Patata
3
Sie sollten Ihr Objekt auch nicht wirklich benennenmyArray
Barry Michael Doyle
2
@ BarryMichaelDoyle Ich habe das geändert :)
saurabhgoyal795
Gut, es ist immer besser, Ihre Variablen so zu benennen, wie sie tatsächlich sind. Macht Ihren Code für andere Entwickler besser lesbar.
Barry Michael Doyle
4
Vor der Bearbeitung von "myArray" -> "myObject" war dies identisch mit der zweithöchsten Antwort.
Yunnosch
16

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);
Verbündete
quelle
Ich denke das ist nicht sicher. Zum Beispiel kann es kein Element mit dem Schlüssel "Länge" haben, die Anweisung a1 ["Länge"] = "Hallo Welt"; Der Eintrag kann nicht gespeichert werden. Auch die Anweisung a1 ["hasOwnProperty"] = "some prop"; total bricht die Funktion
Panos Theof
3
@PanosTheof Ich glaube nicht, dass Sie möchten, dass der Wert gespeichert wird, wenn Sie die lengthEigenschaft verwenden. Jeder Code, der sie verwendet, muss sicherstellen, dass nicht versucht wird, sie zu speichern length, aber ich denke, das wäre dasselbe, wenn dies der Fall wäre ein Standard-Array auch. Das Überschreiben hasOwnPropertyeines Objekts würde höchstwahrscheinlich zu einem unerwünschten Ergebnis führen.
Verbündeter
16

<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;
Giovanni G. PY
quelle
15

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.

Jānis Elmeris
quelle
15

Verwenden:

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

Mahendra Kulkarni
quelle
14

@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.

Polsonby
quelle
13

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
Oriol
quelle
11

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--; }}
}
Jerry
quelle
11

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

abo-elleef
quelle
2
Dies ist eine großartige Antwort, ich kann jedoch keine Dokumentation für diese Tastenfunktion finden. Daher kann ich mich nicht auf die Cross-Browser-Unterstützung verlassen.
Chim
1
Leider ist dies keine so gute Antwort, wie ich zuerst dachte! Es stellt sich heraus, dass die Tastenfunktion nur in den Chrome- und Firefox-Webkonsolen verfügbar ist. Wenn Sie diesen Code in ein Skript einfügen, schlägt er mit Uncaught ReferenceError fehl: Die Schlüssel sind nicht definiert
Chim
1
Wie unterscheidet sich das von Aeosynths Antwort ?
Peter Mortensen
11
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
tdjprog
quelle
Welches ist schneller unter den oben genannten 3.
Siluveru Kiran Kumar
Object.values ​​(myObject) .length
tdjprog
Wie können wir sagen, dass es Object.values ​​(myObject) .length ist schneller gibt es ein Beispiel Danke, @tdjprog
Siluveru Kiran Kumar
Versuchen Sie dies einfach in der Konsole:var myObject = {}; for (let i=0; i<10000000; i++) myObject[i] = i;
tdjprog
warum Object.values ​​(myObject) .length schneller, wo Object.entries (myObject) .length auch nach einiger Zeit keine Ausgabe geben, was ist der Grund hier? Danke @tdjprog
siluveru kiran kumar
10

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>
pcnate
quelle
4
Das OP hat nicht nach einer AngularJS-Version gefragt. Dies ist keine gültige Antwort auf die Frage.
Francisco Hodge
10

Der einfachste Weg ist so

Object.keys(myobject).length

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

Mithu Ein Kai
quelle
2
Dies scheint nur eine Wiederholung dieser bestehenden Antwort zu sein .
Pang
@Pang stimmte zu und bietet keinen weiteren Kontext wie andere Antworten.
Mystischer
8

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.

John Slegers
quelle
8

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
shaheb
quelle
8
const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

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

// o/p 3
Dev216
quelle
7

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.

Wade Harrell
quelle
6

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/

Sherzod
quelle
6
Object.prototype- schlechte Idee.
Dziad Borowy
@tborychowski kannst du bitte erklären warum?
Mohamad
Hier ist ein Artikel: bit.ly/1droWrG . Ich sage nicht, dass es nicht getan werden darf, nur dass Sie alle Auswirkungen kennen müssen, bevor Sie dies tun.
Dziad Borowy
Wenn Sie integrierte Prototypen erweitern oder eine Eigenschaft (z. B. Affen-Patch) mehrfach ausfüllen möchten, gehen Sie bitte korrekt vor: Überprüfen Sie aus Gründen der Vorwärtskompatibilität, ob die Eigenschaft zuerst vorhanden ist, und machen Sie die Eigenschaft dann nicht aufzählbar, sodass die eigenen Schlüssel vorhanden sind von konstruierten Objekten werden nicht verschmutzt. Verwenden Sie für Methoden tatsächliche Methoden . Meine Empfehlung: Befolgen Sie diese Beispiele, die zeigen, wie Sie eine Methode hinzufügen, die sich so genau wie möglich wie integrierte Methoden verhält.
user4642212
5

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()

Mystisch
quelle
3
Wie unterscheidet sich das von Aeosynths Antwort ?
Peter Mortensen
Dies liegt daran, dass gezeigt wird, wie es als Funktion und globale Objektmethode erstellt wird (objektorientierter und in Form einer Kapselung). jedoch aeosynth Antwort nicht.
Mystischer
Wenn Sie integrierte Prototypen erweitern oder eine Eigenschaft (z. B. Affen-Patch) mehrfach ausfüllen möchten, gehen Sie bitte korrekt vor: Überprüfen Sie aus Gründen der Vorwärtskompatibilität, ob die Eigenschaft zuerst vorhanden ist, und machen Sie die Eigenschaft dann nicht aufzählbar, sodass die eigenen Schlüssel vorhanden sind von konstruierten Objekten werden nicht verschmutzt. Verwenden Sie für Methoden tatsächliche Methoden . Meine Empfehlung: Befolgen Sie diese Beispiele, die zeigen, wie Sie eine Methode hinzufügen, die sich so genau wie möglich wie integrierte Methoden verhält.
user4642212
Wie ist das Schreiben einer Methode „effizienter“?
user4642212
5

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

Pian0_M4n
quelle
1
Object.keys()Gibt ein Array zurück, das nur die Namen der aufzählbaren Eigenschaften enthält. Wenn Sie ein Array mit ALLEN Eigenschaften möchten, sollten Sie Object.getOwnPropertyNames()stattdessen verwenden. Siehe developer.mozilla.org/en/docs/Web/JavaScript/Reference/…
John Slegers
3
Wie unterscheidet sich das von Aeosynths Antwort ?
Peter Mortensen
4

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

Object.values(myObject).length
Solanki ...
quelle
4

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.

MacroMan
quelle
1
Abgesehen von den Argumenten gegen die Änderung von Prototypen hatte ich persönlich NIE einen Fehler, der dadurch verursacht wurde, und ist für mich eine der Stärken von JavaScript.
MacroMan
3

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
Eric Anderson
quelle
1
Sie wollten wahrscheinlich sagen size++ for own key of obj( own keySyntaxzucker in CoffeeScript). Die Verwendung hasOwnPropertydirekt vom Objekt aus ist gefährlich, da sie unterbrochen wird, wenn das Objekt tatsächlich über eine solche Eigenschaft verfügt.
Konrad Borowski
2
Das OP hat weder nach einer CoffeeScript-Version gefragt, noch ist es als solche gekennzeichnet. Dies ist keine gültige Antwort auf die Frage.
Francisco Hodge