Comment lister les propriétés d'un objet JavaScript?

Disons que je crée un objet ainsi:

var myObject =
        {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

Quelle est la meilleure façon de récupérer une liste des noms de propriété? c'est-à-dire que je voudrais me retrouver avec des "clés" variables telles que:

keys == ["ircEvent", "method", "regex"]

Dans les navigateurs modernes (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +), vous pouvez utiliser la méthode Object.keys intégrée :

var keys = Object.keys(myObject);

Ce qui précède a un polyfill complet mais une version simplifiée est:

var getKeys = function(obj){
   var keys = [];
   for(var key in obj){
      keys.push(key);
   }
   return keys;
}

Remplacez également var getKeyspar Object.prototype.keyspour vous permettre d'appeler .keys()n'importe quel objet. L'extension du prototype a des effets secondaires et je ne recommanderais pas de le faire.

Comme l'a souligné slashnick , vous pouvez utiliser la construction "for in" pour parcourir un objet pour ses noms d'attribut. Cependant, vous itérerez sur tous les noms d'attributs de la chaîne de prototypes de l'objet. Si vous souhaitez itérer uniquement sur les propres attributs de l'objet, vous pouvez utiliser la méthode Object # hasOwnProperty () . Ayant ainsi les éléments suivants.

for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
        /* useful code here */
    }
}

Comme Sam Dutton a répondu, une nouvelle méthode à cet effet a été introduite dans ECMAScript 5e édition. Object.keys()fera ce que vous voulez et est pris en charge dans Firefox 4 , Chrome 6, Safari 5 et IE 9 .

Vous pouvez également implémenter très facilement la méthode dans les navigateurs qui ne la prennent pas en charge. Cependant, certaines implémentations ne sont pas entièrement compatibles avec Internet Explorer. Voici une solution plus compatible:

Object.keys = Object.keys || (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !{toString:null}.propertyIsEnumerable("toString"),
        DontEnums = [ 
            'toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
            'isPrototypeOf', 'propertyIsEnumerable', 'constructor'
        ],
        DontEnumsLength = DontEnums.length;

    return function (o) {
        if (typeof o != "object" && typeof o != "function" || o === null)
            throw new TypeError("Object.keys called on a non-object");

        var result = [];
        for (var name in o) {
            if (hasOwnProperty.call(o, name))
                result.push(name);
        }

        if (hasDontEnumBug) {
            for (var i = 0; i < DontEnumsLength; i++) {
                if (hasOwnProperty.call(o, DontEnums[i]))
                    result.push(DontEnums[i]);
            }   
        }

        return result;
    };
})();

Notez que la réponse actuellement acceptée n'inclut pas une vérification de hasOwnProperty () et renverra des propriétés héritées de la chaîne de prototype. Il ne prend pas non plus en compte le célèbre bogue DontEnum dans Internet Explorer où les propriétés non énumérables sur la chaîne de prototypes font en sorte que les propriétés déclarées localement avec le même nom héritent de leur attribut DontEnum.

L'implémentation d' Object.keys () vous donnera une solution plus robuste.

EDIT: suite à une récente discussion avec kangax , un contributeur bien connu de Prototype, j'ai implémenté la solution de contournement pour le bogue DontEnum basée sur le code de sa Object.forIn()fonction trouvée ici .

Notez que Object.keys et d'autres méthodes ECMAScript 5 sont pris en charge par Firefox 4, Chrome 6, Safari 5, IE 9 et supérieur.

Par exemple:

var o = {"foo": 1, "bar": 2}; 
alert(Object.keys(o));

Tableau de compatibilité ECMAScript 5: http://kangax.github.com/es5-compat-table/

Description des nouvelles méthodes: http://markcaudill.com/index.php/2009/04/javascript-new-features-ecma5/

Object.getOwnPropertyNames(obj)

Cette fonction affiche également des propriétés non énumérables en plus de celles indiquées par Object.keys(obj).

Dans JS, chaque propriété a quelques propriétés, y compris un booléen enumerable.

En général, les propriétés non énumérables sont plus «internes» et moins souvent utilisées, mais il est parfois judicieux de les examiner pour voir ce qui se passe réellement.

Exemple:

var o = Object.create({base:0})
Object.defineProperty(o, 'yes', {enumerable: true})
Object.defineProperty(o, 'not', {enumerable: false})

console.log(Object.getOwnPropertyNames(o))
// [ 'yes', 'not' ]

