Comment compter efficacement le nombre de clés / propriétés d'un objet en JavaScript?

Quelle est la manière la plus rapide de compter le nombre de clés / propriétés d'un objet? Est-il possible de le faire sans itérer sur l'objet? c'est à dire sans faire

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

(Firefox a fourni une __count__propriété magique , mais cela a été supprimé quelque part autour de la version 4.)

Pour ce faire, dans n'importe quel environnement compatible ES5 , tel que Node , Chrome, IE 9+, Firefox 4+ ou Safari 5+:

Object.keys(obj).length

• Compatibilité du navigateur
• Documentation Object.keys (inclut une méthode que vous pouvez ajouter à des navigateurs non ES5)

Vous pouvez utiliser ce code:

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

Ensuite, vous pouvez également l'utiliser dans les anciens navigateurs:

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

Si vous utilisez Underscore.js, vous pouvez utiliser _.size (merci @douwe):
_.size(obj)

Alternativement, vous pouvez également utiliser _.keys qui pourrait être plus clair pour certains:
_.keys(obj).length

Je recommande fortement Underscore, sa bibliothèque serrée pour faire beaucoup de choses de base. Dans la mesure du possible, ils correspondent à ECMA5 et s'en remettent à l'implémentation native.

Sinon, je soutiens la réponse de @ Avi. Je l'ai édité pour ajouter un lien vers le document MDC qui inclut la méthode keys () que vous pouvez ajouter aux navigateurs non ECMA5.

