Como contar com eficiência o número de chaves / propriedades de um objeto em JavaScript?

Qual é a maneira mais rápida de contar o número de chaves / propriedades de um objeto? É possível fazer isso sem iterar sobre o objeto? ou seja, sem fazer

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

(O Firefox forneceu uma __count__propriedade mágica , mas isso foi removido em algum momento da versão 4.)

Para fazer isso em qualquer ambiente compatível com ES5 , como Nó , Chrome, IE 9+, Firefox 4+ ou Safari 5+:

Object.keys(obj).length

• Compatibilidade do navegador
• Documentação de Object.keys (inclui um método que você pode adicionar a navegadores não ES5)

Você pode 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;
    };
}

Em seguida, você também pode usar isso em navegadores antigos:

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

Se você estiver usando o Underscore.js, poderá usar o _.size (obrigado @douwe):
_.size(obj)

Como alternativa, você também pode usar _.keys, o que pode ser mais claro para alguns:
_.keys(obj).length

Eu recomendo o Underscore, é uma biblioteca restrita para fazer muitas coisas básicas. Sempre que possível, eles correspondem ao ECMA5 e adiam para a implementação nativa.

Caso contrário, eu apoio a resposta da @ Avi. Editei-o para adicionar um link ao documento MDC, que inclui o método keys () que você pode adicionar a navegadores não-ECMA5.

A implementação padrão de Objeto ( Propriedades e Métodos Internos do Objeto ES5.1 ) não exige que um Objectrastreie seu número de chaves / propriedades; portanto, não deve haver uma maneira padrão de determinar o tamanho de um objeto.Object sem iterar explícita ou implicitamente suas chaves.

Então, aqui estão as alternativas mais usadas:

1. Object.keys do ECMAScript ()

Object.keys(obj).length;Trabalha iterando internamente as chaves para calcular uma matriz temporária e retorna seu comprimento.

• Prós - sintaxe legível e limpa. Nenhuma biblioteca ou código personalizado necessário, exceto um calço, se o suporte nativo estiver indisponível
• Contras - sobrecarga de memória devido à criação da matriz.

2. Soluções baseadas em bibliotecas

Muitos exemplos baseados em bibliotecas em outras partes deste tópico são expressões úteis no contexto de sua biblioteca. Do ponto de vista do desempenho, no entanto, não há nada a ganhar em comparação com um código sem biblioteca perfeito, pois todos esses métodos de biblioteca realmente encapsulam um loop for ou ES5 Object.keys(nativo ou shimmed).

3. Otimizando um loop for

A parte mais lenta desse loop for geralmente é a .hasOwnProperty()chamada, devido à sobrecarga da chamada de função. Portanto, quando eu apenas quero o número de entradas de um objeto JSON, apenas pulo a .hasOwnProperty()chamada se souber que nenhum código foi nem será estendido Object.prototype.

Caso contrário, seu código poderá ser otimizado levemente, tornando klocal ( var k) e usando o operador prefix-increment ( ++count) em vez do postfix.

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

Outra idéia depende do armazenamento em cache do hasOwnPropertymétodo:

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

Se isso é mais rápido ou não em um determinado ambiente, é uma questão de benchmarking. Um ganho de desempenho muito limitado pode ser esperado de qualquer maneira.

Se você está realmente enfrentando um problema de desempenho, sugiro agrupar as chamadas que adicionam / removem propriedades ao / do objeto com uma função que também aumenta / diminui uma propriedade nomeada adequadamente (size?).

Você só precisa calcular o número inicial de propriedades uma vez e prosseguir a partir daí. Se não houver um problema real de desempenho, não se preocupe. Apenas envolva esse pedaço de código em uma função getNumberOfProperties(object)e termine com ela.

Conforme declarado pela Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

fará o truque para todas as propriedades enumeráveis ​​do seu objeto, mas também incluirá as propriedades não enumeráveis ​​que você pode usar Object.getOwnPropertyNames. Aqui está a diferença:

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

Conforme declarado aqui, ele tem o mesmo suporte de navegador queObject.keys

