Itérer à travers les propriétés des objets

2040

var obj = {
    name: "Simon",
    age: "20",
    clothing: {
        style: "simple",
        hipster: false
    }
}

for(var propt in obj){
    console.log(propt + ': ' + obj[propt]);
}

Comment la variable proptreprésente-t-elle les propriétés de l'objet? Ce n'est pas une méthode ou une propriété intégrée. Pourquoi propose-t-il toutes les propriétés de l'objet?

Rafay
la source
11
if (typeof(obj[propt]) === 'object') {/ * Recommencez * /}
noob
13
Eh bien, vraiment désolé pour cette question. Je sais ce qu'est une boucle, je ne pouvais pas m'empêcher de "parcourir les propriétés des objets", ce qui, je pense, est maintenant effacé. Aussi, ils m'ont recommandé "JavaScript étape par étape 2e édition - Steve Suehring à l'école.
Rafay
242
C'est une bonne question pour les débutants. J'ajouterais que j'ai 15 ans d'expérience professionnelle avec d'autres langues et j'avais besoin de cette réponse. J'aurais plus 2000 si je pouvais.
Nathan C. Tresch
60
Fou, mais je viens sur cette page tous les quelques mois depuis des années pour réapprendre la syntaxe sur la façon de le faire. Je n'ai pas la peine de me rappeler comment faire ça ... Je me souviens juste que cette page est toujours ici sur SO.
HDave
14
Ceci est la page la plus étrange que j'ai vue sur StackOverflow. Si vous lisez attentivement la question, une seule réponse commence même à tenter de répondre à ce qui est réellement demandé, et elle a un score de -6. La réponse ayant obtenu le score le plus élevé, qui a été acceptée, non seulement ne répond pas, mais est tout simplement fausse.

Réponses:

2426

L'itération des propriétés nécessite cette hasOwnPropertyvérification supplémentaire :

for (var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
        // do stuff
    }
}

C'est nécessaire car le prototype d'un objet contient des propriétés supplémentaires pour l'objet qui font techniquement partie de l'objet. Ces propriétés supplémentaires sont héritées de la classe d'objets de base, mais sont toujours des propriétés de obj.

hasOwnProperty vérifie simplement s'il s'agit d'une propriété spécifique à cette classe, et non héritée de la classe de base.


Il est également possible d'appeler hasOwnPropertyvia l'objet lui-même:

if (obj.hasOwnProperty(prop)) {
    // do stuff
}

Mais cela échouera si l'objet a un champ sans rapport avec le même nom:

var obj = { foo: 42, hasOwnProperty: 'lol' };
obj.hasOwnProperty('foo');  // TypeError: hasOwnProperty is not a function

C'est pourquoi il est plus sûr de l'appeler à la Object.prototypeplace:

var obj = { foo: 42, hasOwnProperty: 'lol' };
Object.prototype.hasOwnProperty.call(obj, 'foo');  // true
Fée lambda
la source
21
@BT Selon la documentation de Mozilla : "Si vous souhaitez uniquement considérer les propriétés attachées à l'objet lui-même, et non ses prototypes, utilisez getOwnPropertyNames ou effectuez une vérification hasOwnProperty (propertyIsEnumerable peut également être utilisé)."
davidmdem
3
Quel est exactement le point d'appeler object.hasOwnProperty()? Le fait d' propertyavoir une valeur quelconque n'implique- t-il pas que c'est le cas object?
Alex S
6
Parce que, Alex S, le prototype d'un objet contient des propriétés supplémentaires pour l'objet qui font techniquement partie de l'objet. Ils sont hérités de la classe d'objets de base, mais ce sont toujours des propriétés. hasOwnProperty vérifie simplement s'il s'agit d'une propriété spécifique à cette classe et non héritée de la classe de base. Une bonne explication: brianflove.com/2013/09/05/javascripts-hasownproperty-method
Kyle Richter
87
Je pense que je dois cependant mentionner que Object.keys (obj) est maintenant une bien meilleure solution pour obtenir les clés de l'objet lui-même. Lien vers la documentation de Mozilla: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Kyle Richter
9
Une information importante manque. propertyest une chaîne ici, aurait dû être appelée propertyName. Sinon, cela peut causer de la confusion aux débutants JS comme moi, c'est-à-dire quoi faire à l'intérieur du if.
Neolisk
1136

