如何为一组相互依赖的任务构建异步等待代码？

Question

我正在将 async.auto 流转换为异步等待代码。 为了简化我的问题，说我有一组任务和这些任务相互依赖的列表，我如何将其转换为异步等待代码。 这是我认为将涵盖所有情况的示例（如果没有，请纠正我）。

任务集 - a(), b(), c(), f(), d(resultOfA, resultOfB), e(resultOfB, resultOfC), g(resultOfF, resultOfE) 这里要执行 d 我们需要从 a 返回的值和 b，为了执行 e，我们需要 b 和 c，对于 g，我们需要 e 和 f。

请注意，我想尽快完成所有任务

编辑：添加我需要转换的示例异步自动流

async.auto({
    a: function(callback) {
        setTimeout(() => {
            let resA = 3;
            callback(null, resA);
        }, 1000);
    },
    b: function(callback) {
        setTimeout(() => {
            let resB = 4;
            callback(null, resB);
        }, 1000);
    },
    c: function(callback) {
        setTimeout(() => {
            let resC = 5;
            callback(null, resC);
        }, 1000);
    },
    d: ['a', 'b', function(results, callback) {
        setTimeout(() => {
            //following line represents some computations which depends on resA and resB
            resD = results.a + results.b;
            callback(null, resD);
        }, 1000);
    }],
    e: ['b', 'c', function(results, callback) {
        setTimeout(() => {
            resE = results.b + results.c;
            callback(null, resE);
        }, 1000);
    }],
    f: function(callback) {
        callback(null, resF);
    },
    g: ['e', 'f', function(results, callback) {
        setTimeout(() => {
            resG = results.e + results.f;
            callback(null, resG);
        }, 1000);
    }]
}, function(err, results) {
    if (err) {
        console.log('err : ', err);
    }
    console.log('results : ', results);
});

我知道如何从这三个问题并行和串行运行任务 -

1. 使用 async/await 并行运行任务的方法
2. 从并行运行的任务中获取结果的方法
3. 使用 Promise.all() 和 async await 并行运行任务的比较

Answer 1

Promises 只完成一次。

async function foo() {
  a = some_promise_factory();
  b = some_promise_factory();
  c = some_promise_factory();
  f = some_promise_factory();
  d = ab(a, b) // the promise resulting from ab is created
               // *before* that from bc, as it is assigned to d
  e = bc(b, c) // doesn't matter if promise b is used again
  g = ef(e, f) // an 'await promise_e' in ef won't resolve
               // until e is resolved, which won't resolve until
               // bc resolves, which won't resolve until
               // both 'await promise_b' and 'await promise_c' ..

  // can await any promise in an async function..
  return await g;
}

然后在ab ， bc ， ef ，例如。 里面的 await 与ab(await a, await b) ； 如果先将 await 应用于参数，则在解决这些参数之前不会进行调用。 选择最适合给定任务的表单。

async function ab (promise_a, promise_b) {
  return (await promise_a) + (await promise_b) + 1;
}

async function bc (promise_b, promise_c) {
  return (await promise_b) + (await promise_c) * 2;
}

async function ef (promise_e, promise_f) {
  return (await promise_e) + (await promise_f) / 3;
}

虽然async函数隐式地返回一个 Promise，但一个普通的函数返回一个 Promise 也足够了。

虽然上述内容在不强制解析参数的情况下是“最并行的”（fsvo "parallel" ¹ ，取决于承诺来源），但并不总是需要它，并且在几乎不需要的情况下会更慢。 如果调用不涉及 IO 或相关的延续，它可能可以避免async或涉及承诺。

¹考虑这样的concurrent而不是parallel可能更好。