ES6, alias ECMAScript 2015, inclut une notion native de ‘Promesses’ et fournit une syntaxe plus directe et perspicace pour travailler avec elles. Les promesses en ES6 représentent une opération qui n’a pas encore été complétée, mais qui est attendue à l’avenir.
Voici comment vous pouvez utiliser les promesses dans Node.js:
1. Création d’une Promesse:
```
let promesse = new Promise(function(resolve, reject) {
// Faire une opération asynchrone et appeler
// la fonction resolve en cas de succès
// la fonction reject en cas d’erreur
});
```
1. Utilisation d’une Promesse:
```
promesse
.then(function(result) {
// Traiter le “result” lorsque la promesse est accomplie (résolue)
console.log(result);
})
.catch(function(error) {
// Traiter l’“error” quand la promesse est rejetée.
console.error(error);
})
.finally(function() {
// Code à exécuter que la promesse soit résolue ou rejetée
});
```
1. Enchaînement de Promesses:
```
doSomething()
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => {
console.log(`Got the final result: ${finalResult}`);
})
.catch(failureCallback);
```
Cette logique d’enchaînement provient du fait que la méthode `then()` retourne une promesse, vous permettant ainsi de les chaîner.
1. Async/Await :
Avec ES6, vous pouvez également utiliser async / await qui est essentiellement de la syntaxe de sucre par-dessus les promesses. Ça rend votre code asynchrone flatté et plus facile à lire.
```
async function example() {
try {
const result = await someAsyncFunction();
console.log(result);
} catch (error) {
console.error(error);
}
}
```
Dans cette fonction `async`, vous pouvez `await` la promesse. Cela arrête essentiellement l’exécution de la fonction async jusqu’à ce que la promesse soit résolue.
