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

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

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

Answer 1

承诺只完成一次。

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里面，比如。等待 inside 与 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 函数隐含地 returns promise，但返回 Promise 的普通函数也足够了。

虽然上面的没有强制解析参数，是“最并行的”（fsvo“并行”¹，取决于 promise 来源)，它并不总是需要的，并且在不需要它的情况下会变慢。如果调用不涉及 IO 或相关的延续，它可能可以避免成为 async 或涉及承诺。

¹考虑这样的并发可能比并发.[=18更好=]

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

How to construct async-await code for a set of tasks which are dependent on one another?

javascript

performance

asynchronous

async-await

async.js