¿Cómo contar eficientemente el número de claves / propiedades de un objeto en JavaScript?

¿Cuál es la forma más rápida de contar el número de claves / propiedades de un objeto? ¿Es posible hacer esto sin iterar sobre el objeto? es decir, sin hacer

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

(Firefox proporcionó una __count__propiedad mágica , pero esta se eliminó en algún lugar alrededor de la versión 4.)

Para hacer esto en cualquier entorno compatible con ES5 , como Node , Chrome, IE 9+, Firefox 4+ o Safari 5+:

Object.keys(obj).length

• Compatibilidad del navegador
• Documentación de Object.keys (incluye un método que puede agregar a navegadores que no son ES5)

Podrías usar este código:

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

Entonces puede usar esto también en navegadores antiguos:

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

Si está utilizando Underscore.js puede usar _.size (gracias @douwe):
_.size(obj)

Alternativamente, también puede usar _.keys que podrían ser más claros para algunos:
_.keys(obj).length

Recomiendo mucho Underscore, es una biblioteca compacta para hacer muchas cosas básicas. Siempre que sea posible, coinciden con ECMA5 y difieren de la implementación nativa.

De lo contrario, apoyo la respuesta de @ Avi. Lo edité para agregar un enlace al documento de MDC que incluye el método de claves () que puede agregar a los navegadores que no son ECMA5.

La implementación estándar de objetos ( Propiedades y métodos internos de objetos ES5.1 ) no requiere un Objectseguimiento de su número de claves / propiedades, por lo que no debe haber una forma estándar de determinar el tamaño de un Objectsin iterar explícita o implícitamente sobre sus claves.

Aquí están las alternativas más utilizadas:

1. Object.keys de ECMAScript ()

Object.keys(obj).length;Funciona iterando internamente sobre las teclas para calcular una matriz temporal y devuelve su longitud.

• Pros : sintaxis legible y limpia. No se requiere biblioteca o código personalizado, excepto una cuña si el soporte nativo no está disponible
• Contras : sobrecarga de memoria debido a la creación de la matriz.

2. Soluciones basadas en bibliotecas

Muchos ejemplos basados ​​en bibliotecas en otras partes de este tema son expresiones idiomáticas útiles en el contexto de su biblioteca. Sin embargo, desde el punto de vista del rendimiento, no hay nada que ganar en comparación con un código perfecto sin biblioteca, ya que todos esos métodos de biblioteca realmente encapsulan ya sea for-loop o ES5 Object.keys(nativo o shimmed).

3. Optimizar un ciclo for

La parte más lenta de tal ciclo for es generalmente la .hasOwnProperty()llamada, debido a la sobrecarga de la llamada de función. Entonces, cuando solo quiero la cantidad de entradas de un objeto JSON, simplemente salteo la .hasOwnProperty()llamada si sé que ningún código se extendió ni se extenderá Object.prototype.

De lo contrario, su código podría optimizarse ligeramente haciendo klocal ( var k) y utilizando el operador de incremento de prefijo ( ++count) en lugar de postfix.

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

Otra idea se basa en el almacenamiento en caché del hasOwnPropertymétodo:

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

Si esto es más rápido o no en un entorno determinado es una cuestión de evaluación comparativa. Se puede esperar una ganancia de rendimiento muy limitada de todos modos.

Si realmente se encuentra con un problema de rendimiento, le sugiero que ajuste las llamadas que agregan / eliminan propiedades al / del objeto con una función que también incrementa / disminuye una propiedad con el nombre apropiado (¿tamaño?).

Solo necesita calcular el número inicial de propiedades una vez y continuar desde allí. Si no hay un problema de rendimiento real, no se moleste. Simplemente envuelva ese bit de código en una función getNumberOfProperties(object)y termine con él.

Según lo indicado por Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

hará el truco para todas las propiedades enumerables en su objeto, pero para incluir también las propiedades no enumerables, puede usar el Object.getOwnPropertyNames. Aquí está la diferencia:

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

Como se indicó aquí, este tiene el mismo soporte de navegador queObject.keys

