具有承诺和并发性的递归

Question

请耐心等待，因为这需要一些出发点。

出于问题/讨论的目的，考虑一下这个平凡的价值树。

const valuetree = [{
    item: 1,
    value: 100,
  },
  {
    item: 2,
    value: [{
      item: 3,
      value: [{
          item: 4,
          value: 200
        },
        {
          item: 5,
          value: 200
        },
        {
          item: 6,
          value: 200
        },
      ]
    }]
  },
];

现在，如果我们想编写一个递归函数来将所有值相加，那么这本身就相当简单。像这样：

function sumTree(leaf) {
  let total = 0;

  if (Array.isArray(leaf)) {
    leaf.forEach(subLeaf => {
      total += sumTree(subLeaf);
    });
  } else {
    if (Array.isArray(leaf.value)) {
      total += sumTree(leaf.value);
    } else {
      total += Number(leaf.value);
    }
  }

  return total;
}

现在假设我们想使用 Promise 来实现相同的目标？

这就是我最终的结果......

async function sumTreeAsync(leaf) {
  let promises = [];

  if (Array.isArray(leaf)) {
    leaf.forEach(async subLeaf => {
      promises.push(sumTreeAsync(subLeaf));
    });
  } else {
    if (Array.isArray(leaf.value)) {
      promises.push(sumTreeAsync(leaf.value));
    } else {
      promises.push(leaf.value);
    }
  }

  return promises;
}

所以返回的内容是这样的

[ Promise { [ 100 ] }, Promise { [ [Promise] ] } ]

这是有道理的，一个由 2 个顶级项组成的数组，一个字面值的承诺，以及一个返回嵌套的承诺数组的承诺。

所以现在像 Promise.all 这样的函数只处理一组平面的 Promise，我必须递归嵌套的 Promise 才能得到相同的结果。所以现在我必须递归这棵树两次，这闻起来很糟糕。

所以也许我需要从子叶是数组的 2 种情况中返回已解决的承诺？

这样做是否值得，或者递归应该是同步的？

Answer 1

离你不远了。如果你改变你的回报来做一个Promise .all调用和.then (sum)一个明显的sum函数，这会起作用：

const sum = (ns) => ns .reduce ((a, b) => a + b, 0)

async function sumTreeAsync(leaf) {
  let promises = [];

  if (Array.isArray(leaf)) {
    leaf.forEach(async subLeaf => {
      promises.push(sumTreeAsync(subLeaf));
    });
  } else {
    if (Array.isArray(leaf.value)) {
      promises.push(sumTreeAsync(leaf.value));
    } else {
      promises.push(leaf.value);
    }
  }

  return Promise.all(promises).then(sum);
}

const valuetree = [{item: 1, value: 100}, {item: 2, value: [{item: 3, value: [{item: 4, value: 200}, {item: 5, value: 200}, {item: 6, value: 200}]}]}];

sumTreeAsync (valuetree)
  .then (console .log)

但我肯定会以不同的方式编写这段代码：

const sum = (ns) => ns .reduce ((a, b) => a + b, 0)

const sumTreeAsync = async (leaf) =>
  Promise .all (Array .isArray (leaf)
    ? leaf.map (sumTreeAsync)
    : Array .isArray (leaf .value)
      ? [sumTreeAsync (leaf .value)]
      : [leaf .value]
  ) .then (sum)

const valuetree = [{item: 1, value: 100}, {item: 2, value: [{item: 3, value: [{item: 4, value: 200}, {item: 5, value: 200}, {item: 6, value: 200}]}]}];

sumTreeAsync (valuetree)
  .then (console .log)

不止于此。我可能根本不会写这段代码。 JS 一般还是单线程语言。所以在这种方法中你根本不会得到并发计算。如果您不是简单的总结，而是将事情交给不同的工作人员处理，那么这可能是有道理的。事实上，这只是一种不必要的复杂化。