Lunghezza di un object JavaScript

Se ho un object JavaScript, ad esempio

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

esiste un modo migliore o predefinito per ottenere la lunghezza di questo object?

La risposta più efficace (ovvero quella che cattura l’intento di ciò che stai cercando di fare causando il minor numero di bug) sarebbe:

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

C’è una sorta di convenzione in JavaScript che non si aggiungono oggetti a Object.prototype , perché può interrompere le enumerazioni in varie librerie. L’aggiunta di metodi a Object è di solito sicura, però.


Ecco un aggiornamento a partire dal 2016 e una diffusione diffusa di ES5 e oltre. Per IE9 + e tutti gli altri browser compatibili con ES5 +, è ansible utilizzare Object.keys() modo che il codice sopra appena diventa:

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

Questo non deve modificare alcun prototipo esistente poiché Object.keys() è ora integrato.

Modifica : gli oggetti possono avere proprietà simboliche che non possono essere restituite tramite il metodo Object.key. Quindi la risposta sarebbe incompleta senza menzionarli.

Il tipo di simbolo è stato aggiunto alla lingua per creare identificatori univoci per le proprietà dell’object. Il principale vantaggio del tipo di simbolo è la prevenzione delle sovrascritture.

Object.keys o Object.getOwnPropertyNames non funziona per le proprietà simboliche. Per restituirli è necessario utilizzare 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 

Se sai che non devi preoccuparti dei controlli hasOwnProperty , puoi farlo molto semplicemente:

 Object.keys(myArray).length 

Aggiornato : se stai usando Underscore.js (consigliato, è leggero!), Allora puoi farlo

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

In caso contrario , e non si vuole scherzare con le proprietà dell’object per qualsiasi motivo, e si sta già utilizzando jQuery, un plugin è ugualmente accessibile:

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

Usa qualcosa di semplice come:

 Object.keys(obj).length 

Non deve essere difficile e sicuramente non richiede un’altra funzione da realizzare.

Ecco la soluzione più cross-browser.

Questo è migliore della risposta accettata perché usa Object.keys nativi se esiste. Quindi, è il più veloce per tutti i browser moderni.

 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; 

Non sono un esperto di JavaScript, ma sembra che tu debba scorrere gli elementi e contarli poiché Object non ha un metodo di lunghezza:

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

@palmsey: In tutta onestà all’OP, la documentazione JavaScript in realtà si riferisce esplicitamente all’utilizzo di variabili di tipo Object in questo modo come “array associativi”.

Questo metodo ottiene tutti i nomi delle proprietà dell’object in una matrice, in modo da ottenere la lunghezza di tale array che è uguale alla lunghezza delle chiavi dell’object.

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

Per non rovinare il prototipo o altro codice, potresti build ed estendere il tuo object:

 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 si utilizza sempre il metodo add, la proprietà length sarà corretta. Se sei preoccupato che tu o altri non ti serva, puoi aggiungere anche il contatore di proprietà che gli altri hanno pubblicato sul metodo di lunghezza.

Certo, potresti sempre sovrascrivere i metodi. Ma anche se lo fai, il tuo codice probabilmente fallirà notevolmente, rendendo più facile il debug. 😉

Ecco come e non dimenticare di controllare che la proprietà non si trovi sulla catena del prototipo:

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

