Comprimento de um objecto JavaScript

votos
1k

Se eu tiver um objeto JavaScript, dizem

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

há uma maneira interna ou aceite melhores práticas para obter o comprimento deste objeto?

Publicado 07/08/2008 em 20:42
fonte usuário
Em outras línguas...                            


36 respostas

votos
1k

A resposta mais robusta (ou seja, que captura a intenção de que você está tentando fazer, enquanto causando os erros menor número) seria:

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

Há uma espécie de convenção em JavaScript que você não adicionar coisas para Object.prototype , porque pode quebrar enumerações em várias bibliotecas. Adicionando métodos para objeto é geralmente seguro, no entanto.


Aqui está uma atualização a partir de 2016 e implantação generalizada de ES5 e além. Para IE9 + e todos os outros modernos ES5 + navegadores capazes, você pode usar Object.keys()para que o código acima só se torna:

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

Isto não tem de modificar qualquer protótipo existente desde Object.keys()agora é construído em.

Editar : Os objetos podem ter propriedades simbólicas que não podem ser devolvidos através do método Object.key. Portanto, a resposta seria incompleta sem mencioná-los.

Tipo de símbolo foi adicionada à linguagem para criar identificadores exclusivos para as propriedades do objeto. principal benefício do tipo Symbol é a prevenção de substituições.

Object.keysou Object.getOwnPropertyNamesnão funciona para propriedades simbólicas. Para devolvê-los você precisa usar 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
Respondeu 09/08/2008 em 09:31
fonte usuário

votos
1k

Se você sabe que você não tem que se preocupar com hasOwnPropertycheques, você pode fazer isso de maneira muito simples:

Object.keys(myArray).length
Respondeu 03/04/2011 em 02:44
fonte usuário

votos
249

Atualizado : Se você estiver usando Underscore.js (recomendado, é leve!), Então você pode apenas fazer

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

Se não , e você não quer mexer com propriedades de objetos por qualquer razão, e já estão usando jQuery, um plugin é igualmente acessível:

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};
Respondeu 05/07/2012 em 15:39
fonte usuário

votos
148

Usar algo tão simples como:

Object.keys(obj).length

Ele não tem que ser difícil e definitivamente não requer outra função de realizar.

Respondeu 27/10/2014 em 03:46
fonte usuário

votos
42

Aqui está a solução mais cross-browser.

Isto é melhor do que a resposta aceita, porque ele usa Object.keys nativos se existe. Assim, ele é o mais rápido de todos os navegadores modernos.

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;
Respondeu 01/09/2013 em 17:12
fonte usuário

votos
26

Eu não sou um especialista em JavaScript, mas parece que você teria que percorrer os elementos e contá-las uma vez objeto não tem um método de comprimento:

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

@palmsey: justiça ao OP, a documentação JavaScript na verdade se referem explicitamente ao uso de variáveis ​​do tipo Object desta maneira como "arrays associativos".

Respondeu 07/08/2008 em 20:52
fonte usuário

votos
25

Este método obtém todos os nomes de propriedades do seu objeto em uma matriz, para que possa obter o comprimento dessa matriz que é igual ao comprimento chaves do seu objeto.

Object.getOwnPropertyNames({"hi":"Hi","msg":"Message"}).length; // => 2
Respondeu 01/07/2014 em 13:40
fonte usuário

votos
19

Para não mexer com o protótipo ou outro código, você poderia construir e ampliar seu próprio objeto:

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 você sempre usar o método add, a propriedade length será correta. Se você está preocupado que você ou outras pessoas esquecer de usá-lo, você pode adicionar o contador de propriedade que os outros têm publicado com o método de comprimento, também.

Claro, você sempre pode substituir os métodos. Mas mesmo se você fizer isso, seu código seria provavelmente falhar visivelmente, tornando mais fácil de depurar. ;)

Respondeu 11/06/2011 em 16:44
fonte usuário

votos
14

Veja como e não se esqueça de verificar que a propriedade não está na cadeia de protótipos:

