Longueur d'un objet JavaScript

J'ai un objet JavaScript, existe-t-il un moyen intégré ou accepté de meilleures pratiques pour obtenir la longueur de cet objet?

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

La réponse la plus robuste (c'est-à-dire qui capture l'intention de ce que vous essayez de faire tout en causant le moins de bogues) serait:

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

Il y a une sorte de convention en JavaScript selon laquelle vous n'ajoutez rien à Object.prototype , car cela peut casser les énumérations dans diverses bibliothèques. Cependant, ajouter des méthodes à Object est généralement sûr.

Voici une mise à jour à partir de 2016 et un déploiement généralisé d'ES5 et au-delà. Pour IE9 + et tous les autres navigateurs modernes ES5 +, vous pouvez utiliser Object.keys()le code ci-dessus comme suit:

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

Cela ne doit modifier aucun prototype existant car il Object.keys()est maintenant intégré.

Edit : les objets peuvent avoir des propriétés symboliques qui ne peuvent pas être retournées via la méthode Object.key. La réponse serait donc incomplète sans les mentionner.

Le type de symbole a été ajouté au langage pour créer des identificateurs uniques pour les propriétés des objets. Le principal avantage du type Symbol est la prévention des écrasements.

Object.keysou Object.getOwnPropertyNamesne fonctionne pas pour les propriétés symboliques. Pour les retourner, vous devez utiliser 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 vous savez que vous n'avez pas à vous soucier des hasOwnPropertycontrôles, vous pouvez le faire très simplement:

Object.keys(myArray).length

Mise à jour : si vous utilisez Underscore.js (recommandé, c'est léger!), Alors vous pouvez simplement faire

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

Sinon , et vous ne voulez pas jouer avec les propriétés d'objet pour une raison quelconque, et utilisez déjà jQuery, un plugin est également accessible:

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

Voici la solution la plus multi-navigateurs.

C'est mieux que la réponse acceptée car elle utilise des Object.keys natifs s'il existe. Ainsi, c'est le plus rapide pour tous les navigateurs modernes.

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;

Je ne suis pas un expert JavaScript, mais il semble que vous deviez parcourir les éléments et les compter car Object n'a pas de méthode de longueur:

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

@palmsey: Pour être honnête avec l'OP, la documentation JavaScript se réfère en fait explicitement à l'utilisation de variables de type Object de cette manière en tant que "tableaux associatifs".

Cette méthode obtient tous les noms de propriétés de votre objet dans un tableau, vous pouvez donc obtenir la longueur de ce tableau qui est égale à la longueur des clés de votre objet.

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

Pour ne pas jouer avec le prototype ou un autre code, vous pouvez créer et étendre votre propre objet:

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 vous utilisez toujours la méthode add, la propriété length sera correcte. Si vous craignez que vous ou d'autres personnes l'utilisiez, vous pouvez également ajouter le compteur de propriétés que les autres ont publié dans la méthode de longueur.

Bien sûr, vous pouvez toujours remplacer les méthodes. Mais même si vous le faites, votre code échouera probablement sensiblement, ce qui facilitera le débogage. ;)

Voici comment et n'oubliez pas de vérifier que la propriété n'est pas sur la chaîne prototype:

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

Utilisez-le simplement pour obtenir length:

Object.keys(myObject).length

Voici une solution complètement différente qui ne fonctionnera que dans les navigateurs plus modernes (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Voir jsFiddle

Configurez votre classe de tableau associatif

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

Vous pouvez maintenant utiliser ce code comme suit ...

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>

Cela fonctionne pour moi:

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

Dans certains cas, il est préférable de simplement stocker la taille dans une variable distincte. Surtout, si vous ajoutez au tableau un élément en un seul endroit et pouvez facilement augmenter la taille. Cela fonctionnerait évidemment beaucoup plus rapidement si vous devez vérifier la taille souvent.

Utilisation:

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

@palmsey: Pour être juste avec l'OP, les documents javascript se réfèrent en fait explicitement à l'utilisation de variables de type Object de cette manière en tant que "tableaux associatifs".

Et pour être honnête avec @palmsey, il avait tout à fait raison, ce ne sont pas des tableaux associatifs, ce sont certainement des objets :) - faire le travail d'un tableau associatif. Mais en ce qui concerne le point plus large, vous semblez définitivement en avoir le droit selon cet article plutôt fin que j'ai trouvé:

