Programmation asynchrone TypeScript async/await

async/await est un sucre syntaxique pour la programmation asynchrone introduit dans ES2017, faisant ressembler le code asynchrone à du code synchrone.

Diagramme SVG : flux d'exécution async/await Background Title async/await execution flow Left: Promise Promise approach fetchData() .then(result => { console.log(result); }) Arrow Right: async/await async/await approach async function main() { const result = await fetchData(); console.log(result); } Bottom: execution flow await execution order Timeline Main thread await Pause Promise Background execution Resume Resume Complete Complete Right-side explanation Advantage comparison ✓ Cleaner code ✓ Synchronous style ✓ Better error stack ✓ Easy to debug ✓ try/catch handling Arrow definition

Le diagramme ci-dessus montre les avantages de async/await par rapport aux Promises traditionnelles : un code plus propre et un flux d'exécution plus clair.


Bases de Promise

Une Promise représente le résultat final d'une opération asynchrone.

Exemple

// Créer une Promise
var promise = new Promise(function(resolve, reject) {
    var success = true;
    if (success) {
        resolve("Opération réussie");
    } else {
        reject("Échec de l'opération");
    }
});

promise.then(function(result) {
    console.log("Succès : " + result);
})["catch"](function(error) {
    console.log("Échec : " + error);
});

Résultat de l'exécution :

Success: Operation successful

Fonctions async

Utilisez le mot-clé async pour déclarer des fonctions asynchrones.

Exemple

// les fonctions async renvoient automatiquement une Promise
async function greet(): Promise<string> {
    return "Hello, World!";
}

greet().then(function(result) {
    console.log("Résultat : " + result);
});

// Une fonction asynchrone renvoie une Promise
async function getData() {
    return { name: "Alice", age: 25 };
}

getData().then(function(data) {
    console.log("Données : " + JSON.stringify(data));
});

Résultat de l'exécution :

结果: Hello, World!
数据: {"name":"Alice","age":25}

Mot-clé await

await attend qu'une Promise se termine et obtient le résultat.

Exemple

// Simuler une opération asynchrone
function delay(ms: number): Promise<string> {
    return new Promise(function(resolve) {
        setTimeout(function() {
            resolve("Terminé !");
        }, ms);
    });
}

async function main() {
    console.log("Début...");
    var result = await delay(100);
    console.log("Résultat : " + result);
    console.log("Fin");
}

main();

Résultat de l'exécution :

Start...
Result: Complete!
End

Gestion des erreurs

Utilisez try/catch pour gérer les erreurs asynchrones.

Exemple

function mayFail(shouldFail: boolean): Promise<string> {
    return new Promise(function(resolve, reject) {
        if (shouldFail) {
            reject(new Error("Échec de l'opération"));
        } else {
            resolve("Opération réussie");
        }
    });
}

async function handleError() {
    try {
        var result = await mayFail(true);
        console.log("Résultat : " + result);
    } catch (error) {
        console.log("Erreur interceptée : " + error.message);
    }
}

handleError();

Résultat de l'exécution :

Error caught: Operation failed

Exécution parallèle

Utilisez Promise.all pour exécuter plusieurs opérations asynchrones en parallèle.

Exemple

function fetchUser(id: number): Promise<{ id: number; name: string }> {
    return Promise.resolve({ id: id, name: "Utilisateur" + id });
}

async function main() {
    // Exécuter séquentiellement
    console.time("Série");
    var user1 = await fetchUser(1);
    var user2 = await fetchUser(2);
    console.log("Série terminée : " + user1.name + ", " + user2.name);
    console.timeEnd("Série");

    // Exécuter en parallèle
    console.time("Parallèle");
    var results = await Promise.all([fetchUser(1), fetchUser(2)]);
    console.log("Terminé en parallèle : " + results[0].name + ", " + results[1].name);
    console.timeEnd("Parallèle");
}

main();

Résultat de l'exécution :

串行完成: User1, User2
并行完成: User1, User2

Avantages de async/await par rapport à Promise

  • Code plus propre et plus lisible
  • Style de code synchrone
  • Meilleure pile d'erreurs
  • Facile à déboguer

Résumé

  • async:Déclaration de fonctions async
  • await:Attente d'une Promise
  • Gestion des erreurs :try/catch
  • Parallèle :Promise.all

Autres extensions