var element_count = 0;
for(var e in myArray)
    if(myArray.hasOwnProperty(e))
        element_count++;
Respondeu 08/08/2008 em 20:18
fonte usuário

votos
13

Aqui é uma solução completamente diferente, que só funcionará nos navegadores mais modernos (IE9 +, Chrome, Firefox 4 +, Opera 11.60+, Safari 5.1+)

veja jsFiddle

Setup sua classe matriz associativa

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

Agora você pode usar este código como segue ...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);
Respondeu 02/08/2013 em 09:49
fonte usuário

votos
12

Usar:

var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
obj = Object.keys(myArray).length;
console.log(obj)

Respondeu 31/05/2016 em 04:49
fonte usuário

votos
12

Para alguns casos, é melhor apenas para armazenar o tamanho em uma variável separada. Especialmente, se você está adicionando à matriz por um elemento em um lugar e pode facilmente aumentar o tamanho. Seria, obviamente, trabalhar muito mais rápido se você precisa verificar o tamanho muitas vezes.

Respondeu 29/07/2011 em 14:41
fonte usuário

votos
11

Basta usar isso para obter a length:

Object.keys(myObject).length
Respondeu 18/01/2018 em 10:29
fonte usuário

votos
10

@palmsey: justiça ao OP, os docs javascript realmente se referem explicitamente ao uso de variáveis ​​do tipo Object desta maneira como "arrays associativos".

E na equidade para @palmsey ele estava bastante correta, eles não são arrays associativos, eles estão definitivamente objetos :) - fazendo o trabalho de uma matriz associativa. Mas no que se refere ao ponto mais largo você definitivamente parecem ter o direito dele de acordo com esta bastante fino artigo que encontrei:

JavaScript “associativas Arrays” consideradas nocivas

Mas de acordo com tudo isso, não é a resposta aceita em si má prática?

Especificar uma função de tamanho protótipo () para Objeto

Se qualquer outra coisa foi adicionada ao objeto .prototype, então o código sugerido irá falhar:

<script type="text/javascript">
Object.prototype.size = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
Object.prototype.size2 = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
alert("age is " + myArray["age"]);
alert("length is " + myArray.size());
</script>

Eu não acho que a resposta deve ser a aceitaram uma vez que não se pode confiar para trabalhar se você tiver qualquer outro código em execução no mesmo contexto de execução. Para fazê-lo de uma forma robusta certamente você teria que definir o método de tamanho dentro de myArray e verifique se o tipo dos membros como você iterar através deles.

Respondeu 08/08/2008 em 23:34
fonte usuário

votos
8

Se você estiver usando AngularJS 1.x que você pode fazer as coisas da maneira AngularJS criando um filtro e usando o código de qualquer um dos outros exemplos como os seguintes:

// Count the elements in an object
app.filter('lengthOfObject', function() {
  return function( obj ) {
    var size = 0, key;
    for (key in obj) {
      if (obj.hasOwnProperty(key)) size++;
    }
   return size;
 }
})

Uso

Em seu controlador:

$scope.filterResult = $filter('lengthOfObject')($scope.object)

Ou na sua opinião:

<any ng-expression="object | lengthOfObject"></any>
Respondeu 15/09/2015 em 19:15
fonte usuário

votos
8

Se tivermos o hash

de hash = { "a": "b", "c": "d"};

podemos obter o comprimento usando o tamanho das chaves que é o comprimento do hash:

teclas (Hash) .length

Respondeu 09/02/2014 em 07:48
fonte usuário

votos
8

Que tal algo como isto -

function keyValuePairs() {
    this.length = 0;
    function add(key, value) { this[key] = value; this.length++; }
    function remove(key) { if (this.hasOwnProperty(key)) { delete this[key]; this.length--; }}
}
Respondeu 24/08/2011 em 15:26
fonte usuário

votos
6

O mais simples é Object.keys (myObject) .length

Respondeu 21/06/2018 em 02:25
fonte usuário

votos
6