Sin embargo, en la mayoría de los casos, es posible que no desee incluir los no enumerables en este tipo de operaciones, pero siempre es bueno saber la diferencia;)

No conozco ninguna forma de hacer esto, sin embargo, para mantener las iteraciones al mínimo, podría intentar verificar la existencia de __count__y si no existe (es decir, no Firefox), podría iterar sobre el objeto y definir para su uso posterior, por ejemplo:

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

De esta forma, cualquier navegador compatible __count__lo usaría, y las iteraciones solo se llevarían a cabo para aquellos que no lo hacen. Si el recuento cambia y no puede hacer esto, siempre podría hacerlo una función:

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

De esta manera cada vez que haga referencia a myobj. __count__la función se activará y volverá a calcular.

Para iterar en Avi Flax, responda Object.keys (obj) .length es correcto para un objeto que no tiene funciones vinculadas

ejemplo:

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

versus

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

pasos para evitar esto:

1. no coloque funciones en un objeto en el que desee contar el número de claves

2. use un objeto separado o cree un nuevo objeto específicamente para funciones (si desea contar cuántas funciones hay en el archivo usando Object.keys(obj).length)

También sí, utilicé el módulo _ o subrayado de nodejs en mi ejemplo

la documentación se puede encontrar aquí http://underscorejs.org/ así como su fuente en github y otra información

Y finalmente una implementación lodash https://lodash.com/docs#size

_.size(obj)

como se respondió anteriormente: Object.keys(obj).length

Pero: como ahora tenemos una clase de Mapa real en ES6, sugeriría usarla en lugar de usar las propiedades de un objeto.

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

Para aquellos que tienen Underscore.js incluido en su proyecto, pueden hacer:

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

o estilo funcional:

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

Aquí hay algunas pruebas de rendimiento para tres métodos;

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

Object.keys (). Length

20,735 operaciones por segundo

Muy simple y compatible. Corre rápido pero costoso porque crea una nueva matriz de claves, que luego se descarta.

return Object.keys(objectToRead).length;

recorrer las teclas

15,734 operaciones por segundo

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

Ligeramente más lento, pero nada cerca del uso de memoria, por lo que probablemente sea mejor si está interesado en optimizar para dispositivos móviles u otras máquinas pequeñas

Usar mapa en lugar de objeto

953,839,338 operaciones por segundo

return mapToRead.size;

Básicamente, Map rastrea su propio tamaño, por lo que solo estamos devolviendo un campo numérico. Mucho, mucho más rápido que cualquier otro método. Si tiene control del objeto, conviértalos en mapas.

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

Object.defineProperty (obj, prop, descriptor)

Puedes agregarlo a todos tus objetos:

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

O un solo objeto:

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

Ejemplo:

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

Agregado de esa manera, no se mostrará en ... en bucles:

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

Salida:

name:John Doe
email:leaked@example.com

Nota: no funciona en los navegadores <IE9.

Cómo he resuelto este problema es crear mi propia implementación de una lista básica que mantiene un registro de cuántos elementos están almacenados en el objeto. Es muy simple. Algo como esto:

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

Puede usar Object.keys(data).lengthpara encontrar la longitud del objeto JSON que tiene datos clave

Para aquellos que tienen Ext JS 4 en su proyecto, pueden hacer:

Ext.Object.getSize(myobj);

La ventaja de esto es que funcionará en todos los navegadores compatibles con Ext (incluido IE6-IE8), sin embargo, creo que el tiempo de ejecución no es mejor que O (n), como ocurre con otras soluciones sugeridas.

Puedes usar:

Object.keys(objectName).length; 

y

Object.values(objectName).length;

OP no especificó si el objeto es una lista de nodos, si es así, puede usar el método de longitud directamente. Ejemplo:

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

Si jQuery anterior no funciona, intente

$(Object.Item).length

No creo que esto sea posible (al menos no sin usar algunos elementos internos). Y no creo que ganarías mucho optimizando esto.

Intento ponerlo a disposición de todos los objetos como este:

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 tiene una buena función para esto ... goog.object.getCount (obj)

mira goog.Object Documentation