2
votes

Itérer sur un objet à plusieurs niveaux?

J'ai un objet à plusieurs niveaux qui a des noms dynamiques et qui s'étend sur environ 2 niveaux. J'ai trouvé une solution qui fonctionne s'il n'y a qu'un seul objet dynamique, mais j'ai du mal à écrire la boucle pour les multiples. Voici les bases.

Mon objet ressemble à ceci:

for (j = 0; j < container.length; j++){
  const [objectKeys] = Object.keys(container);
}

Fondamentalement, je veux parcourir cet objet et obtenir les objets de chacun des mods tableaux, puis poussez-les vers un autre tableau.

Je reçois cet objet, avec la variable container , puis structure comme ceci: p >

const myMods = [...modsList]

Cette solution fonctionne très bien car ensuite je l'ajoute simplement à mon nouveau tableau comme ceci:

const [objectKeys] = Object.keys(container);
const modsList = container[objectKeys].mods;

Cependant, toute cette fonctionnalité semble se casser lorsque j'essaye de le boucler. voici ce que j'ai jusqu'à présent:

{ 
  dynamic_name1: { 
    mods: [ 
      [Object], [Object] 
    ] 
  }, 

  dynamic_name2: { 
    mods: [ 
      [Object], [Object]
    ] 
   }, 

  dynamic_name3: { 
    mods: [ 
      [Object], [Object]
    ] 
  } 
}

mais en essayant de connecter [objectKeys] je ne suis pas défini. Une idée de comment je pourrais faire ça?

javascript object destructuring

2 commentaires

@Taki Voici un extrait de code: JSFiddle .

thnx, je viens de mal lire votre message,

5 Réponses :

2
votes

Je voudrais obtenir tous les mods réduisant une carte sur vos sous-objets dynamiques, quelque chose comme:

const container = { 
  dynamic_name1: { 
    mods: [ 
      1, 2
    ] 
  }, 

  dynamic_name2: { 
    mods: [ 
      3, 4
    ] 
   }, 

  dynamic_name3: { 
    mods: [ 
      5, 6
    ] 
  } 
}

const mods = Object.values(container)
                   .map(sub => sub.mods)
                   .reduce(
                     (result, mods) => [...result, ...mods],
                     []
                   )

console.log(mods)
// [1, 2, 3, 4, 5, 6]

De cette façon, vous pouvez boucler à la fin.

2 commentaires

Cela a très bien fonctionné pour ce que j'essayais de faire, merci d'avoir pris le temps de répondre!

Object.values (/*...*/). Reduction ((result, {mods}) => [... result, ... mods], []);

0
votes

Si je vous ai bien compris, la fonction ci-dessous devrait accepter un objet et renvoyer un tableau avec tous les mods de 2e niveau

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Appelez-le comme ci-dessous

extractMods({
    a: {
        mods: [0,1,2,3,4]
    },
    b: {
        mods: [5,6,7,8,9]
    },
    c: {
        mods: [10,11,12,13,14]
    },
})

2 commentaires

décourager-screenshots-of-code-and-or-errors

@Taki, supprimé. Je vous remercie

0
votes

Bon exemple des raisons pour lesquelles je n'aime pas les noms de propriétés dynamiques. Un tableau composé de: [{"name": "dynamic_name1", "mods": [{}, {}]}, {"name": "dynamic_name2", "mods": [{}, {} ]}] vous donne des boucles faciles.

Mais pour aider avec le problème, Object.keys () a quelques frères et sœurs: Object.entries () et Object.values ().

const data = { 
  dynamic_name1: { 
    mods: [ 
      { id: 1 },
      { id: 2}
    ] 
  }, 

  dynamic_name2: { 
    mods: [ 
      { id: 3 },
      { id: 4 }
    ] 
   }, 

  dynamic_name3: { 
    mods: [ 
      { id: 5 },
      { id: 6 }
    ] 
  } 
};

const modsList = Object.values( data ).flatMap( entry => entry.mods );

console.log( modsList );

Si votre navigateur ne prend pas encore en charge flatMap (), vous pouvez faire de même avec une carte () ou une réduction ().

2 commentaires

Ouais, je ne suis personnellement pas fan des obj dynamiques. noms, mais j'obtiens ces données avec une page scrape, donc je dois prévoir à l'avance que les mods seront dans des conteneurs dynamiques

Si je devais faire beaucoup d'opérations souvent, donc non seulement obtenir une propriété une fois, j'ai trouvé qu'il était plus efficace de simplement mordre la balle et la boucle pour reformater les données immédiatement après l'avoir grattée. Vous perdez du temps initial, mais vous le rattrapez plus tard par rapport à l'utilisation d'Object.keys / values / entries () imbriqués dans toutes les transformations qui se produisent dans la collection.

0
votes

let obj = {
    dynamic_name1: { mods: [{x:1}, {x:2}] },
    dynamic_name2: { mods: [{x:3}, {x:4}] },
    dynamic_name3: { mods: [{x:5}, {x:6}] }
}

let result = Object.values(obj).reduce((a, b) => (a.push(...b.mods), a), []);
console.log( result )

0 commentaires

0
votes

Le problème avec

const container = {
  dynamic_name1: {
    mods: [
      [Object],
      [Object]
    ]
  },

  dynamic_name2: {
    mods: [
      [Object],
      [Object]
    ]
  },

  dynamic_name3: {
    mods: [
      [Object],
      [Object]
    ]
  }
}

const myMods = Object.values(container).map(e => e.mods).flat(2);

console.log(myMods);

est que container.length n'est pas défini, par conséquent, il n'y a aucune itération et objectKeys n'est jamais attribué.

Utilisez l'objet . valeurs et map a > le tableau résultant pour renvoyer les mods , puis flat avec profondeur de 2 :

for (j = 0; j < container.length; j++){
  const [objectKeys] = Object.keys(container);
}

0 commentaires