Se você precisa de uma estrutura de dados associativa que expõe o seu tamanho, melhor usar um mapa em vez de um objeto.

var myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3
Respondeu 18/05/2016 em 18:16
fonte usuário

votos
5

Se você não se preocupam com suporte Internet Explorer 8 ou inferior, você pode facilmente obter o número de propriedades em um objeto, aplicando as duas etapas a seguir:

  1. Rodar tanto Object.keys()para obter uma matriz que contém os nomes de apenas as propriedades que são enumerable ou Object.getOwnPropertyNames(), se você quiser também incluem os nomes de propriedades que não são enumeráveis.
  2. Obter o .lengthestabelecimento desse array.

Se você precisa fazer isso mais de uma vez, você poderia envolver essa lógica em uma função:

function size(obj, enumerablesOnly) {
    return enumerablesOnly === false ?
        Object.getOwnPropertyNames(obj).length :
        Object.keys(obj).length;
}

Como usar esta função especial:

var myObj = Object.create({}, {
    getFoo: {},
    setFoo: {}
});
myObj.Foo = 12;

var myArr = [1,2,5,4,8,15];

console.log(size(myObj));        // Output : 1
console.log(size(myObj, true));  // Output : 1
console.log(size(myObj, false)); // Output : 3
console.log(size(myArr));        // Output : 6
console.log(size(myArr, true));  // Output : 6
console.log(size(myArr, false)); // Output : 7

Veja também este violino para uma demonstração.

Respondeu 07/03/2016 em 13:13
fonte usuário

votos
5

Uma variação sobre alguns dos acima é:

var objLength = function(obj){    
    var key,len=0;
    for(key in obj){
        len += Number( obj.hasOwnProperty(key) );
    }
    return len;
};

É um pouco maneira mais elegante para integrar hasOwnProp.

Respondeu 18/11/2011 em 19:06
fonte usuário

votos
4

Você pode simplesmente usar Object.keys(obj).lengthem qualquer objeto para obter seu comprimento. Object.keys retorna uma matriz contendo todos os objectos chaves (propriedades) que podem ser úteis para encontrar o comprimento de que o objecto com o comprimento da matriz correspondente. Você pode até escrever uma função para isso. Vamos criativo e escrever um método para ele também (junto com uma propriedade getter mais conveniente):

function objLength(obj)
{
  return Object.keys(obj).length;
}

console.log(objLength({a:1, b:"summit", c:"nonsense"}));

// Works perfectly fine
var obj = new Object();
obj['fish'] = 30;
obj['nullified content'] = null;
console.log(objLength(obj));

// It also works your way, which is creating it using the Object constructor
Object.prototype.getLength = function() {
   return Object.keys(this).length;
}
console.log(obj.getLength());

// You can also write it as a method, which is more efficient as done so above

Object.defineProperty(Object.prototype, "length", {get:function(){
    return Object.keys(this).length;
}});
console.log(obj.length);

// probably the most effictive approach is done so and demonstrated above which sets a getter property called "length" for objects which returns the equivalent value of getLength(this) or this.getLength()

Respondeu 17/09/2016 em 01:48
fonte usuário

votos
4

Aqui está uma versão diferente da resposta de James Cogan. Em vez de passar um argumento, apenas protótipos para fora da classe Object e tornar o código mais limpo.

Object.prototype.size = function () {
    var size = 0,
        key;
    for (key in this) {
        if (this.hasOwnProperty(key)) size++;
    }
    return size;
};

var x = {
    one: 1,
    two: 2,
    three: 3
};

x.size() === 3;

jsFiddle exemplo: http://jsfiddle.net/qar4j/1/

Respondeu 27/06/2013 em 00:47
fonte usuário

votos
3

Isso funciona para mim:

var size = Object.keys(myObj).length;
Respondeu 06/06/2018 em 06:51
fonte usuário

votos
3

Você sempre pode fazer Object.getOwnPropertyNames(myObject).lengthpara obter o mesmo resultado que [].lengthdaria por matriz normal.

Respondeu 12/01/2016 em 01:37
fonte usuário

