Comment utiliser Async/Await pour suspendre l'exécution des rappels en JavaScript ?

Utiliser Async/Await pour suspendre l'exécution des rappels

Lors du traitement des rappels, il peut être souhaitable de suspendre l'exécution d'une fonction jusqu'au rappel a renvoyé une valeur. En programmation synchrone, cela peut être réalisé avec des mécanismes de blocage comme join(). Cependant, dans la programmation asynchrone, cela est souvent indésirable.

Supposons que vous disposiez d'une fonction de rappel qui garantit d'être appelée exactement une fois et que vous souhaitiez modifier la fonction suivante pour utiliser async/await :

test() {
  api.on( 'someEvent', function( response ) {
    return response;
  });
}

Le but est de le convertir en une fonction asynchrone qui attend l'exécution du rappel, comme ceci :

async test() {
  return await api.on( 'someEvent' );
}

Async/await seul ne peut pas y parvenir, car cela nécessite qu'une promesse soit renvoyée par api.on(). Pour remédier à cela, nous pouvons envelopper le rappel dans une fonction de retour de promesse :

function apiOn(event) {
  return new Promise(resolve => {
    api.on(event, response => resolve(response));
  });
}

Maintenant, nous pouvons réécrire test() en tant que fonction asynchrone :

async function test() {
  return await apiOn( 'someEvent' ); // await is optional here (returns a Promise)
}

Notez que async les fonctions renvoient également des promesses elles-mêmes. Pour obtenir le résultat réel de test(), il doit être attendu dans une fonction asynchrone externe :

async function whatever() {
  const response = await test();
  // use response here
}

En tirant parti de la fonction Promise-wrapping, nous pouvons utiliser async/await pour suspendre efficacement l'exécution de test() jusqu'à ce que le rappel ait renvoyé une valeur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!