6
votes

aplatissement de l'objet imbriqué en javascript

J'ai rencontré ce problème, j'ai pu écrire une solution qui peut gérer un tableau d'objets (non posté ici) ou un objet imbriqué profond d'un niveau mais je ne pouvais pas résoudre lorsque l'objet donné a une structure imbriquée comme ci-dessous. Je suis curieux de savoir comment nous pouvons résoudre ce problème.

nestetdObject(source, '')

la solution devrait être

let returnObj = {}

let nestetdObject = (source, parentKey) => {

    let keys = keyFunction(source);

    keys.forEach((key) => {
      let values = source[key];

      if( typeof values === 'object' && values !== null ) {
        parentKey = keys[0]+'.'+keyFunction(values)[0]
        nestetdObject(values, parentKey);
      }else{
        let key = parentKey.length > 0 ? parentKey : keys[0];
        returnObj[key] = values;
      }
    })
    return returnObj
};

// Key Extractor 
let keyFunction = (obj) =>{
  return Object.keys(obj);
}

une tentative pour un objet imbriqué profond

const solution = {
    'a': 1,
    'b.c': true,
    'b.d.e': 'foo',
    'f': false,
    'g.0': 'red',
    'g.1': 'green',
    'g.2': 'blue',
    'h.0.i': 2,
    'h.0.j': 3
};

appel de la fonction

const source = {
  a: 1,
  b: {
    c: true,
    d: {
      e: 'foo'
    }
  },
  f: false,
  g: ['red', 'green', 'blue'],
  h: [{
    i: 2,
    j: 3
  }]
};

Mais ma tentative échouera si l'objet est comme {foo: {boo: {doo : 1}}} .

javascript typescript arrays data-structures javascript-objects

0 commentaires

3 Réponses :

16
votes

Vous devriez pouvoir le faire assez simplement avec la récursivité. La façon dont cela fonctionne, c'est que vous appelez simplement récursivement un analyseur sur les enfants d'objet qui précède la bonne clé en descendant. Par exemple (pas testé très dur cependant):

const source = {
  a: 1,
  b: {
    c: true,
    d: {
      e: 'foo'
    }
  },
  f: false,
  g: ['red', 'green', 'blue'],
  h: [{
    i: 2,
    j: 3
  }]
}

const flatten = (obj, prefix = '', res = {}) => 
  Object.entries(obj).reduce((r, [key, val]) => {
    const k = `${prefix}${key}`
    if(typeof val === 'object'){ 
      flatten(val, `${k}.`, r)
    } else {
      res[k] = val
    }
    return r
  }, res)
 
console.log(flatten(source))

0 commentaires

-1
votes

un autre exemple simple avec Object.keys

 const apple = { foo: { boo : { doo : 1 } } }


let newObj = {}
const format = (obj,str) => {
  Object.keys(obj).forEach((item)=>{
     if(typeof obj[item] ==='object'){
        const s = !!str? str+'.'+item:item
        format(obj[item],s)
     } else {
       const m = !!str?`${str}.`:''
       newObj[m+item]= obj[item]
     }
  })

}

format(apple,'')

console.log(newObj)

0 commentaires

0
votes

Je suis très en retard à la fête mais cela peut être facilement réalisé avec un module comme Flatify-obj .

Utilisation :

   const flattenObject = require('flatify-obj');

   flattenObject({foo: {bar: {unicorn: 'ðŸ¦„'}}})
   //=> { 'foo.bar.unicorn': 'ðŸ¦„' }

   flattenObject({foo: {unicorn: 'ðŸ¦„'}, bar: 'unicorn'}, {onlyLeaves: true});
   //=> {unicorn: 'ðŸ¦„', bar: 'unicorn'}

0 commentaires