ECMAScript 6 fournit nativement l'objet Promise.

Les objets Promise représentent des événements qui se produiront à l'avenir et servent à transmettre des messages issus d'opérations asynchrones.

Les objets Promise ont les deux caractéristiques suivantes :

1. L'état de l'objet n'est pas affecté par le monde extérieur. Un objet Promise représente une opération asynchrone et possède trois états :

  • pending : l'état initial, ni un état de succès ni d'échec.
  • fulfilled : signifie que l'opération s'est terminée avec succès.
  • rejected : signifie que l'opération a échoué.

Seul le résultat d'une opération asynchrone peut déterminer dans quel état elle se trouve actuellement ; aucune autre opération ne peut changer cet état. C'est aussi l'origine du nom Promise, dont le sens anglais est « promise », indiquant qu'aucun autre moyen ne peut le changer.

Une fois l'état changé, il ne changera plus, et le résultat peut être obtenu à tout moment. Il n'y a que deux changements possibles pour l'état d'un objet Promise : de Pending à Resolved, et de Pending à Rejected. Une fois que l'un de ces changements se produit, l'état est figé et ne changera plus jamais, conservant toujours ce résultat. Même si le changement a déjà eu lieu, si vous ajoutez plus tard une fonction de rappel à l'objet Promise, vous obtiendrez quand même immédiatement ce résultat. C'est complètement différent des événements. La caractéristique d'un événement est que si vous le manquez et l'écoutez plus tard, vous ne pouvez pas obtenir le résultat.

Avantages et inconvénients de Promise

Avec les objets Promise, les opérations asynchrones peuvent être exprimées dans le flux des opérations synchrones, évitant les fonctions de rappel profondément imbriquées. De plus, les objets Promise fournissent une interface unifiée, ce qui facilite le contrôle des opérations asynchrones.

Promise présente aussi quelques inconvénients. Premièrement, une Promise ne peut pas être annulée. Une fois créée, elle s'exécute immédiatement et ne peut pas être annulée en cours de route. Deuxièmement, si aucune fonction de rappel n'est définie, les erreurs lancées à l'intérieur de la Promise ne seront pas reflétées à l'extérieur. Troisièmement, lorsqu'elle est à l'état Pending, il n'y a aucun moyen de savoir à quel stade se trouve la progression actuelle (vient de commencer ou est sur le point de se terminer).

Création de Promise

Pour créer un objet promesse, vous pouvez utiliser new pour appeler le constructeur Promise afin de l'instancier.

Voici les étapes pour créer une promesse :