Depuis JavaScript 1.8.5, vous pouvez utiliser Object.keys(obj)pour obtenir un tableau de propriétés définies sur l'objet lui-même (celles qui renvoient true pour obj.hasOwnProperty(key)).

Object.keys(obj).forEach(function(key,index) {
    // key: the name of the object key
    // index: the ordinal position of the key within the object 
});

C'est mieux (et plus lisible) que d'utiliser une boucle for-in.

Il est pris en charge sur ces navigateurs:

  • Firefox (Gecko): 4 (2.0)
  • Chrome: 5
  • Internet Explorer: 9

Voir la référence de Mozilla Developer Network Object.keys () pour plus d'informations.

Danny R
la source
7
Ceci est désormais plus largement pris en charge: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Dom Vinyard
3
Et si vous avez besoin de support pour les anciens navigateurs, vous pouvez utiliser ce polyfill
KyleMit
27
Dans les environnements qui prennent en charge cette construction de langage, cette méthode permet d'appeler Array.foreach: Object.keys(myObject).forEach(function(key,index) { //key = the name of the object key //index = the ordinal position of the key within the object });
Todd Price
4
@ AJ_83 Il n'y a pas de bon moyen de sortir d'un forEach (). Utilisez un peu () dans ce cas, et revenez fidèle à la rupture
Daniel Z.
11
pourquoi est-ce plus lisible que for-in? for candidate in candidateStatus... me semble lisible
Jona
309

Les filles et les gars, nous sommes en 2019 et nous n'avons pas beaucoup de temps pour taper ... Alors, faisons cette nouvelle ECMAScript 2016:

Object.keys(obj).forEach(e => console.log(`key=${e}  value=${obj[e]}`));
Frank Roth
la source
17
En quoi est-ce différent de la réponse de Danny R?
krillgar
27
C'est un oneliner et utilise map au lieu de forEach. Et le saturation console.log est peut-être intéressant pour certaines personnes.
Frank Roth
Satly, cela ne fonctionne pas quand obj=window.performance.memory: - / Où comme for inça. ievar obj = window.performance.memory; for( key in obj ) console.log( 'key=' + key + ' val=' + obj[key] );
Michaelangel007
2
window.performance.memoryn'est pris en charge que par chrome et Object.keys(obj)renvoie un tableau vide. Cela n'a rien à voir avec .map.
Frank Roth
Au cas où quelqu'un ne voudrait pas restructurer ce single-liner pour faire plus d'une chose à la fois e, j'ai publié cet essentiel. C'est fondamentalement comme la plupart des implémentations de hachage, et utilise à la ( (key) => (value) )place de { key => value }, mais si vous n'avez pas eu à y faire face auparavant, cela pourrait vous aider à mieux le visualiser: gist.github.com/the-nose-knows/9f06e745a56ff20519707433e28a4fa8
kayleeFrye_onDeck
216

C'est le for...in statement( MDN , spécification ECMAScript ).

Vous pouvez le lire comme " POUR chaque propriété DANS l' objobjet, affectez tour à tour chaque propriété à la variable PROPT ".

Marc B
la source
1
Merci beaucoup, je le comprends maintenant. Je me cognais la tête, parcourant des livres et Google.
Rafay
21
D' accord avec @RightSaidFred, l' inopérateur et la fordéclaration ne sont pas impliqués du tout, la for-indéclaration représente une production de grammaire sur son propre: for ( LeftHandSideExpression in Expression ),for ( var VariableDeclarationNoIn in Expression )
CMS
2
Bizarre cette réponse a tant de votes positifs, d'autant plus que ces commentaires populaires semblent la contredire.
Doug Molineux
9
Pourquoi est-ce marqué comme réponse? C'est probablement le moins utile dans ce fil ..
computrius
3
Réponse la moins utile? Cela dépend de ce que vous pensez que le PO demandait; lorsque j'ai lu la question pour la première fois, cela semblait être une perplexité déconcertée quant au mécanisme par lequel une variable peut être utilisée pour inspecter les propriétés d'un objet, et que cette réponse explique avec éloquence (malgré le terme impropre `` for-in ''). La question « Pourquoi faut - il venir avec tous les biens » Je vois pourrait impliquer l'OP cherchait hasOwnProperty mais ne le sait pas, mais je pense qu'il est plus probable c'était ce que l'OP a voulu savoir et a mal accepté une correcte répondre à une autre question. :-)
Bumpy
157