console.log(Object.keys(o))
// [ 'yes' ]

for (var x in o)
    console.log(x)
// yes, base

Notez également comment:

• Object.getOwnPropertyNameset Object.keys ne remontez pas la chaîne du prototype pour trouverbase
• for in Est-ce que

Plus d'informations sur la chaîne de prototypes ici: https://stackoverflow.com/a/23877420/895245

Je suis un grand fan de la fonction de vidage.

http://ajaxian.com/archives/javascript-variable-dump-in-coldfusion

Pourrait le faire avec jQuery comme suit:

var objectKeys = $.map(object, function(value, key) {
  return key;
});

si vous essayez d'obtenir uniquement les éléments mais pas les fonctions, ce code peut vous aider

this.getKeys = function() {

    var keys = new Array();
    for(var key in this) {

        if( typeof this[key] !== 'function') {

            keys.push(key);
        }
    }
    return keys;
}

cela fait partie de mon implémentation du HashMap et je veux seulement les clés, "ceci" est l'objet hashmap qui contient les clés

Cela fonctionnera dans la plupart des navigateurs, même dans IE8, et aucune bibliothèque d'aucune sorte n'est requise. var i est votre clé.

var myJSONObject =  {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"}; 
var keys=[];
for (var i in myJSONObject ) { keys.push(i); }
alert(keys);

Sous les navigateurs prenant en charge js 1.8:

[i for(i in obj)]

Mozilla a des détails d'implémentation complets sur la façon de le faire dans un navigateur où il n'est pas pris en charge, si cela aide:

if (!Object.keys) {
  Object.keys = (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
        dontEnums = [
          'toString',
          'toLocaleString',
          'valueOf',
          'hasOwnProperty',
          'isPrototypeOf',
          'propertyIsEnumerable',
          'constructor'
        ],
        dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');

      var result = [];

      for (var prop in obj) {
        if (hasOwnProperty.call(obj, prop)) result.push(prop);
      }

      if (hasDontEnumBug) {
        for (var i=0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
        }
      }
      return result;
    };
  })();
}

Vous pouvez l'inclure comme vous le souhaitez, mais éventuellement dans une sorte de extensions.jsfichier en haut de votre pile de scripts.

Utilisation Reflect.ownKeys()

var obj = {a: 1, b: 2, c: 3};
Reflect.ownKeys(obj) // ["a", "b", "c"]

Object.keys et Object.getOwnPropertyNames ne peuvent pas obtenir de propriétés non énumérables . Cela fonctionne même pour les propriétés non énumérables .

var obj = {a: 1, b: 2, c: 3};
obj[Symbol()] = 4;
Reflect.ownKeys(obj) // ["a", "b", "c", Symbol()]

IE ne prend pas en charge (i in obj) pour les propriétés natives. Voici une liste de tous les accessoires que j'ai pu trouver.

Il semble que stackoverflow effectue un filtrage stupide.

La liste est disponible au bas de ce message de groupe Google: - https://groups.google.com/group/hackvertor/browse_thread/thread/a9ba81ca642a63e0

Puisque j'utilise underscore.js dans presque tous les projets, j'utiliserais la keysfonction:

var obj = {name: 'gach', hello: 'world'};
console.log(_.keys(obj));

La sortie de cela sera:

['name', 'hello']

S'appuyant sur la réponse acceptée.

Si l'objet a des propriétés que vous voulez appeler, dites .properties () essayez!

var keys = Object.keys(myJSONObject);

for (var j=0; j < keys.length; j++) {
  Object[keys[j]].properties();
}

La solution fonctionne sur mes coques et cross-browser:

var getKeys = function(obj) {
    var type = typeof  obj;
    var isObjectType = type === 'function' || type === 'object' || !!obj;

    // 1
    if(isObjectType) {
        return Object.keys(obj);
    }

    // 2
    var keys = [];
    for(var i in obj) {
        if(obj.hasOwnProperty(i)) {
            keys.push(i)
        }
    }
    if(keys.length) {
        return keys;
    }

    // 3 - bug for ie9 <
    var hasEnumbug = !{toString: null}.propertyIsEnumerable('toString');
    if(hasEnumbug) {
        var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

        var nonEnumIdx = nonEnumerableProps.length;

        while (nonEnumIdx--) {
            var prop = nonEnumerableProps[nonEnumIdx];
            if (Object.prototype.hasOwnProperty.call(obj, prop)) {
                keys.push(prop);
            }
        }

    }

    return keys;
};