var promise = new Promise(function(resolve, reject) { //Traitement asynchrone //Une fois le traitement terminé, appelez resolve ou reject });

Le constructeur Promise contient un paramètre et une fonction de rappel avec deux paramètres : resolve (résolution) et reject (rejet). Effectuez une opération (par exemple, asynchrone) dans la fonction de rappel. Si tout est normal, appelez resolve ; sinon, appelez reject.

Exemple

var myFirstPromise = new Promise(function(resolve, reject){ //Lorsque le code asynchrone s'exécute avec succès, nous appelons resolve(...) ; lorsqu'il échoue, nous appelons reject(...). //Dans cet exemple, nous utilisons setTimeout(...) pour simuler du code asynchrone ; dans du code réel, il peut s'agir de requêtes XHR ou de certaines méthodes d'API HTML5. setTimeout(function(){ resolve("Succès !"); //Code exécuté normalement ! }, 250); }); myFirstPromise.then(function(successMessage){ //La valeur de successMessage est la valeur transmise à l'appel de méthode resolve(...) ci-dessus. //Le paramètre successMessage ne doit pas nécessairement être de type chaîne ; ce n'est qu'un exemple. document.write("Youpi ! " + successMessage); });

Essayez-le vous-même »

Pour un objet Promise déjà instancié, vous pouvez appeler la méthode promise.then(), en passant les méthodes resolve et reject comme fonctions de rappel.

promise.then() est la méthode la plus couramment utilisée de Promise.

promise.then(onFulfilled, onRejected)

La promesse simplifie la gestion des erreurs. Le code ci-dessus peut également s'écrire comme ceci :

promise.then(onFulfilled).catch(onRejected)

Ajax avec Promise

Voici un exemple d'opération Ajax implémentée avec un objet Promise.

Exemple

function ajax(URL) { return new Promise(function (resolve, reject) { var req = new XMLHttpRequest(); req.open('GET', URL, true); req.onload = function () { if (req.status === 200) { resolve(req.responseText); } else { reject(new Error(req.statusText)); } }; req.onerror = function () { reject(new Error(req.statusText)); }; req.send(); }); } var URL = "/try/ajax/testpromise.php"; ajax(URL).then(function onFulfilled(value){ document.write('Contenu :' + value); }).catch(function onRejected(error){ document.write('Erreur :' + error); });

Essayez-le vous-même »

Dans le code ci-dessus, la méthode resolve et la méthode reject sont toutes deux appelées avec des arguments. Leurs arguments seront passés aux fonctions de rappel. L'argument de la méthode reject est généralement une instance de l'objet Error, tandis que l'argument de la méthode resolve, en plus d'une valeur normale, peut également être une autre instance de Promise, comme indiqué ci-dessous.

var p1 = new Promise(function(resolve, reject){ // ... du code }); var p2 = new Promise(function(resolve, reject){ // ... du code resolve(p1); })

Dans le code ci-dessus, p1 et p2 sont tous deux des instances de Promise, mais la méthode resolve de p2 prend p1 comme argument. À ce stade, l'état de p1 sera transmis à p2. Si l'état de p1 est en attente lors de l'appel, alors la fonction de rappel de p2 attendra que l'état de p1 change ; si l'état de p1 est déjà accompli ou rejeté, alors la fonction de rappel de p2 sera exécutée immédiatement.


Méthode Promise.prototype.then : opérations chaînées

La méthode Promise.prototype.then renvoie un nouvel objet Promise, de sorte qu'une syntaxe chaînée peut être utilisée.

getJSON("/posts.json").then(function(json) { return json.post; }).then(function(post) { // proceed });

Le code ci-dessus utilise la méthode then pour spécifier deux fonctions de rappel en séquence. Une fois la première fonction de rappel terminée, son résultat renvoyé sera transmis comme argument à la seconde fonction de rappel.

Si la fonction de rappel précédente renvoie un objet Promise, la fonction de rappel suivante attendra que cet objet Promise ait un résultat avant d'être appelée à son tour.

getJSON("/post/1.json").then(function(post) { return getJSON(post.commentURL); }).then(function(comments) { //Traiter les commentaires });

Cette conception permet de réécrire facilement les opérations asynchrones imbriquées, en passant du « développement horizontal » des fonctions de rappel au « développement vers le bas ».


Méthode Promise.prototype.catch : capturer les erreurs

La méthode Promise.prototype.catch est un alias de Promise.prototype.then(null, rejection), utilisée pour spécifier une fonction de rappel lorsqu'une erreur se produit.

getJSON("/posts.json").then(function(posts) { // du code }).catch(function(error) { //Gérer les erreurs qui se produisent lors de l'exécution de la fonction de rappel précédente console.log('Une erreur est survenue !', error); });

Les erreurs des objets Promise ont une nature « remontante » : elles se propagent vers l'arrière jusqu'à être capturées. Autrement dit, une erreur sera toujours capturée par l'instruction catch suivante.

getJSON("/post/1.json").then(function(post) { return getJSON(post.commentURL); }).then(function(comments) { // du code }).catch(function(error) { //Gérer les erreurs des deux premières fonctions de rappel });

méthode Promise.all, méthode Promise.race

La méthode Promise.all est utilisée pour envelopper plusieurs instances de Promise dans une nouvelle instance de Promise.

var p = Promise.all([p1,p2,p3]);

Dans le code ci-dessus, la méthode Promise.all accepte un tableau comme argument, et p1, p2 et p3 sont tous des instances d'objets Promise. (L'argument de la méthode Promise.all ne doit pas nécessairement être un tableau, mais il doit avoir une interface d'itérateur, et chaque membre qu'il retourne doit être une instance de Promise.)

L'état de p est déterminé par p1, p2 et p3, et il y a deux cas.

  • (1) Ce n'est que lorsque p1, p2 et p3 deviennent tous accomplis que l'état de p devient accompli. À ce moment-là, les valeurs de retour de p1, p2 et p3 forment un tableau qui est transmis à la fonction de rappel de p.
  • (2) Dès que l'un de p1, p2 et p3 est rejeté, l'état de p devient rejeté. À ce moment-là, la valeur de retour de la première instance rejetée sera transmise à la fonction de rappel de p.

Voici un exemple concret.

//Générer un tableau d'objets Promise var promises = [2, 3, 5, 7, 11, 13].map(function(id){ return getJSON("/post/" + id + ".json"); }); Promise.all(promises).then(function(posts) { // ... }).catch(function(reason){ // ... });

La méthode Promise.race enveloppe également plusieurs instances de Promise dans une nouvelle instance de Promise.

var p = Promise.race([p1,p2,p3]);

Dans le code ci-dessus, dès que l'un de p1, p2 et p3 est le premier à changer d'état, l'état de p change en conséquence. La valeur de retour de l'instance de Promise qui change d'état en premier est transmise à la valeur de retour de p.

Si les arguments de la méthode Promise.all et de la méthode Promise.race ne sont pas des instances de Promise, la méthode Promise.resolve décrite ci-dessous sera d'abord appelée pour convertir les arguments en instances de Promise, puis un traitement ultérieur sera effectué.


méthode Promise.resolve, méthode Promise.reject

Parfois, des objets existants doivent être convertis en objets Promise, et la méthode Promise.resolve sert à cela.

var jsPromise = Promise.resolve($.ajax('/whatever.json'));

Le code ci-dessus convertit l'objet deferred généré par jQuery en un nouvel objet Promise ES6.

Si l'argument de la méthode Promise.resolve n'est pas un objet avec une méthode then (également appelé objet thenable), elle renvoie un nouvel objet Promise dont l'état est fulfilled.

var p = Promise.resolve('Hello'); p.then(function (s){ console.log(s) }); // Hello

Le code ci-dessus crée une instance p d'un nouvel objet Promise, dont l'état est fulfilled, donc la fonction de rappel s'exécutera immédiatement. L'argument de la méthode Promise.resolve est le paramètre de la fonction de rappel.

Si l'argument de la méthode Promise.resolve est une instance d'un objet Promise, il sera renvoyé tel quel.

La méthode Promise.reject(reason) renvoie également une nouvelle instance de Promise, dont l'état est rejected. Le paramètre reason de la méthode Promise.reject sera transmis à la fonction de rappel de l'instance.

var p = Promise.reject('Une erreur s'est produite.'); p.then(null, function (s){ console.log(s) }); //Une erreur s'est produite.

Le code ci-dessus crée une instance d'un objet Promise, dont l'état est rejected, et la fonction de rappel s'exécutera immédiatement.

Liens de référence :

  • https://wohugb.gitbooks.io/ecmascript-6/content/docs/promise.html
  • https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise
  • http://qingtong234.github.io/2016/01/14/javascript%E4%B8%AD%E7%9A%84promise%E5%BC%82%E6%AD%A5%E7%BC%96%E7%A8%8B-1/