L'implémentation d'objet standard ( propriétés et méthodes internes de l'objet ES5.1 ) ne nécessite pas Objectde suivi de son nombre de clés / propriétés, il ne devrait donc pas y avoir de méthode standard pour déterminer la taille d'unObject sans itération explicite ou implicite sur ses clés.

Voici donc les alternatives les plus utilisées:

1. Object.keys d'ECMAScript ()

Object.keys(obj).length;Fonctionne en itérant en interne sur les clés pour calculer un tableau temporaire et renvoie sa longueur.

• Avantages - Syntaxe lisible et propre. Aucune bibliothèque ou code personnalisé requis sauf un shim si le support natif n'est pas disponible
• Inconvénients - surcharge de mémoire due à la création de la baie.

2. Solutions basées sur la bibliothèque

De nombreux exemples basés sur des bibliothèques ailleurs dans cette rubrique sont des idiomes utiles dans le contexte de leur bibliothèque. Du point de vue des performances, cependant, il n'y a rien à gagner par rapport à un code parfait sans bibliothèque, car toutes ces méthodes de bibliothèque encapsulent en fait une boucle for ou ES5Object.keys For (native ou shimmed).

3. Optimiser une boucle for

La partie la plus lente d'une telle boucle for est généralement l' .hasOwnProperty()appel, en raison de la surcharge d'appel de la fonction. Donc, quand je veux juste le nombre d'entrées d'un objet JSON, je saute juste l' .hasOwnProperty()appel si je sais qu'aucun code n'a fait ni ne s'étendra Object.prototype .

Sinon, votre code pourrait être très légèrement optimisé en rendant klocal ( var k) et en utilisant l'opérateur prefix-increment ( ++count) au lieu de postfix.

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

Une autre idée repose sur la mise en cache de la hasOwnPropertyméthode:

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

Que ce soit plus rapide ou non dans un environnement donné est une question de benchmarking. Un gain de performances très limité peut être attendu de toute façon.

Si vous rencontrez réellement un problème de performances, je suggérerais d'encapsuler les appels qui ajoutent / suppriment des propriétés à / de l'objet avec une fonction qui incrémente / décrémente également une propriété (taille?) Correctement nommée.

Vous n'avez qu'à calculer une fois le nombre initial de propriétés et à partir de là. S'il n'y a pas de réel problème de performances, ne vous embêtez pas. Enveloppez simplement ce morceau de code dans une fonction getNumberOfProperties(object)et terminez avec.

Comme indiqué par Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

fera l'affaire pour toutes les propriétés énumérables de votre objet, mais pour inclure également les propriétés non énumérables, vous pouvez utiliser à la place le Object.getOwnPropertyNames. Voici la différence:

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

Comme indiqué ici, il a le même support de navigateur queObject.keys

Cependant, dans la plupart des cas, vous ne voudrez peut-être pas inclure les non-énumérables dans ce type d'opérations, mais il est toujours bon de connaître la différence;)

Je ne connais aucun moyen de le faire, mais pour garder les itérations au minimum, vous pouvez essayer de vérifier l'existence de __count__et si elle n'existe pas (c'est-à-dire pas Firefox), vous pouvez parcourir l''objet et définir pour une utilisation ultérieure, par exemple:

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

De cette façon, tout navigateur prenant en charge __count__utiliserait cela, et les itérations ne seraient effectuées que pour ceux qui ne le font pas. Si le nombre change et que vous ne pouvez pas le faire, vous pouvez toujours en faire une fonction:

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

De cette façon, chaque fois que vous faites référence à myobj. __count__la fonction se déclenche et recalcule.

Pour itérer sur Avi Flax, répondez Object.keys (obj) .length est correct pour un objet qui n'a pas de fonctions liées à lui

exemple:

obj = {"lol": "what", owo: "pfft"};
Object.keys(obj).length; // should be 2

contre

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

étapes pour éviter cela:

1. ne placez pas de fonctions dans un objet dans lequel vous souhaitez compter le nombre de clés

2. utiliser un objet séparé ou créer un nouvel objet spécifiquement pour les fonctions (si vous voulez compter le nombre de fonctions dans le fichier en utilisant Object.keys(obj).length)

aussi oui j'ai utilisé le module _ ou underscore de nodejs dans mon exemple

la documentation peut être trouvée ici http://underscorejs.org/ ainsi que sa source sur github et diverses autres informations

Et enfin une implémentation lodash https://lodash.com/docs#size

_.size(obj)

comme répondu ci-dessus: Object.keys(obj).length

Mais: comme nous avons maintenant une vraie classe Map dans ES6, je suggère de l'utiliser au lieu d'utiliser les propriétés d'un objet.

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

Pour ceux qui ont Underscore.js inclus dans leur projet, vous pouvez faire:

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

ou style fonctionnel:

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

Voici quelques tests de performances pour trois méthodes;

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

Object.keys (). Length

20 735 opérations par seconde

Très simple et compatible. Fonctionne rapidement mais cher car il crée un nouveau tableau de clés, qui est ensuite jeté.

return Object.keys(objectToRead).length;

parcourir les clés

15 734 opérations par seconde

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

Légèrement plus lent, mais loin de l'utilisation de la mémoire, donc probablement mieux si vous êtes intéressé par l'optimisation pour les machines mobiles ou autres petites

Utiliser la carte au lieu de l'objet

953 839 338 opérations par seconde

return mapToRead.size;

Fondamentalement, Map suit sa propre taille, nous ne faisons que renvoyer un champ numérique. Loin, bien plus vite que toute autre méthode. Si vous avez le contrôle de l'objet, convertissez-les à la place en cartes.

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

Object.defineProperty (obj, prop, descriptor)

Vous pouvez soit l'ajouter à tous vos objets:

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

Ou un seul objet:

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

Exemple:

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

Ajouté de cette façon, il ne sera pas affiché dans les boucles for..in:

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

Production:

name:John Doe
email:leaked@example.com

Remarque: cela ne fonctionne pas dans les navigateurs <IE9.

La façon dont j'ai résolu ce problème consiste à créer ma propre implémentation d'une liste de base qui conserve un enregistrement du nombre d'éléments stockés dans l'objet. C'est très simple. Quelque chose comme ça:

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

Vous pouvez utiliser Object.keys(data).lengthpour trouver la longueur d'un objet JSON contenant des données clés

Pour ceux qui ont Ext JS 4 dans leur projet, vous pouvez faire:

Ext.Object.getSize(myobj);

L'avantage de cela est qu'il fonctionnera sur tous les navigateurs compatibles Ext (IE6-IE8 inclus), cependant, je pense que le temps d'exécution n'est pas meilleur que O (n), comme avec les autres solutions suggérées.

Vous pouvez utiliser:

Object.keys(objectName).length; 

et

Object.values(objectName).length;

OP n'a pas spécifié si l'objet est un nodeList, si c'est le cas, vous pouvez simplement utiliser la méthode de longueur directement dessus. Exemple:

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

Si jQuery ci-dessus ne fonctionne pas, essayez

$(Object.Item).length

Je ne pense pas que ce soit possible (du moins pas sans utiliser des internes). Et je ne pense pas que vous gagneriez beaucoup en optimisant cela.

J'essaie de le rendre disponible à tous les objets comme celui-ci:

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

Google Closure a une fonction intéressante pour cela ... goog.object.getCount (obj)

regardez goog.Object Documentation