Estoy convirtiendo un flujo async.auto en un código de espera asíncrono. Para simplificar mi pregunta, diga que tengo un conjunto de tareas y una lista de dependencias de estas tareas entre sí, ¿cómo puedo convertir esto en un código de espera asíncrono? Aquí hay un ejemplo que creo que cubrirá todos los casos (corríjame si no es así).
Conjunto de tareas - a(), b(), c(), f(), d(resultOfA, resultOfB), e(resultOfB, resultOfC), g(resultOfF, resultOfE) Aquí para ejecutar d necesitamos valores devueltos de a y b, y para ejecutar e necesitamos los de b y c, para g necesitamos e y f.
Tenga en cuenta que quiero completar todas las tareas lo antes posible
Editar: agregar un flujo automático asincrónico de muestra que necesito convertir
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); });Soy consciente de cómo ejecutar tareas en paralelo y en serie a partir de estas tres preguntas:
Las promesas solo se completan una vez.
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; } Luego dentro de ab , bc , ef , por ejemplo. Tener el await adentro es diferente a ab(await a, await b) ; si la espera se aplica primero a los argumentos, la llamada no se realizará hasta que se resuelvan. Elija el formulario que funcione mejor para la tarea dada.
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; } Mientras que una función async implícitamente devuelve una promesa, una función normal que devuelve una Promesa también es suficiente.
Si bien lo anterior, sin forzar la resolución en los argumentos, es "el más paralelo" (fsvo "parallel" 1 , dependiendo de las fuentes de la promesa ), no siempre es necesario y será más lento en los casos en que no sea trivialmente necesario. Si una llamada no involucra IO o continuaciones relacionadas, probablemente pueda evitar ser async o involucrar promesas.
1 Probablemente sea mejor considerar tal concurrente en lugar de paralelo .