Domanda Lunghezza di un oggetto JavaScript


Se ho un oggetto JavaScript, ad esempio

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

esiste un modo migliore o predefinito per ottenere la lunghezza di questo oggetto?


1819
2017-08-07 19:42


origine


risposte:


La risposta più efficace (ovvero quella che cattura l'intento di ciò che stai cercando di fare mentre causa il minor numero di bug) sarebbe:

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

C'è una specie di convenzione in JavaScript che tu non aggiungere cose a Object.prototype, perché può rompere le enumerazioni in varie librerie. L'aggiunta di metodi a Object è di solito sicura, però.


Ecco un aggiornamento a partire dal 2016 e diffusione diffusa di ES5 e oltre.  Per IE9 + e tutti gli altri browser moderni compatibili con ES5 +, puoi utilizzare Object.keys() quindi il codice sopra diventa semplicemente:

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

Questo non deve modificare alcun prototipo esistente da allora Object.keys() è ora integrato

modificare: Gli oggetti possono avere proprietà simboliche che non possono essere restituite tramite il metodo Object.key. Quindi la risposta sarebbe incompleta senza menzionarli.

Il tipo di simbolo è stato aggiunto alla lingua per creare identificatori univoci per le proprietà dell'oggetto. Il principale vantaggio del tipo di simbolo è la prevenzione delle sovrascritture.

Object.keys o Object.getOwnPropertyNames non funziona per le proprietà simboliche. Per restituirli è necessario utilizzare 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



Se sai che non devi preoccuparti hasOwnProperty controlli, puoi farlo molto semplicemente:

Object.keys(myArray).length

1406
2018-04-03 01:44



aggiornato: Se stai usando Underscore.js (consigliato, è leggero!), quindi puoi farlo

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

Altrimenti, e non vuoi scherzare con le proprietà dell'oggetto per qualsiasi motivo, e stai già usando jQuery, un plugin è ugualmente accessibile:

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



Usa qualcosa di semplice come:

Object.keys(obj).length

Non deve essere difficile e sicuramente non richiede un'altra funzione da realizzare.


153
2017-10-27 03:46



Ecco la soluzione più cross-browser.

Questo è migliore della risposta accettata perché usa Object.keys nativi se esiste. Quindi, è il più veloce per tutti i browser moderni.

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



Non sono un esperto di JavaScript, ma sembra che tu debba scorrere gli elementi e contarli poiché Object non ha un metodo di lunghezza:

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

@palmsey: In tutta onestà all'OP, la documentazione JavaScript in realtà si riferisce esplicitamente all'utilizzo di variabili di tipo Object in questo modo come "array associativi".


27
2017-08-07 19:52



Questo metodo ottiene tutti i nomi delle proprietà dell'oggetto in una matrice, in modo da ottenere la lunghezza di tale array che è uguale alla lunghezza delle chiavi dell'oggetto.

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

25
2017-07-01 12:40



Per non rovinare il prototipo o altro codice, potresti costruire ed estendere il tuo oggetto:

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

Se si utilizza sempre il metodo add, la proprietà length sarà corretta. Se sei preoccupato che tu o altri non ti serva, puoi aggiungere anche il contatore di proprietà che gli altri hanno pubblicato sul metodo di lunghezza.

Certo, potresti sempre sovrascrivere i metodi. Ma anche se lo fai, il tuo codice probabilmente fallirà notevolmente, rendendo più facile il debug. ;)


19
2018-06-11 15:44