Question

这是可运行的代码： https://gist.github.com/the1mills/61d53438a3dce1da32640d3e05a611a6

（我不知道如何使用JSBin或RequireBin在线加载异步库，也许有人知道该怎么做。）

我有这个树形结构：

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
    }
  },

};

对于树中的每个节点，我想从该节点获取每个分支的描述，将分支键简化为一个键，以便得到：

  // 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 / O操作，但出于问题的考虑，我们可以使用process.nextTick对其进行仿真。

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);
});

在我的代码中，对于每个节点，我正在寻找树路径，并且得到了一些疯狂的结果，我不知道为什么。

Answer 1

当代码自身压缩/崩溃时，通常会知道您在正确的轨道上：

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);
});

我上面的代码的问题是数组中的对象引用被所有分支共享，因此，如果可以的话，每个分支的人口都将过多。

将树的每个节点简化为树的提示列表

1 个答案: