Comment les fonctions asynchrones en JavaScript renvoient-elles toujours une promesse ?

Comprendre la relation entre les fonctions asynchrones et les promesses

En JavaScript, les fonctions asynchrones simplifient la programmation asynchrone en vous permettant d'écrire du code qui apparaît synchrone tout en il s'exécute de manière asynchrone. Cependant, comprendre comment les fonctions asynchrones interagissent avec les promesses peut être crucial.

Le problème

Considérez la fonction asynchrone suivante :

async function latestTime() {
  const bl = await web3.eth.getBlock('latest');
  console.log(bl.timestamp); // Returns a primitive
  console.log(typeof bl.timestamp.then == 'function'); // Returns false - not a promise
  return bl.timestamp;
}

Lorsque vous appelez lastTime(), vous pouvez vous attendre à recevoir la valeur primitive de l'horodatage de web3.eth.getBlock. Cependant, à la place, vous obtenez une promesse en attente, comme indiqué par ce qui suit :

const time = latestTime(); // Promise { <pending> }

Pourquoi une promesse est renvoyée

Les fonctions asynchrones renvoient toujours une promesse. Cette promesse est réglée lorsque la fonction termine son opération asynchrone et fournit la valeur finale ou la rejette avec une erreur. Dans le cas de lastTime(), la promesse est réglée avec la primitive d'horodatage.

Comment gérer la promesse

En dehors d'une autre fonction asynchrone, vous pouvez utiliser la puis méthode sur la promesse d'accéder à la valeur résolue ou de gérer les erreurs :

latestTime()
.then(time => {
    console.log(time);
})
.catch(error => {
    // Handle/report error
});

Top-Level wait

Les environnements modernes prennent en charge l'attente de niveau supérieur dans les modules, vous permettant d'écrire du code comme celui-ci :

const time = await latestTime();

Cette syntaxe simplifie le travail avec les promesses au niveau du module. Cependant, n'oubliez pas que les rejets de promesses non gérés dans les modules peuvent entraîner l'échec du chargement du module.

Comprendre les fonctions asynchrones avec des promesses

Pour mieux comprendre comment les fonctions asynchrones fonctionnent conjointement avec les promesses, il est utile de réfléchir à la manière dont le moteur JavaScript compile votre fonction asynchrone en un exécuteur de promesses function :

function latestTime() {
    return new Promise((resolve, reject) => {
        web3.eth.getBlock('latest')
        .then(bl => {
            console.log(bl.timestamp);
            console.log(typeof bl.timestamp.then == 'function');
            resolve(bl.timestamp);
        })
        .catch(reject);
    });
}

Dans cette représentation :

• La fonction asynchrone est représentée comme une fonction d'exécuteur de promesse transmise à la nouvelle promesse.
• L'opération asynchrone démarre lorsque web3.eth.getBlock est appelé de manière synchrone.
• Les rappels de promesse sont utilisés pour résoudre ou rejeter le promesse.

En conséquence, la fonction asynchrone renvoie effectivement une promesse au code appelant.

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!