Nsryjdtyk

Here is the runnable code:
https://gist.github.com/the1mills/61d53438a3dce1da32640d3e05a611a6

(I couldn't figure out how to load the async library using JSBin or RequireBin online, maybe someone knows how to do that).

I have this tree structure:

const animals = {

  canines: {

    dogs: {

      poodle: {

        val: true

      }

    },

    fox:{

      val: true

    },

    wolf: {

      northwestern:{

        val: true

      },

      arctic: {

        val: true

      }

    },

    raccoon:{

      val: true

    }

  },

  porpoises: {

    vaquita:{

      val: true

    },

    harbor: {

      val: true

    }

  },



};

For each node in the tree, I want to get a description of each branch from that node, reducing the branch keys into one key, so that I get:

  // canines node: 

[{"Dogs.Poodle": true}, {"Fox":true}, {"Wolf.Northwestern":true}, {"Wolf.Arctic":true}, {"Raccoon" : true}]



   // porpoisies node: 

[{"Vaquita": true}, {"Harbor":true}]



   // and at the animals node:

 [{"Canines.Dogs.Poodle": true}, {"Canines.Fox":true}, {"Canines.Wolf.Northwestern":true}, {"Canines.Wolf.Arctic":true}, {"Canines.Raccoon" : true}, {"Porpoises.Vaquita": true}, {"Porpoises.Harbor":true}]

I have this code, but I can't figure out what's wrong with it. I need to keep it asynchronous because I will be doing so I/O, but we can simulate that with process.nextTick for the purposes of the question.

const uppercaseFirstChar = s => {

  return s.slice(0,1).toUpperCase() + s.slice(1).toLowerCase();

};





const loop = (v, list, cb) => {



  const results = ;



  async.eachLimit(Object.keys(v), 3, (k, cb) => {



    const sub = v[k];



    if (sub && typeof sub === 'object') {



      for (let l of list) {

        l.push({

          key: k

        });

      }



      return loop(sub, list.concat([results]), err => {



        const path = results.reduce((a, b) => {

          return {

            val: a.val,

            key: uppercaseFirstChar(a.key) + '.' + uppercaseFirstChar(b.key)

          }

        });



        console.log({path});



        cb(err);

      });

    }



    for (let l of list) {

      l.push({

        val: sub,

        key: k

      });

    }



    process.nextTick(cb);





  }, cb);



};



const list = ;



loop(animals, list, (err, val) => {

  console.log(err, val);

});

In my code, for each node I am looking the tree paths, and I am getting some wild results, I cannot figure out why.

When the code condenses/collapses itself, you usually know you're on the right track:

const loop = (v, cb) => {



  const results = ;



  async.eachLimit(Object.keys(v), 3, (k, cb) => {



    const sub = v[k];



    if (sub && typeof sub === 'object') {



      return loop(sub, (err, values) => {



        for(let v of values){

          results.push(k + v);

        }



        cb(err);

      });

    }





    results.push(k);

    process.nextTick(cb);





  }, err => {

     cb(err, results);

  });



};





loop(animals, (err, val) => {

  console.log(err, val);

});

the problem with my code above was that object references in the array were being shared by all branches, so each branch was getting overpopulated, if you will.