Longueur D'un objet JavaScript

si vous savez que vous n'avez pas à vous soucier des chèques hasOwnProperty , vous pouvez le faire très simplement:

Object.keys(myArray).length

Updated : si vous utilisez Underscore.js (recommandé, c'est léger!), alors vous pouvez simplement faire

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

si ce n'est pas , et que vous ne voulez pas jouer avec les propriétés des objets pour quelque raison que ce soit, et que vous 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;
};

utilisez quelque chose d'aussi simple que:

Object.keys(obj).length

il ne doit pas être difficile et ne nécessite certainement pas une autre fonction à accomplir.

Voici la solution la plus cross-browser.

c'est mieux que la réponse acceptée parce qu'elle utilise un objet natif.les touches s'il existe. Ainsi, il 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 auriez à boucle à travers les éléments et les compter depuis objet 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 fait explicitement référence à l'utilisation de variables d'objet de type de cette manière comme des "tableaux associatifs".

cette méthode obtient tous les noms de propriétés de votre objet dans un tableau, de sorte que vous pouvez 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 déconner avec le prototype ou un autre code, vous pouvez construire 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 oublient de l'utiliser, vous pouvez ajouter le compteur de propriétés que les autres ont posté à la méthode de longueur, aussi.

bien sûr, vous pourriez toujours écraser les méthodes. Mais même si vous le faites, votre code serait probablement pas visiblement, le rendant facile à déboguer. ;)

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

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

le programme d'Installation de votre Tableau Associatif de la classe

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

Maintenant, vous pouvez 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);

Pour certains cas, il est préférable de stocker la taille dans une variable distincte. En particulier, si vous ajoutez au tableau par un élément dans un endroit et peut facilement augmenter la taille. Il serait évidemment travailler beaucoup plus rapidement si vous avez besoin de vérifier la taille souvent.

utiliser:

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

utilisez simplement ceci pour obtenir le length :

Object.keys(myObject).length

@palmsey: pour être honnête avec L'OP, les docs javascript font explicitement référence à l'utilisation de variables d'objet de type de cette manière comme des "tableaux associatifs".

et en toute justice pour @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 certainement avoir le droit de celui-ci selon cet article plutôt beau que j'ai trouvé:

JavaScript "Tableaux Associatifs", Jugée Dangereuse

mais selon tout cela, n'est-ce pas la réponse acceptée elle-même mauvaise pratique?

spécifier une fonction prototype de taille () pour L'objet

Si autre chose a été ajouté à L'objet .prototype, puis le 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 la réponse acceptée car on ne peut pas lui faire confiance si vous avez un autre code exécuté dans le même contexte d'exécution. Pour le faire d'une manière robuste sûrement vous auriez besoin de définir la méthode de taille dans myArray et vérifier le type des membres que vous itérez à travers eux.

Le plus simple est Objet.les touches(monobjet).longueur

Qu'en est-il de 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 hash

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

nous pouvons obtenir la longueur en utilisant la longueur des touches qui est la longueur du hachage:

clés de hachage).longueur

si vous utilisez AngularJS 1.x vous pouvez faire les choses à la façon AngularJS en créant un filtre et en utilisant le code de l'un des autres exemples tels que le suivant:

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

Utilisation

dans votre contrôleur:

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

Ou dans votre point de vue:

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

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

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

une variante de ce qui précède est:

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.

si vous ne vous souciez pas de supporter Internet Explorer 8 ou moins, vous pouvez facilement obtenir le nombre de propriétés dans un objet en appliquant les deux étapes suivantes:

1. Exécuter Object.keys() pour obtenir un tableau qui contient les noms des uniquement les propriétés qui sont énumérable ou Object.getOwnPropertyNames() si vous voulez inclure les noms de propriétés qui ne sont pas énumérable.
2. obtenir le .length propriété de ce tableau.

si vous avez besoin de faire cela plus d'une fois, vous pouvez envelopper 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.

ça marche pour moi:

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

Voici une version différente de la réponse de James Cogan. Au lieu de passer un argument, il suffit de prototyper la classe D'objet 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 de jsfiddle: http://jsfiddle.net/qar4j/1 /

, Vous pouvez simplement utiliser Object.keys(obj).length sur n'importe quel objet pour obtenir sa longueur. Objet.keys retourne un tableau contenant tout l'objet keys (propriétés) qui peut être pratique pour trouver la longueur de cet objet en utilisant la longueur du tableau correspondant. Vous pouvez même écrire une fonction pour cela. Nous allons obtenir créatif et écrire une méthode pour elle aussi bien (avec un getter plus convivial de la propriété):

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

la manière la plus simple est comme ceci

Object.keys(myobject).length

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

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

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

1. objet.valeurs(monobjet).longueur
2. objet.entrées(monobjet).longueur
3. objet.les touches(monobjet).longueur

ci-dessous est une version de la réponse de James Coglan en CoffeeScript pour ceux qui ont abandonné JavaScript droit:)

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

biens

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

Utiliser

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

comme la plupart des problèmes JavaScript, il y a plusieurs solutions. Vous pouvez étendre L'objet que pour le meilleur ou le pire fonctionne comme beaucoup D'autres langues du dictionnaire (+ citoyens de première classe). Rien de mal à cela, mais une autre option est de construire un nouvel Objet qui répond à vos besoins spécifiques.

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