votos
2
var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;
  1. Object.values ​​(meuObjeto) .length
  2. Object.entries (meuObjeto) .length
  3. Object.keys (meuObjeto) .length
Respondeu 05/04/2018 em 23:45
fonte usuário

votos
2

Um pouco tarde para o jogo, mas uma boa maneira de conseguir isso (apenas IE9 +) é definir um getter magia sobre a propriedade comprimento:

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

E você pode apenas usá-lo assim:

var myObj = { 'key': 'value' };
myObj.length;

Daria 1.

Respondeu 04/07/2017 em 15:20
fonte usuário

votos
2

Podemos encontrar o comprimento do objeto usando:

Object.values(myObject).length
Respondeu 22/05/2017 em 13:42
fonte usuário

votos
2

Propriedade

Object.defineProperty(Object.prototype, 'length', {
    get: function () {
        var size = 0, key;
        for (key in this)
            if (this.hasOwnProperty(key))
                size++;
        return size;
    }
});

Usar

var o = {a: 1, b: 2, c: 3};
alert(o.length); // <-- 3
o['foo'] = 123;
alert(o.length); // <-- 4
Respondeu 06/01/2015 em 19:10
fonte usuário

votos
2

Abaixo está uma versão da resposta de James Coglan em CoffeeScript para aqueles que abandonaram JavaScript reta :)

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size
Respondeu 04/03/2013 em 18:38
fonte usuário

votos
1

No melhor resposta, na minha opinião, if (obj.hasOwnProperty(key))o controle é redundante. Ele retorna sempre true.

Object.size = function(obj) {
    var size = 0, key;
    for (key in obj) {
     size++;
   }
   return size;
};
Respondeu 28/06/2018 em 16:44
fonte usuário

votos
1

Como a maioria dos problemas de JavaScript, existem muitas soluções. Você poderia estender o objeto que, para melhor ou pior obras como dicionário de muitos outros idiomas (+ cidadãos de primeira classe). Nada de errado com isso, mas outra opção é construir um novo objeto que atenda às suas necessidades específicas.

function uberject(obj){
    this._count = 0;
    for(var param in obj){
        this[param] = obj[param];
        this._count++;
    }
}

uberject.prototype.getLength = function(){
    return this._count;
};

var foo = new uberject({bar:123,baz:456});
alert(foo.getLength());
Respondeu 09/05/2014 em 19:45
fonte usuário

votos
0

A maneira mais simples é assim

Object.keys(myobject).length

onde myobject é o objeto do que você quer o comprimento

Respondeu 30/05/2018 em 15:41
fonte usuário

votos
0

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

var size = JSON.stringify(myObject).length;

document.write(size);

JSON.stringify(myObject)

Respondeu 09/04/2018 em 10:24
fonte usuário

votos
0

O trabalho solução para muitos casos e cross browser:

Código

var getTotal = function(collection) {

    var length = collection['length'];
    var isArrayObject =  typeof length == 'number' && length >= 0 && length <= Math.pow(2,53) - 1; // Number.MAX_SAFE_INTEGER

    if(isArrayObject) {
        return collection['length'];
    }

    i= 0;
    for(var key in collection) {
        if (collection.hasOwnProperty(key)) {
            i++;
        }
    }

    return i;
};

Exemplos de Dados:

// case 1
var a = new Object();
a["firstname"] = "Gareth";
a["lastname"] = "Simpson";
a["age"] = 21;

//case 2
var b = [1,2,3];

// case 3
var c = {};
c[0] = 1;
c.two = 2;

Uso

getLength(a); // 3
getLength(b); // 3
getLength(c); // 2
Respondeu 07/08/2016 em 16:28
fonte usuário

votos
0

solução simples:

  var myObject = {};      // ... your object goes here.

  var length = 0;

  for (var property in myObject) {
    if (myObject.hasOwnProperty(property)){
      length += 1;
    }
  };

  console.log(length);    // logs 0 in my example.
Respondeu 11/04/2015 em 14:33
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more