Come contare in modo efficiente il numero di chiavi / proprietà di un oggetto in JavaScript?

Qual è il modo più veloce per contare il numero di chiavi / proprietà di un oggetto? È possibile farlo senza iterare sull'oggetto? cioè senza farlo

var count = 0;
for (k in myobj) if (myobj.hasOwnProperty(k)) count++;

(Firefox ha fornito una __count__proprietà magica , ma questa è stata rimossa da qualche parte intorno alla versione 4.)

Per fare ciò in qualsiasi ambiente compatibile con ES5 , come Node , Chrome, IE 9+, Firefox 4+ o Safari 5+:

Object.keys(obj).length

• Compatibilità del browser
• Documentazione Object.keys (include un metodo che è possibile aggiungere a browser non ES5)

Puoi usare questo codice:

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

Quindi puoi usarlo anche nei browser più vecchi:

var len = Object.keys(obj).length;

Se stai usando Underscore.js puoi usare _.size (grazie @douwe):
_.size(obj)

In alternativa puoi anche usare _.keys che potrebbe essere più chiaro per alcuni:
_.keys(obj).length

Consiglio vivamente Underscore, è una libreria ristretta per fare molte cose di base. Ove possibile, corrispondono a ECMA5 e rimandano all'implementazione nativa.

Altrimenti sostengo la risposta di @ Avi. L'ho modificato per aggiungere un collegamento al documento MDC che include il metodo keys () che è possibile aggiungere ai browser non ECMA5.

L'implementazione standard degli oggetti ( proprietà e metodi interni agli oggetti ES5.1 ) non richiede Objectdi tenere traccia del numero di chiavi / proprietà, quindi non dovrebbe esserci un modo standard per determinare la dimensione di un Objectsenza iterare esplicitamente o implicitamente sulle sue chiavi.

Ecco quindi le alternative più comunemente utilizzate:

1. Object.keys () di ECMAScript

Object.keys(obj).length;Funziona ripetendo internamente le chiavi per calcolare un array temporaneo e restituirne la lunghezza.

• Pro : sintassi leggibile e pulita. Nessuna libreria o codice personalizzato richiesto tranne uno spessore se il supporto nativo non è disponibile
• Contro : sovraccarico di memoria dovuto alla creazione dell'array.

2. Soluzioni basate su libreria

Molti esempi basati su librerie altrove in questo argomento sono utili modi di dire nel contesto della loro biblioteca. Da un punto di vista delle prestazioni, tuttavia, non c'è nulla da guadagnare rispetto a un perfetto codice no-library poiché tutti quei metodi di libreria effettivamente incapsulano un for-loop o ES5 Object.keys(nativo o shimmed).

3. Ottimizzazione di un ciclo continuo

La parte più lenta di tale for-loop è generalmente la .hasOwnProperty()chiamata, a causa dell'overhead della chiamata di funzione. Quindi, quando voglio solo il numero di voci di un oggetto JSON, salto semplicemente la .hasOwnProperty()chiamata se so che nessun codice ha funzionato né si estenderà Object.prototype.

Altrimenti, il tuo codice potrebbe essere leggermente ottimizzato creando klocal ( var k) e usando l'operatore prefix-increment ( ++count) invece di postfix.

var count = 0;
for (var k in myobj) if (myobj.hasOwnProperty(k)) ++count;

Un'altra idea si basa sulla memorizzazione nella cache del hasOwnPropertymetodo:

var hasOwn = Object.prototype.hasOwnProperty;
var count = 0;
for (var k in myobj) if (hasOwn.call(myobj, k)) ++count;

Se questo è più veloce o meno in un determinato ambiente è una questione di benchmarking. Ci si può aspettare comunque un rendimento molto limitato.

Se stai effettivamente riscontrando un problema di prestazioni, suggerirei di racchiudere le chiamate che aggiungono / rimuovono le proprietà a / dall'oggetto con una funzione che incrementa / decrementa anche una proprietà (size?) Appropriatamente denominata.

Devi solo calcolare il numero iniziale di proprietà una volta e passare da lì. Se non c'è un vero problema di prestazioni, non preoccuparti. Basta racchiudere quel pezzetto di codice in una funzione getNumberOfProperties(object)e terminare.

Come affermato da Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

farà il trucco per tutte le proprietà enumerabili sul tuo oggetto ma per includere anche le proprietà non enumerabili che puoi invece usare Object.getOwnPropertyNames. Ecco la differenza:

var myObject = new Object();

Object.defineProperty(myObject, "nonEnumerableProp", {
  enumerable: false
});
Object.defineProperty(myObject, "enumerableProp", {
  enumerable: true
});

console.log(Object.getOwnPropertyNames(myObject).length); //outputs 2
console.log(Object.keys(myObject).length); //outputs 1

console.log(myObject.hasOwnProperty("nonEnumerableProp")); //outputs true
console.log(myObject.hasOwnProperty("enumerableProp")); //outputs true

console.log("nonEnumerableProp" in myObject); //outputs true
console.log("enumerableProp" in myObject); //outputs true

Come indicato qui, questo ha lo stesso supporto del browser diObject.keys

Tuttavia, nella maggior parte dei casi, potresti non voler includere gli elementi non numerabili in questo tipo di operazioni, ma è sempre utile conoscere la differenza;)

Non sono a conoscenza di alcun modo per farlo, tuttavia per mantenere le iterazioni al minimo, potresti provare a verificare l'esistenza di __count__e se non esiste (cioè non Firefox), puoi iterare l'oggetto e definire per un uso successivo, ad esempio:

if (myobj.__count__ === undefined) {
  myobj.__count__ = ...
}

In questo modo qualsiasi browser che supporti __count__lo userebbe e le iterazioni verrebbero eseguite solo per quelli che non lo fanno. Se il conteggio cambia e non puoi farlo, puoi sempre renderlo una funzione:

if (myobj.__count__ === undefined) {
  myobj.__count__ = function() { return ... }
  myobj.__count__.toString = function() { return this(); }
}

In questo modo ogni volta che fai riferimento a myobj. __count__la funzione verrà attivata e ricalcolata.

Per iterare su Avi Flax, rispondere Object.keys (obj) .length è corretto per un oggetto che non ha funzioni legate ad esso

esempio:

obj = {"lol": "what", owo: "pfft"};
Object.keys(obj).length; // should be 2

contro

arr = [];
obj = {"lol": "what", owo: "pfft"};
obj.omg = function(){
    _.each(obj, function(a){
        arr.push(a);
    });
};
Object.keys(obj).length; // should be 3 because it looks like this 
/* obj === {"lol": "what", owo: "pfft", omg: function(){_.each(obj, function(a){arr.push(a);});}} */

passi per evitarlo:

1. non inserire funzioni in un oggetto in cui si desidera contare il numero di chiavi

2. usa un oggetto separato o crea un nuovo oggetto appositamente per le funzioni (se vuoi contare quante funzioni ci sono nel file usando Object.keys(obj).length)

anche sì, nel mio esempio ho usato il modulo _ o underscore di nodejs

la documentazione è disponibile qui http://underscorejs.org/ nonché la sua fonte su github e varie altre informazioni

E infine un'implementazione lodash https://lodash.com/docs#size

_.size(obj)

come risposto sopra: Object.keys(obj).length

Ma: dato che ora abbiamo una vera classe Map in ES6, suggerirei di usarla invece di usare le proprietà di un oggetto.

const map = new Map();
map.set("key", "value");
map.size; // THE fastest way

Per coloro che hanno Underscore.js incluso nel loro progetto puoi fare:

_({a:'', b:''}).size() // => 2

o stile funzionale:

_.size({a:'', b:''}) // => 2

Ecco alcuni test delle prestazioni per tre metodi;

https://jsperf.com/get-the-number-of-keys-in-an-object

Object.keys (). Length

20.735 operazioni al secondo

Molto semplice e compatibile Funziona veloce ma costoso perché crea un nuovo array di chiavi, che poi viene buttato via.

return Object.keys(objectToRead).length;

scorrere tra i tasti

15.734 operazioni al secondo

let size=0;
for(let k in objectToRead) {
  size++
}
return size;

Leggermente più lento, ma in nessun luogo vicino all'utilizzo della memoria, quindi probabilmente meglio se sei interessato a ottimizzare per dispositivi mobili o altri piccoli computer

Usando Mappa invece di Oggetto

953.839.338 operazioni al secondo

return mapToRead.size;

Fondamentalmente, Mappa tiene traccia delle sue dimensioni, quindi stiamo solo restituendo un campo numerico. Molto, molto più veloce di qualsiasi altro metodo. Se hai il controllo dell'oggetto, convertili invece in mappe.

Da: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

Object.defineProperty (oggetto, oggetto, descrittore)

Puoi aggiungerlo a tutti i tuoi oggetti:

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

O un singolo oggetto:

var myObj = {};
Object.defineProperty(myObj, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

Esempio:

var myObj = {};
myObj.name  = "John Doe";
myObj.email = "leaked@example.com";
myObj.length; //output: 2

Aggiunto in questo modo, non verrà visualizzato in for..in loop:

for(var i in myObj) {
     console.log(i + ":" + myObj[i]);
}

Produzione:

name:John Doe
email:leaked@example.com

Nota: non funziona nei browser <IE9.

Come ho risolto questo problema è costruire la mia implementazione di un elenco di base che tiene traccia di quanti elementi sono memorizzati nell'oggetto. È molto semplice. Qualcosa come questo:

function BasicList()
{
   var items = {};
   this.count = 0;

   this.add = function(index, item)
   {
      items[index] = item;
      this.count++;
   }

   this.remove = function (index)
   {
      delete items[index];
      this.count--;
   }

   this.get = function(index)
   {
      if (undefined === index)
        return items;
      else
        return items[index];
   }
}

È possibile utilizzare Object.keys(data).lengthper trovare la lunghezza dell'oggetto JSON con dati chiave

Per quelli che hanno Ext JS 4 nel loro progetto puoi fare:

Ext.Object.getSize(myobj);

Il vantaggio di questo è che funzionerà su tutti i browser compatibili con Ext (IE6-IE8 incluso), tuttavia, credo che il tempo di esecuzione non sia migliore di O (n), tuttavia, come con altre soluzioni suggerite.

Puoi usare:

Object.keys(objectName).length; 

e

Object.values(objectName).length;

OP non ha specificato se l'oggetto è un nodeList, in tal caso è possibile utilizzare direttamente il metodo length . Esempio:

buttons = document.querySelectorAll('[id=button)) {
console.log('Found ' + buttons.length + ' on the screen'); 

Se jQuery sopra non funziona, quindi provare

$(Object.Item).length

Non credo sia possibile (almeno non senza usare alcuni interni). E non penso che guadagneresti molto ottimizzando questo.

Provo a renderlo disponibile a tutti gli oggetti in questo modo:

Object.defineProperty(Object.prototype, "length", {
get() {
    if (!Object.keys) {
        Object.keys = function (obj) {
            var keys = [],k;
            for (k in obj) {
                if (Object.prototype.hasOwnProperty.call(obj, k)) {
                    keys.push(k);
                }
            }
            return keys;
        };
    }
    return Object.keys(this).length;
},});

console.log({"Name":"Joe","Age":26}.length) //returns 2

Google Closure ha una bella funzione per questo ... goog.object.getCount (obj)

guarda goog.Object Documentation