Dans les implémentations mises à jour d'ES, vous pouvez utiliser Object.entries:

for (const [key, value] of Object.entries(obj)) { }

ou

Object.entries(obj).forEach(([key, value]) => ...)

Si vous souhaitez simplement parcourir les valeurs, utilisez Object.values:

for (const value of Object.values(obj)) { }

ou

Object.values(obj).forEach(value => ...)
OneHoopyFrood
la source
ce serait la meilleure solution (object.entries ...), mais je ne peux pas l'utiliser. Lorsque vous souhaitez le faire plusieurs fois et que vous ne pouvez pas le prendre en charge dans votre framework, vous pouvez utiliser le polyfill sur cette page: developer.mozilla.org/nl/docs/Web/JavaScript/Reference/…
Mario
La troisième suggestion est excellente si vous ne faites que les valeurs des propriétés. Impressionnant!
Ginzburg le
27

Si votre environnement prend en charge ES2017, je recommanderais Object.entries :

Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`);
});

Comme indiqué dans la documentation Mozillas Object.entries () :

La méthode Object.entries () renvoie un tableau de paires de propriétés énumérables [clé, valeur] propres à un objet donné, dans le même ordre que celui fourni par une boucle for ... in (la différence étant qu'une boucle for-in énumère propriétés de la chaîne prototype également).

Fondamentalement, avec Object.entries, nous pouvons renoncer à l'étape supplémentaire suivante qui est requise avec l'ancienne pour ... en boucle:

// This step is not necessary with Object.entries
if (object.hasOwnProperty(property)) {
  // do stuff
}
JSON C11
la source
22

jquery vous permet de le faire maintenant:

$.each( obj, function( key, value ) {
  alert( key + ": " + value );
});
Rob Sedgwick
la source
1
$.each({foo:1, length:0, bar:2}, function(k,v){console.log(k,v)})$ .each n'est pas adapté aux objets. Si un objet possède une propriété length et que sa valeur est nulle, l'objet entier est traité comme s'il s'agissait d'un tableau vide.
Bob Stein
Détails pourquoi je pense que c'est une approche invitant les bogues .
Bob Stein
21

La réponse de Dominik est parfaite, je préfère simplement le faire de cette façon, car c'est plus propre à lire:

for (var property in object) {
    if (!object.hasOwnProperty(property)) continue;

    // Do stuff...
}
Cyril N.
la source
Doit être Objecten majuscule o, non?
Jonathan
18

Les réponses ci-dessus sont un peu ennuyeuses car elles n'expliquent pas ce que vous faites à l'intérieur de la boucle for après vous être assuré qu'il s'agit d'un objet: VOUS N'Y ACCÉDEZ PAS DIRECTEMENT! En réalité, vous ne recevez que la CLÉ que vous devez appliquer à l’OBJ:

var obj = {
  a: "foo",
  b: "bar",
  c: "foobar"
};

// We need to iterate the string keys (not the objects)
for(var someKey in obj)
{
  // We check if this key exists in the obj
  if (obj.hasOwnProperty(someKey))
  {
    // someKey is only the KEY (string)! Use it to get the obj:
    var myActualPropFromObj = obj[someKey]; // Since dynamic, use [] since the key isn't literally named "someKey"

    // NOW you can treat it like an obj
    var shouldBeBar = myActualPropFromObj.b;
  }
}

Tout cela est sûr ECMA5. Fonctionne même dans les versions JS boiteuses comme Rhino;)

dylanh724
la source
15

Pour ajouter l'utilisation de ES2015 de Reflect.ownKeys(obj) et l'itération d'ES2015 sur les propriétés via un itérateur.

Par exemple:

let obj = { a: 'Carrot', b: 'Potato', Car: { doors: 4 } };

peut être répété par

// logs each key
Reflect.ownKeys(obj).forEach(key => console.log(key));

Si vous souhaitez parcourir directement les valeurs des clés d'un objet, vous pouvez définir un iterator , tout comme les itérateurs par défaut de JavaScipts pour les chaînes, les tableaux, les tableaux typés, Map et Set.

JS tentera d'itérer via la propriété d'itérateur par défaut, qui doit être définie comme Symbol.iterator .

Si vous voulez pouvoir parcourir tous les objets, vous pouvez l'ajouter en tant que prototype d'objet:

Object.prototype[Symbol.iterator] = function*() { 
    for(p of Reflect.ownKeys(this)){ yield this[p]; }
}

Cela vous permettrait d'itérer sur les valeurs d'un objet avec une boucle for ... of, par exemple:

for(val of obj) { console.log('Value is:' + val ) }

Attention : Au moment d'écrire cette réponse (juin 2018), tous les autres navigateurs, mais IE, prennent en charge les générateurs et l' for...ofitération viaSymbol.iterator

Dimitar Nikovski
la source
Bien que vous ne répondiez pas réellement à la question du PO, cela m'a été très utile, je ne connaissais pas encore Reflect.
Michiel
15
if(Object.keys(obj).length) {
    Object.keys(obj).forEach(key => {
        console.log("\n" + key + ": " + obj[key]);
    });
}

// *** Explanation line by line ***

// Explaining the bellow line
// It checks if obj has at least one property. Here is how:
// Object.keys(obj) will return an array with all keys in obj
// If there is no keys in obj, it will return empty array = []
// Then it will get it's length, if it has at least one element,
// it's bigger than 0 which evaluates to true and the bellow 
// code will be executed.
// Else means it's length = 0 which evaluates to false
// NOTE: you can use Object.hasOwnProperty() instead of Object.keys(obj).length
if(Object.keys(obj).length) {

    // Explaining the bellow line
    // Just like in the previous line, this returns an array with
    // all keys in obj (because if code execution got here, it means 
    // obj has keys.) 
    // Then just invoke built-in javascript forEach() to loop
    // over each key in returned array and calls a call back function 
    // on each array element (key), using ES6 arrow function (=>)
    // Or you can just use a normal function ((key) { blah blah }).
    Object.keys(obj).forEach(key => {

        // The bellow line prints out all keys with their 
        // respective value in obj.
        // key comes from the returned array in Object.keys(obj)
        // obj[key] returns the value of key in obj
        console.log("\n" + key + ": " + obj[key]);
    });
}
Fouad Boukredine
la source
3
Bonjour, pourriez-vous ajouter plus d'informations sur votre réponse, ne fournissant que du code n'aide pas.
Nicolas
Bonjour @Nicolas J'ai ajouté une explication ligne par ligne au code. Faites-moi savoir si ce n'est toujours pas clair
Fouad Boukredine
1
Parce que forEach saute les valeurs vides , je pense que vous pouvez vous débarrasser du si et faire Object.keys(obj).forEach(e => console.log(`key=${e} value=${obj[e]}`));comme la réponse de Frank Roth.
Darkproduct
12

La boucle for ... in représente chaque propriété d'un objet, car elle ressemble à une boucle for. Vous avez défini propt dans la boucle for ... in en faisant:

    for(var propt in obj){
alert(propt + ': ' + obj[propt]);
}

Une boucle for ... in parcourt les propriétés énumérables d'un objet. Quelle que soit la variable que vous définissez ou placez dans la boucle for ... in, elle change chaque fois qu'elle passe à la propriété suivante qu'elle itère. La variable dans la boucle for ... in parcourt les clés, mais sa valeur est la valeur de la clé. Par exemple:

    for(var propt in obj) {
      console.log(propt);//logs name
      console.log(obj[propt]);//logs "Simon"
    }

Vous pouvez voir en quoi la variable diffère de sa valeur. En revanche, une boucle for ... of fait le contraire.

J'espère que ça aide.

Vappor Washmade
la source
11
let obj = {"a": 3, "b": 2, "6": "a"}

Object.keys(obj).map((item) => {console.log("item", obj[item])})

// a
// 3
// 2
Philll_t
la source
1
Comme mentionné dans d'autres commentaires, forEachest plus approprié ici, car il mapest destiné à renvoyer un nouveau tableau avec les résultats de l'appel du bloc de code à chaque itération. Mais nous ne nous intéressons qu'aux effets secondaires de chaque itération, pas à la valeur de retour, nous n'avons donc pas besoin de ce nouveau tableau qui mapnous donne.
Danny
11
Object.keys(obj).forEach(key =>
  console.log(`key=${key} value=${obj[key]}`)
);
Fellow Stranger
la source
10

Vous pouvez utiliser Lodash. La documentation

var obj = {a: 1, b: 2, c: 3};
_.keys(obj).forEach(function (key) {
    ...
});
viktarpunko
la source
10
Pourquoi diable cette "réponse" a-t-elle 10 votes positifs? Il ne répond absolument pas à la question. Je commence à perdre confiance dans l'intelligence du développeur JS moyen.
developerbmw
1
@developerbmw Je comprends que l'utilisation des fonctionnalités ES6 est plus juste, mais j'ai répondu il y a un an. S'il vous plaît, partagez vos pensées avec nous lorsque vous aurez une minute.
viktarpunko
1
L'idée est de se concentrer davantage sur les méthodes natives, au lieu de suggérer à l'utilisateur d'ajouter une bibliothèque de 10000 lignes à sa page. Ne vous méprenez pas, j'aime bien utiliser Lodash mais il y a un temps et un endroit pour cela et ce n'est pas ça.
9

Votre forboucle itère sur toutes les propriétés de l'objet obj. proptest défini dans la première ligne de votre boucle for. Il s'agit d'une chaîne qui est le nom d'une propriété de l' objobjet. Dans la première itération de la boucle, proptserait "nom".

arb
la source
9

Les objets en JavaScript sont des collections de propriétés et peuvent donc être bouclés dans un pour chaque instruction.

Vous devez penser objà une collection de valeurs clés.


la source
! avec la différence importante que ces «listes de propriétés» peuvent avoir des noms comme clés, tandis que les tableaux JS normaux ne peuvent avoir que des nombres comme clés.
Qqwy
9

De nos jours, vous pouvez convertir un objet JS standard en un objet itérable simplement en ajoutant une méthode Symbol.iterator. Ensuite, vous pouvez utiliser une for ofboucle et accéder directement à ses valeurs ou même utiliser un opérateur d'étalement sur l'objet également. Cool. Voyons comment on peut y arriver:

var o = {a:1,b:2,c:3},
    a = [];
o[Symbol.iterator] = function*(){
                       var ok = Object.keys(this);
                            i = 0;
                       while (i < ok.length) yield this[ok[i++]];
                     };
for (var value of o) console.log(value);
// or you can even do like
a = [...o];
console.log(a);

Redu
la source
1
Une façon intéressante de le faire. Merci pour la function*découverte!
Benj
5

Si vous exécutez Node, je recommanderais:

Object.keys(obj).forEach((key, index) => {
    console.log(key);
});
Justin
la source
5

Bien que la réponse la mieux notée soit correcte, voici un cas d'utilisation alternatif, c'est-à-dire si vous parcourez un objet et souhaitez créer un tableau à la fin. Utiliser .mapau lieu deforEach

const newObj = Object.keys(obj).map(el => {
    //ell will hold keys 
   // Getting the value of the keys should be as simple as obj[el]
})
iRohitBhatia
la source
4

Ajout également de la manière récursive:

function iterate(obj) {
    // watch for objects we've already iterated so we won't end in endless cycle
    // for cases like var foo = {}; foo.bar = foo; iterate(foo);
    var walked = [];
    var stack = [{obj: obj, stack: ''}];
    while(stack.length > 0)
    {
        var item = stack.pop();
        var obj = item.obj;
        for (var property in obj) {
            if (obj.hasOwnProperty(property)) {
                if (typeof obj[property] == "object") {
                  // check if we haven't iterated through the reference yet
                  var alreadyFound = false;
                  for(var i = 0; i < walked.length; i++)
                  {
                    if (walked[i] === obj[property])
                    {
                      alreadyFound = true;
                      break;
                    }
                  }
                  // new object reference
                  if (!alreadyFound)
                  {
                    walked.push(obj[property]);
                    stack.push({obj: obj[property], stack: item.stack + '.' + property});
                  }
                }
                else
                {
                    console.log(item.stack + '.' + property + "=" + obj[property]);
                }
            }
        }
    }
}

Usage:

iterate({ foo: "foo", bar: { foo: "foo"} }); 
Ondrej Svejdar
la source
1
@faiz - voir mes commentaires, c'est une protection contre le coincement dans une boucle sans fin lorsque vous marchez
régulièrement à
3

Ce que fait la boucle for..in, c'est qu'elle crée une nouvelle variable (var someVariable) et stocke ensuite chaque propriété de l'objet donné dans cette nouvelle variable (someVariable) une par une. Par conséquent, si vous utilisez le bloc {}, vous pouvez itérer. Prenons l'exemple suivant.

var obj = {
     name:'raman',
     hobby:'coding',
     planet:'earth'
     };

for(var someVariable in obj) {
  //do nothing..
}

console.log(someVariable); // outputs planet
Raman Sohi
la source
Vote en faveur de cela, étant donné sa simplicité. Dans mon cas d'utilisation, je dois vérifier tous les attributs d'un objet pour les valeurs douteuses-NaN, nulls, indéfinies (c'était des points sur un graphique et ces valeurs empêchaient le graphique de dessiner). Pour obtenir la valeur au lieu du nom, dans la boucle, vous devez simplement le faire obj[someVariable]. Peut-être que la raison pour laquelle il a été tant voté est qu'il n'est pas récursif. Ce ne serait donc pas une solution adéquate si vous avez un objet hautement structuré.
Katharine Osborne
@KatharineOsborne ou peut-être parce que la phrase suivante est un peu cryptique: "Par conséquent, si vous utilisez le bloc {}, vous pouvez itérer." Le code en dit plus que le texte.
bvdb
3

Ici, j'itère chaque nœud et crée des noms de nœuds significatifs. Si vous remarquez, instanceOf Array et instanceOf Object font à peu près la même chose (dans mon application, je donne cependant une logique différente)

function iterate(obj,parent_node) {
    parent_node = parent_node || '';
    for (var property in obj) {
        if (obj.hasOwnProperty(property)) {
            var node = parent_node + "/" + property;
            if(obj[property] instanceof Array) {
                //console.log('array: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            } else if(obj[property] instanceof Object){
                //console.log('Object: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            }
            else {
                console.log(node + ":" + obj[property]);
            }
        }
    }
}

note - Je suis inspiré par la réponse d'Ondrej Svejdar. Mais cette solution a de meilleures performances et moins ambiguës

Faiz Mohamed Haneef
la source
3

Vous voulez essentiellement parcourir chaque propriété de l'objet.

JSFiddle

var Dictionary = {
  If: {
    you: {
      can: '',
      make: ''
    },
    sense: ''
  },
  of: {
    the: {
      sentence: {
        it: '',
        worked: ''
      }
    }
  }
};

function Iterate(obj) {
  for (prop in obj) {
    if (obj.hasOwnProperty(prop) && isNaN(prop)) {
      console.log(prop + ': ' + obj[prop]);
      Iterate(obj[prop]);
    }
  }
}
Iterate(Dictionary);
HovyTech
la source
obj(prop)<- TypeError: obj n'est pas une fonction
le_m
@le_m mon mauvais. Je dois avoir accidentellement retiré l' hasOwnPropertyattribut. Ça devrait marcher maintenant.
HovyTech
2

Je veux ajouter aux réponses ci-dessus, car vous pourriez avoir des intentions différentes de Javascript. Un objet JSON et un objet Javascript sont des choses différentes, et vous voudrez peut-être parcourir les propriétés d'un objet JSON en utilisant les solutions proposées ci-dessus, puis être surpris.

Supposons que vous ayez un objet JSON comme:

var example = {
    "prop1": "value1",
    "prop2": [ "value2_0", value2_1"],
    "prop3": {
         "prop3_1": "value3_1"
    }
}

La mauvaise façon d'itérer à travers ses «propriétés»:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        recursivelyIterateProperties(jsonObject[prop]);
    }
}

Vous pourriez être surpris de voir l'enregistrement de la console 0, 1etc. lorsque vous parcourez à travers les propriétés prop1et prop2et prop3_1. Ces objets sont des séquences et les index d'une séquence sont les propriétés de cet objet en Javascript.

Une meilleure façon d'itérer récursivement les propriétés d'un objet JSON serait de vérifier d'abord si cet objet est une séquence ou non:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        if (!(typeof(jsonObject[prop]) === 'string')
            && !(jsonObject[prop] instanceof Array)) {
                recursivelyIterateProperties(jsonObject[prop]);

            }

     }
}
Jadiel de Armas
la source
1

Pour affiner davantage la réponse acceptée, il convient de noter que si vous instanciez l'objet avec un var object = Object.create(null)alors object.hasOwnProperty(property)déclenchera une TypeError. Donc, pour être sûr, vous devez l'appeler à partir du prototype comme ceci:

for (var property in object) {
    if (Object.prototype.hasOwnProperty.call(object, property)) {
        // do stuff
    }
}
Konrad Kiss
la source