Comment exécuter async / await en parallèle en Javascript

Vous pouvez écrire quelque chose comme ceci:

const responses = await Promise.all([
 fetchUserAsync(),
 fetchPostsAsync(),
]);

const userResponse = responses[0];
const postsResponse = responses[1];

C'est facile à droite? Mais il y a un hic. Promise.all a fail-fast comportement qui signifie, qu'elle rejette dès que l'une des promesses rejeté. Probablement vous voulez une solution plus robuste où nous sommes en charge de la gestion des rejets tout de l'extrait. Heureusement il existe une solution, il peut être réalisé simplement avec async/await sans avoir besoin de l'aide de Promise.all. Un exemple de travail:

JS:

console.clear();

function wait(ms, data) {
  return new Promise( resolve => setTimeout(resolve.bind(this, data), ms) );
}

/** 
 * This will run in series, because 
 * we call a function and immediately wait for it's result, 
 * so this will finish in 1s.
 */
async function series() {
  return {
    result1: await wait(500, 'seriesTask1'),
    result2: await wait(500, 'seriesTask2'),
  }
}

/** 
 * While here we call the functions first,
 * then wait for the result later, so 
 * this will finish in 500ms.
 */
async function parallel() {
  const task1 = wait(500, 'parallelTask1');
  const task2 = wait(500, 'parallelTask2');

  return {
    result1: await task1,
    result2: await task2,
  }
}

async function taskRunner(fn, label) {
  const startTime = performance.now();
  console.log(`Task ${label} starting...`);
  let result = await fn();
  console.log(`Task ${label} finished in ${ Number.parseInt(performance.now() - startTime) } miliseconds with,`, result);
}

void taskRunner(series, 'series');
void taskRunner(parallel, 'parallel');


/* 
 * The result will be:
 * Task series starting...
 * Task parallel starting...
 * Task parallel finished in 500 milliseconds with, { "result1": "parallelTask1", "result2": "parallelTask2" }
 * Task series finished in 1001 milliseconds with, { "result1": "seriesTask1", "result2": "seriesTask2" }
 */

Remarque: Vous aurez besoin d'un navigateur qui a async/await activé pour exécuter cet extrait de code (ou nodejs v7 et ci-dessus)

De cette façon, vous pouvez utiliser simplement try/catch pour gérer vos erreurs, et de renvoyer des résultats partiels à l'intérieur de la parallel fonction.

Pour ceux qui demandent comment vous l'étendre à un nombre déterminé d'appels, vous pouvez utiliser les 2 boucles. Les premiers départs de toutes les tâches, le second attend tout pour finir

JS:

console.clear();

function wait(ms, data) {
  return new Promise( resolve => setTimeout(resolve.bind(this, data), ms) );
}

/** 
 * While here we call the functions first,
 * then wait for the result later, so 
 * this will finish in 500ms.
 */
async function runTasks(timings) {
  let tasks = [];
  for (let i in timings) {
      tasks.push(wait(timings[i], `Result of task ${i}`));
  }

  /* Want fast fail? use Promise.All */
  //return Promise.All(tasks);
  
  let results = [];
  for (let task of tasks) {
       results.push(await task);
  }

  return results;
}

async function taskRunner(fn, arg, label) {
  const startTime = performance.now();
  console.log(`Task ${label} starting...`);
  let result = await fn(arg);
  console.log(`Task ${label} finished in ${ Number.parseInt(performance.now() - startTime) } miliseconds with,`, result);
}

void taskRunner(runTasks, [50,100,200,60,500], 'Task List');

Le pseudo-code peut être écrit comme ci-dessous:

fn async task() {
  result-1 = doAsync();
  result-2 = doAsync();
  result-n = doLongAsync();
  try{
  //handle results together
  combinedResult = handleResults(await result-1, await result-2);
  lastResult = handleLastResult(await result-n);
  }
  catch(err){
   console.error(err)
  }

}

résultat-1, le résultat-2, suite-n va s'exécuter en parallèle.
combinedResult et lastResult continuera à fonctionner en parallèle.
Cependant combinedResult c'est à dire la valeur de retour de handleResults fonction sera rendue une fois le résultat-1 et 2 sont disponibles et lastResult valeur que j'ai.e handleLastResult sera rendue une fois le résultat n est disponible.

Espère que cette aide