Déterminer combien de champs un objet Javascript a

Question

J'ai un objet Javascript que j'essaie d'utiliser comme un "hashmap". Les clés sont toujours des chaînes, donc je ne pense pas avoir besoin de quelque chose d'aussi sophistiqué que ce qui est décrit dans this SO question. (Je ne m'attends pas non plus à ce que le nombre de clés dépasse 10, donc je ne suis pas particulièrement concerné par les recherches O (n) vs. O (log n) etc.)

La seule fonctionnalité que je veux les objets Javascript intégrés ne semblent pas avoir, est un moyen rapide de comprendre le nombre de paires clé/valeur dans l'objet, comme ce que Map.size de Java renvoie. Bien sûr, vous pouvez simplement faire quelque chose comme:

function getObjectSize(myObject) { 
    var count=0 
    for (var key in myObject) 
    count++ 
    return count 
} 

mais qui semble un peu hacky et rond-point. Y a-t-il une "bonne façon" d'obtenir le nombre de champs dans l'objet?

Answer 1

Une correction: vous devez vérifier myObject.hasOwnProperty(key) à chaque itération, car il peut y avoir des attributs hérités. Par exemple, si vous faites cela avant la boucle Object.prototype.test = 'test', test sera également compté.

Et en parlant de votre question: vous pouvez simplement définir une fonction d'aide, si la vitesse n'a pas d'importance. Après tout, nous définissons des aides pour la fonction d'assiette et d'autres choses simples. Beaucoup de javascript est « type de aki et rond-point » :)

mise à jour
défaut par exemple, comme l'a demandé.

Object.prototype.test = 'test'; 
var x = {}; 
x['a'] = 1; 
x['b'] = 2; 

Le nombre retourné sera 3.

Answer 2

vous pouvez aussi faire juste myObject.length (dans les tableaux)

Nevermind, voir ceci: JavaScript object size

Answer 3

C'est tout ce que vous pouvez faire. Clairement, les objets JavaScript ne sont pas conçus pour cela. Et cela ne vous donnera que le nombre de propriétés Enumerable. Essayez getObjectSize(Math).

Answer 4

Il y a un moyen plus facile à ECMAScript 5. spec'd

Object.keys(..) retourne un tableau de toutes les clés définies sur l'objet. La longueur peut être appelée là-dessus. Essayez Chrome:

Object.keys({a: 1, b: 2}).length; // 2 

Notez que tous les objets sont essentiellement des paires clé/valeur en JavaScript, et ils sont aussi très extensible. Vous pouvez étendre le Object.prototype avec une méthode size et obtenir le compte là. Cependant, une meilleure solution est de créer une interface de type HashMap ou d'utiliser l'une des nombreuses implémentations existantes, et de définir size dessus. Voici une petite mise en œuvre:

function HashMap() {} 

HashMap.prototype.put = function(key, value) { 
    this[key] = value; 
}; 

HashMap.prototype.get = function(key) { 
    if(typeof this[key] == 'undefined') { 
     throw new ReferenceError("key is undefined"); 
    } 
    return this[key]; 
}; 

HashMap.prototype.size = function() { 
    var count = 0; 

    for(var prop in this) { 
     // hasOwnProperty check is important because 
     // we don't want to count properties on the prototype chain 
     // such as "get", "put", "size", or others. 
     if(this.hasOwnProperty(prop) { 
      count++; 
     } 
    } 

    return count; 
}; 

Utilisation comme (example):

var map = new HashMap(); 
map.put(someKey, someValue); 
map.size();