No entanto, na maioria dos casos, talvez você não queira incluir os não numeráveis ​​nesse tipo de operação, mas é sempre bom saber a diferença;)

Não conheço nenhuma maneira de fazer isso, no entanto, para manter as iterações no mínimo, você pode tentar verificar a existência de __count__e, se ela não existir (por exemplo, não o Firefox), poderá iterar sobre o objeto e definir para uso posterior, por exemplo:

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

Dessa forma, qualquer navegador compatível __count__usaria isso, e as iterações seriam realizadas apenas para aqueles que não o fazem. Se a contagem for alterada e você não puder fazer isso, sempre poderá transformá-la em uma função:

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

Dessa forma, sempre que você fizer referência a myobj. __count__a função será acionada e recalculada.

Para iterar na resposta do Avi Flax, a resposta Object.keys (obj) .length está correta para um objeto que não possui funções vinculadas a ele

exemplo:

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

etapas para evitar isso:

1. não coloque funções em um objeto no qual deseja contar o número de chaves

2. use um objeto separado ou crie um novo objeto especificamente para funções (se você quiser contar quantas funções existem no arquivo usando Object.keys(obj).length)

Também sim, eu usei o módulo _ ou sublinhado de nodejs no meu exemplo

documentação pode ser encontrada aqui http://underscorejs.org/ , bem como sua fonte no github e várias outras informações

E, finalmente, uma implementação do lodash https://lodash.com/docs#size

_.size(obj)

como respondido acima: Object.keys(obj).length

Mas: como agora temos uma classe de mapa real no ES6, sugiro usá-la em vez de usar as propriedades de um objeto.

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

Para aqueles que têm o Underscore.js incluído no projeto, você pode:

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

ou estilo funcional:

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

Aqui estão alguns testes de desempenho para três métodos;

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

Object.keys (). Length

20.735 operações por segundo

Muito simples e compatível. É executado rápido, mas caro, porque cria uma nova matriz de chaves, que depois é descartada.

return Object.keys(objectToRead).length;

percorrer as teclas

15.734 operações por segundo

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

Um pouco mais lento, mas nem um pouco próximo do uso da memória, provavelmente melhor se você estiver interessado em otimizar para dispositivos móveis ou outras pequenas máquinas

Usando Mapa em vez de Objeto

953.839.338 operações por segundo

return mapToRead.size;

Basicamente, o Map rastreia seu próprio tamanho, então estamos retornando um campo numérico. Muito, muito mais rápido que qualquer outro método. Se você tiver o controle do objeto, converta-o em mapas.

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

Object.defineProperty (obj, prop, descritor)

Você pode adicioná-lo a todos os seus objetos:

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

Ou um único objeto:

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

Exemplo:

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

Adicionado dessa maneira, ele não será exibido nos loops for..in:

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

Resultado:

name:John Doe
email:leaked@example.com

Nota: não funciona em navegadores <IE9.

Como resolvi esse problema é criar minha própria implementação de uma lista básica que mantém um registro de quantos itens estão armazenados no objeto. É muito simples. Algo assim:

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

Você pode usar Object.keys(data).lengthpara encontrar o comprimento do objeto JSON com os principais dados

Para aqueles que possuem o Ext JS 4 em seu projeto, você pode fazer:

Ext.Object.getSize(myobj);

A vantagem disso é que ele funcionará em todos os navegadores compatíveis com Ext (incluindo IE6-IE8); no entanto, acredito que o tempo de execução não seja melhor que O (n), como em outras soluções sugeridas.

Você pode usar:

Object.keys(objectName).length; 

e

Object.values(objectName).length;

O OP não especificou se o objeto é um nodeList; se for, você pode simplesmente usar o método length diretamente. Exemplo:

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

Se o jQuery acima não funcionar, tente

$(Object.Item).length

Eu não acho que isso seja possível (pelo menos não sem o uso de alguns componentes internos). E eu não acho que você ganharia muito otimizando isso.

Eu tento disponibilizá-lo para todos os 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

O Google Closure tem uma boa função para isso ... goog.object.getCount (obj)

documentação do goog.Object Documentation