Vraag Lengte van een JavaScript-object


Als ik bijvoorbeeld een JavaScript-object heb

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

is er een ingebouwde of geaccepteerde methode om de lengte van dit object te krijgen?


1820
2017-08-07 19:42


oorsprong


antwoorden:


Het meest robuuste antwoord (dat wil zeggen dat de intentie vaststelt van wat u probeert te doen terwijl het de minste bugs veroorzaakt) zou zijn:

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

Er is een soort conventie in JavaScript die jij bent voeg geen dingen toe aan Object.prototype, omdat het opsommingen in verschillende bibliotheken kan doorbreken. Methoden toevoegen aan Object is echter meestal veilig.


Hier is een update vanaf 2016 en wijdverspreide inzet van ES5 en verder.  Voor IE9 + en alle andere moderne ES5 + geschikte browsers, kunt u gebruiken Object.keys() dus de bovenstaande code wordt gewoon:

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

Dit hoeft sindsdien geen bestaand prototype te wijzigen Object.keys() is nu ingebouwd

Bewerk: Objecten kunnen symbolische eigenschappen hebben die niet kunnen worden geretourneerd via de Object.key-methode. Het antwoord zou dus onvolledig zijn zonder ze te vermelden.

Symbooltype is aan de taal toegevoegd om unieke id's voor objecteigenschappen te maken. Het belangrijkste voordeel van het symbooltype is voorkomen van overschrijvingen.

Object.keys of Object.getOwnPropertyNames werkt niet voor symbolische eigenschappen. Om ze terug te sturen, moet je gebruiken 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

2011
2017-08-09 08:31



Als je weet dat je je daar geen zorgen over hoeft te maken hasOwnProperty controles, u kunt dit heel eenvoudig doen:

Object.keys(myArray).length

1407
2018-04-03 01:44



bijgewerkt: Als je gebruikt Underscore.js (aanbevolen, het is lichtgewicht!), dan kun je het gewoon doen

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

Als niet, en je wilt niet rommelen met Object-eigenschappen om welke reden dan ook, en je gebruikt al jQuery, een plug-in is even toegankelijk:

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

252
2017-07-05 14:39



Gebruik zoiets eenvoudigs als:

Object.keys(obj).length

Het hoeft niet moeilijk te zijn en heeft absoluut geen andere functie nodig om te volbrengen.


153
2017-10-27 03:46



Dit is de meest cross-browseroplossing.

Dit is beter dan het geaccepteerde antwoord omdat het native Object.keys gebruikt als deze bestaat. Het is dus de snelste voor alle moderne browsers.

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;

43
2017-09-01 16:12



Ik ben geen JavaScript-expert, maar het lijkt erop dat u de elementen moet doorlopen en ze moet tellen, omdat Object geen lengtemethode heeft:

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

@palmsey: eerlijk gezegd naar het OP verwijst de JavaScript-documentatie eigenlijk expliciet naar het gebruik van variabelen van het type Object op deze manier als "associatieve matrices".


27
2017-08-07 19:52



Met deze methode worden alle objectnamen van objecten in een array opgehaald, zodat u de lengte van die array kunt ophalen die gelijk is aan de lengte van uw objectsleutel.

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

25
2017-07-01 12:40



Om niet te rotzooien met het prototype of andere code, zou je je eigen object kunnen bouwen en uitbreiden:

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

Als u altijd de methode toevoegen gebruikt, is de eigenschap length correct. Als u bang bent dat u of anderen het niet zullen gebruiken, kunt u de eigententeller die de anderen ook op de lengtemethode hebben geplaatst, toevoegen.

Natuurlijk kunt u de methoden altijd overschrijven. Maar zelfs als u dat doet, zal uw code waarschijnlijk merkbaar falen, waardoor het gemakkelijk is om te debuggen. ;)


19
2018-06-11 15:44



Hier is hoe en vergeet niet om te controleren of de woning niet in de prototypeketen zit:

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

14
2017-08-08 19:18



Hier is een heel andere oplossing die alleen in modernere browsers werkt (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Zien jsFiddle

Stel uw Associative Array-klasse in

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

U kunt deze code nu als volgt gebruiken ...

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

13
2017-08-02 08:49



In sommige gevallen is het beter om de grootte in een afzonderlijke variabele op te slaan. Vooral als u met één element op één plaats aan de array toevoegt en de grootte eenvoudig kunt verhogen. Het zou natuurlijk veel sneller werken als je de grootte vaak moet controleren.


12
2017-07-29 13:41