Les «tableaux associatifs» JavaScript considérés comme nuisibles

Mais d'après tout cela, la réponse acceptée n'est-elle pas en soi une mauvaise pratique?

Spécifiez une fonction prototype size () pour Object

Si autre chose a été ajouté au Object .prototype, le code suggéré échouera:

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

Je ne pense pas que cette réponse devrait être acceptée car elle ne peut pas être approuvée pour fonctionner si vous avez un autre code en cours d'exécution dans le même contexte d'exécution. Pour le faire de manière robuste, vous devez sûrement définir la méthode de taille dans myArray et vérifier le type des membres à mesure que vous les parcourez.

Si vous avez besoin d'une structure de données associative qui expose sa taille, mieux utiliser une carte au lieu d'un objet.

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

Et quelque chose comme ça -

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 nous avons le hachage

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

nous pouvons obtenir la longueur en utilisant la longueur des clés qui est la longueur du hachage:

clés (hachage) .longueur

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 vous utilisez AngularJS 1.x, vous pouvez faire les choses à la manière d'AngularJS en créant un filtre et en utilisant le code de l'un des autres exemples tels que les suivants:

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

Usage

Dans votre contrôleur:

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

Ou selon vous:

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

La façon la plus simple est comme ça

Object.keys(myobject).length

où mon objet est l'objet de ce que vous voulez la longueur

Si vous ne vous souciez pas de la prise en charge d'Internet Explorer 8 ou d'une version antérieure, vous pouvez facilement obtenir le nombre de propriétés d'un objet en appliquant les deux étapes suivantes:

1. Exécutez soit Object.keys()pour obtenir un tableau contenant uniquement les noms des propriétés énumérables ouObject.getOwnPropertyNames() si vous souhaitez également inclure les noms des propriétés non énumérables.
2. Obtenez la .lengthpropriété de ce tableau.

Si vous devez effectuer cette opération plusieurs fois, vous pouvez encapsuler cette logique dans une fonction:

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

Comment utiliser cette fonction particulière:

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

Voir aussi ce violon pour une démo.

Utilisez Object.keys(myObject).lengthpour obtenir la longueur de l'objet / du tableau

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

Une variation de certains des éléments ci-dessus est la suivante:

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

C'est une façon un peu plus élégante d'intégrer hasOwnProp.

Voici une version différente de la réponse de James Cogan. Au lieu de passer un argument, il suffit de créer un prototype de la classe Object et de rendre le code plus propre.

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;

exemple jsfiddle: http://jsfiddle.net/qar4j/1/

Vous pouvez simplement l'utiliser Object.keys(obj).lengthsur n'importe quel objet pour obtenir sa longueur. Object.keys renvoie un tableau contenant toutes les clés d' objet (propriétés) qui peuvent être utiles pour trouver la longueur de cet objet en utilisant la longueur du tableau correspondant. Vous pouvez même écrire une fonction pour cela. Soyons créatifs et écrivons également une méthode pour cela (avec une propriété getter plus pratique):

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

Vous pouvez toujours faire Object.getOwnPropertyNames(myObject).lengthpour obtenir le même résultat que [].lengthpour un tableau normal.

Nous pouvons trouver la longueur de l'objet en utilisant:

Object.values(myObject).length

Un peu en retard dans le jeu, mais un bon moyen d'y parvenir (IE9 + uniquement) est de définir un getter magique sur la propriété length:

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

Et vous pouvez simplement l'utiliser comme ceci:

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

Donnerait 1.

Vous trouverez ci-dessous une version de la réponse de James Coglan en CoffeeScript pour ceux qui ont abandonné le JavaScript direct :)

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