1
votes

Analyser récursivement un objet contenant des enfants en un objet de format clé-valeur

Considérant que j'ai un objet comme celui-ci:

const o = {
  name: 'name1',
  age: 1,
  children: [{
    name: 'name21',
    age: 21,
    children: [{
      name: 'name31',
      age: 31,
      children: []
    }]
  }, {
    name: 'name22',
    age: 22,
    children: []
  }]
}

const parser = obj => {
  const result = {}
  const { name, age } = obj
  const key = `${name}_${age}`
  if (obj.children.length > 0) {
    obj.children.forEach(child => {
      result[key] = parser(child)
    })
  } else {
    result[key] = {}
  }
  return result
}

console.log(parser(o)) // { "name1_1": { "name22_22": {} } }

Il a trois propriétés, la propriété children pourrait être un tableau vide représentant qu'il n'a pas d'enfant. Je souhaite transformer cet objet au format suivant:

const newObject = {
  name1_1: {
    name21_21: {
      name31_31: {}
    }, 
    name22_22: {}
  }
}

La clé sera au format name_key , et la valeur sera ses enfants associés , si l'objet n'a pas d'enfants, la valeur sera juste un objet vide.

Voici mon implémentation:

const o = {
  name: 'name1',
  age: 1,
  children: [{
    name: 'name21',
    age: 21,
    children: [{
      name: 'name31',
      age: 31,
      children: []
    }]
  }, {
    name: 'name22',
    age: 22,
    children: []
  }]
}

Je ne suis pas sûr de ce que j'ai fait de mal ici, quelqu'un peut-il m'aider un peu s'il vous plaît?

javascript recursion

0 commentaires

3 Réponses :

1
votes

Vous pouvez simplement attribuer le résultat des appels récursifs de votre fonction à l'objet actuel, mais avant cela, vous devez également initialiser cet objet s'il n'existe pas.

const o = {"name":"name1","age":1,"children":[{"name":"name21","age":21,"children":[{"name":"name31","age":31,"children":[]}]},{"name":"name22","age":22,"children":[]}]}

const parser = ({ name, age, children }) => {
  const result = {}
  const key = `${name}_${age}`;

  if (!result[key]) result[key] = {}
  if (children.length) {
    children.forEach(child => {
      Object.assign(result[key], parser(child))
    })
  }

  return result;
}

console.log(parser(o))

2 commentaires

Bravo, mon frère. Donc ce que j'ai fait de mal, c'est que j'ai utilisé result [key] = parser (child) , et de cette façon, le result sera à chaque fois superposé par le nouveau résultat de l'analyseur (enfant) . Vous utilisez Object.assign pour muter le résultat plutôt que de le chevaucher directement. Ma compréhension est-elle correcte?

Oui et aussi ici, je vérifie toujours s'il y a un résultat [clé] avant et s'il n'y en a pas, je règle sa valeur sur un objet vide.

1
votes

Dans votre implémentation, result [key] = parser (child) remplace l'objet dans la deuxième itération pour définir result [key] = {name22_22: {}} . Le correctif consiste donc à étendre l'objet result [key] au lieu de le réaffecter.

const o = {
  name: 'name1',
  age: 1,
  children: [{
    name: 'name21',
    age: 21,
    children: [{
      name: 'name31',
      age: 31,
      children: []
    }]
  }, {
    name: 'name22',
    age: 22,
    children: []
  }]
}

const parser = obj => {
  const result = {}
  const {
    name,
    age
  } = obj
  const key = `${name}_${age}`
  if (obj.children.length > 0) {
    obj.children.forEach(child => {
    //  result[key] = parser(child);
      result[key] = {
        ...result[key],
        ...parser(child),
      }
    })
  } else {
    result[key] = {}
  }
  return result
}
console.log(parser(o)) // {name1_1: {name21_21: {name31_31: {}}, name22_22: {}}}

2 commentaires

Cool bro, apprécie ça, ton explication est super utile!

Heureux d'aider :)

1
votes

Il existe déjà une bonne réponse expliquant ce que vous avez mal fait et comment y remédier. Mais je pense que vous travaillez trop dur ici. Laissez la récursion faire le gros du travail et utilisez Object.assign pour coller les choses ensemble. Cela permet une implémentation aussi simple que celle-ci:

const parser = ({name, age, children}) =>
  ({[`${name}_${age}`]: Object .assign ({}, ... (children || []) .map (parser))})

const o = {name: 'name1', age: 1, children: [{name: 'name21', age: 21, children: [{name: 'name31', age: 31, children: []}]}, {name: 'name22', age: 22, children: []}]}

console .log (parser (o))

1 commentaires

pop, pop, bang!