Longitud de un objeto JavaScript

Tengo un objeto JavaScript, ¿hay una forma de práctica recomendada incorporada o aceptada para obtener la longitud de este objeto?

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

La respuesta más sólida (es decir, que captura la intención de lo que está tratando de hacer mientras causa la menor cantidad de errores) sería:

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

Hay una especie de convención en JavaScript en la que no agrega cosas a Object.prototype , porque puede romper las enumeraciones en varias bibliotecas. Sin embargo, agregar métodos a Object generalmente es seguro.

Aquí hay una actualización a partir de 2016 y una implementación generalizada de ES5 y más allá. Para IE9 + y todos los otros navegadores modernos con capacidad ES5 +, puede usar Object.keys()para que el código anterior se convierta en:

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

Esto no tiene que modificar ningún prototipo existente ya Object.keys()que ahora está integrado.

Editar : los objetos pueden tener propiedades simbólicas que no se pueden devolver a través del método Object.key. Entonces la respuesta sería incompleta sin mencionarlos.

El tipo de símbolo se agregó al idioma para crear identificadores únicos para las propiedades del objeto. El principal beneficio del tipo de símbolo es la prevención de sobrescrituras.

Object.keyso Object.getOwnPropertyNamesno funciona para propiedades simbólicas. Para devolverlos necesitas 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

Si sabe que no tiene que preocuparse por los hasOwnPropertycheques, puede hacerlo de manera muy simple:

Object.keys(myArray).length

Actualizado : si está utilizando Underscore.js (¡recomendado, es liviano!), Entonces simplemente puede hacer

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

Si no es así , y no desea perder el tiempo con las propiedades de Object por cualquier razón, y ya está utilizando jQuery, un complemento es igualmente accesible:

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

Aquí está la solución más cruzada del navegador.

Esto es mejor que la respuesta aceptada porque usa Object.keys nativo si existe. Por lo tanto, es el más rápido para todos los 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;

No soy un experto en JavaScript, pero parece que tendría que recorrer los elementos y contarlos ya que Object no tiene un método de longitud:

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

@palmsey: Para ser justos con el OP, la documentación de JavaScript se refiere explícitamente al uso de variables de tipo Object de esta manera como "matrices asociativas".

Este método obtiene todos los nombres de propiedad de su objeto en una matriz, por lo que puede obtener la longitud de esa matriz que es igual a la longitud de las claves de su objeto.

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

Para no meterse con el prototipo u otro código, puede construir y extender su propio 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

Si siempre usa el método add, la propiedad de longitud será correcta. Si le preocupa que usted u otros se olviden de usarlo, también puede agregar el contador de propiedades que los demás han publicado al método de longitud.

Por supuesto, siempre puedes sobrescribir los métodos. Pero incluso si lo hace, su código probablemente fallará notablemente, lo que facilitará la depuración. ;)

Aquí le mostramos cómo y no olvide verificar que la propiedad no esté en la cadena de prototipos:

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

Simplemente use esto para obtener length:

Object.keys(myObject).length

Aquí hay una solución completamente diferente que solo funcionará en navegadores más modernos (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Ver jsFiddle

Configure su clase de matriz asociativa

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

Ahora puede usar este código de la siguiente manera ...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);

<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);
</script>

<p id="myObj">The number of <b>keys</b> in <b>myObj</b> are: <script>document.write(size)</script></p>

Esto funciona para mi:

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

En algunos casos, es mejor simplemente almacenar el tamaño en una variable separada. Especialmente, si está agregando a la matriz por un elemento en un lugar y puede aumentar fácilmente el tamaño. Obviamente, funcionaría mucho más rápido si necesita verificar el tamaño con frecuencia.

Utilizar:

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

@palmsey: Para ser justos con el OP, los documentos de JavaScript en realidad se refieren explícitamente al uso de variables de tipo Object de esta manera como "matrices asociativas".

Y para ser justos con @palmsey, él era bastante correcto, no son matrices asociativas, definitivamente son objetos :), haciendo el trabajo de una matriz asociativa. Pero en lo que respecta al punto más amplio, definitivamente parece tener el derecho de acuerdo con este artículo bastante bueno que encontré:

JavaScript "Matrices asociativas" considerado perjudicial

Pero de acuerdo con todo esto, ¿no es la respuesta aceptada en sí misma una mala práctica?

Especifique una función prototype size () para Object

Si se ha agregado algo más al Object .prototype, el código sugerido fallará:

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

No creo que esa respuesta sea la aceptada, ya que no se puede confiar en que funcione si tiene algún otro código ejecutándose en el mismo contexto de ejecución. Para hacerlo de una manera robusta seguramente necesitará definir el método de tamaño dentro de myArray y verificar el tipo de miembros a medida que los recorre.

Si necesita una estructura de datos asociativa que exponga su tamaño, mejor use un mapa en lugar de un objeto.

const myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3

¿Qué tal algo como esto?

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

Si tenemos el hash

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

podemos obtener la longitud usando la longitud de las teclas, que es la longitud del hash:

claves (hash) .length

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

1. Object.values ​​(myObject) .length
2. Object.entries (myObject) .length
3. Object.keys (myObject) .length

Si está utilizando AngularJS 1.x, puede hacer las cosas a la manera de AngularJS creando un filtro y utilizando el código de cualquiera de los otros ejemplos, como los siguientes:

// 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

En tu controlador:

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

O en tu opinión:

<any ng-expression="object | lengthOfObject"></any>

La forma más simple es así

Object.keys(myobject).length

donde myobject es el objeto de lo que quieres la longitud

Si no le importa admitir Internet Explorer 8 o inferior, puede obtener fácilmente el número de propiedades en un objeto aplicando los siguientes dos pasos:

1. Ejecútelo Object.keys()para obtener una matriz que contenga los nombres de solo aquellas propiedades que son enumerables o Object.getOwnPropertyNames()si desea incluir también los nombres de propiedades que no son enumerables.
2. Obtenga la .lengthpropiedad de esa matriz.

Si necesita hacer esto más de una vez, podría ajustar esta lógica en una función:

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

Cómo usar esta función particular:

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

Vea también este violín para una demostración.

Use Object.keys(myObject).lengthpara obtener la longitud del objeto / matriz

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

console.log(Object.keys(myObject).length); //3

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

console.log(Object.keys(myObject).length)

// o/p 3

Una variación de algunos de los anteriores es:

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

Es una forma un poco más elegante de integrar hasOwnProp.

Aquí hay una versión diferente de la respuesta de James Cogan. En lugar de pasar un argumento, prototipo de la clase Object y hacer el código más limpio.

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;

Ejemplo de jsfiddle: http://jsfiddle.net/qar4j/1/

Simplemente puede usar Object.keys(obj).lengthen cualquier objeto para obtener su longitud. Object.keys devuelve una matriz que contiene todas las claves de objeto (propiedades) que pueden ser útiles para encontrar la longitud de ese objeto usando la longitud de la matriz correspondiente. Incluso puedes escribir una función para esto. Vamos a ser creativos y escribir un método para ello también (junto con una propiedad getter más 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()

Siempre puede hacer Object.getOwnPropertyNames(myObject).lengthpara obtener el mismo resultado [].lengthque daría para una matriz normal.

Podemos encontrar la longitud del objeto usando:

Object.values(myObject).length

Un poco tarde para el juego, pero una buena manera de lograr esto (solo IE9 +) es definir un captador mágico en la propiedad de longitud:

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

Y puedes usarlo así:

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

Daría 1.

A continuación se muestra una versión de la respuesta de James Coglan en CoffeeScript para aquellos que han abandonado JavaScript directo :)

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size