Ecco una soluzione completamente diversa che funziona solo con browser più moderni (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Vedi jsFiddle

Imposta la tua class Array associativo

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

Ora puoi usare questo codice come segue …

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

Per alcuni casi è meglio archiviare le dimensioni in una variabile separata. Soprattutto se si aggiunge all’array un elemento in un punto e si può facilmente incrementare la dimensione. Ovviamente funzionerebbe molto più velocemente se è necessario controllare spesso le dimensioni.

Uso:

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

Basta usare questo per ottenere la length :

 Object.keys(myObject).length 

@palmsey: In tutta onestà all’OP, i documenti javascript in realtà si riferiscono esplicitamente all’utilizzo di variabili di tipo Object in questo modo come “array associativi”.

E in tutta onestà con @palmsey lui era del tutto corretto, non sono array associativi, sono sicuramente oggetti 🙂 – fanno il lavoro di un array associativo. Ma per quanto riguarda il punto più ampio, sembra che tu abbia il diritto di farlo secondo questo articolo piuttosto raffinato che ho trovato:

JavaScript “Array associativi” considerato dannoso

Ma secondo tutto questo, la risposta accettata non è forse una ctriggers pratica?

Specificare una funzione prototype size () per Object

Se qualcos’altro è stato aggiunto a Object .prototype, il codice suggerito fallirà:

  

Non credo che la risposta debba essere accettata in quanto non ci si può fidare di lavorare se si ha un altro codice in esecuzione nello stesso contesto di esecuzione. Per farlo in modo sicuro, è necessario definire il metodo di misurazione all’interno di myArray e verificare il tipo di membri durante l’iterazione.

Che dire di qualcosa del genere –

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

Se abbiamo l’hash

hash = {“a”: “b”, “c”: “d”};

possiamo ottenere la lunghezza usando la lunghezza dei tasti che è la lunghezza dell’hash:

chiavi (hash) .length

Se stai usando AngularJS 1.x puoi fare le cose in modo AngularJS creando un filtro e usando il codice da uno qualsiasi degli altri esempi come il seguente:

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

Nel tuo controller:

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

O secondo te:

  

Se hai bisogno di una struttura di dati associativi che espone le sue dimensioni, meglio usare una mappa invece di un object.

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

Il più semplice è Object.keys (myObject) .length

Una variazione su alcuni dei precedenti è:

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

È un modo un po ‘più elegante per integrare hasOwnProp.

Se non ti interessa supportare Internet Explorer 8 o inferiore, puoi facilmente ottenere il numero di proprietà in un object applicando i seguenti due passi:

  1. Eseguire Object.keys() per ottenere un array che contiene i nomi di sole proprietà enumerabili o Object.getOwnPropertyNames() se si desidera includere anche i nomi delle proprietà che non sono enumerabili.
  2. Ottieni la proprietà .length di quell’array.

Se è necessario farlo più di una volta, è ansible racchiudere questa logica in una funzione:

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

Come usare questa particolare funzione:

 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 

Vedi anche questo Fiddle per una demo.

Ecco una versione diversa della risposta di James Cogan. Invece di passare un argomento, basta prototipare la class Object e rendere il codice più pulito.

 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; 

Esempio di jsfiddle: http://jsfiddle.net/qar4j/1/

Puoi semplicemente usare Object.keys(obj).length su qualsiasi object per ottenere la sua lunghezza. Object.keys restituisce una matrice contenente tutte le chiavi dell’object (proprietà) che possono tornare utili per trovare la lunghezza di tale object utilizzando la lunghezza della matrice corrispondente. Puoi persino scrivere una funzione per questo. Diventiamo creativi e scriviamo anche un metodo (insieme a una proprietà getter più comoda):

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

Il modo più semplice è come questo

 Object.keys(myobject).length 

dove myobject è l’object di ciò che si desidera la lunghezza

Puoi sempre fare Object.getOwnPropertyNames(myObject).length per ottenere lo stesso risultato di [].length darebbe per un array normale.

Questo funziona per me:

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

Di seguito è riportata una versione della risposta di James Coglan in CoffeeScript per coloro che hanno abbandonato direttamente JavaScript 🙂

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

Proprietà

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

Uso

 var o = {a: 1, b: 2, c: 3}; alert(o.length); // <-- 3 o['foo'] = 123; alert(o.length); // <-- 4 

Come la maggior parte dei problemi JavaScript, ci sono molte soluzioni. Potresti estendere l’object che, nel bene o nel male, funziona come il dizionario di molte altre lingue (+ cittadini di prima class). Niente di male in questo, ma un’altra opzione è quella di build un nuovo object che soddisfi le tue esigenze specifiche.

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

Possiamo trovare la lunghezza di Object usando:

 Object.values(myObject).length