Explication détaillée de l'utilisation de Promise en JavaScript avec des exemples_Connaissances de base

Extrait – Le SDK Parse JavaScript fournit désormais un mode Promises compatible jquery qui prend en charge la plupart des méthodes asynchrones, alors qu'est-ce que cela signifie, vous comprendrez après avoir lu ce qui suit.

Les « promesses » représentent le prochain grand paradigme de la programmation JavaScript, mais comprendre pourquoi elles sont si formidables n'est pas simple. Son essence est qu’une promesse représente le résultat d’une tâche, qui peut ou non être réalisée. La seule interface requise par le mode Promise est d'appeler la méthode then, qui peut être utilisée pour enregistrer une fonction de rappel appelée lorsque la promesse est terminée ou échouée. Ceci est généralement discuté dans CommonJS Promises/A proposition. Par exemple, je souhaite enregistrer un objet Prase.Object. Il s'agit d'une opération asynchrone. Dans l'ancien paradigme de rappel, votre code pourrait être écrit comme ceci : .

object.save({ key: value }, {
 success:function(object) {
  // the object was saved.
 },
 error:function(object, error) {
  // saving the object failed.
 }
});
在新的Promise范式中，同样的代码你可以这样写:
 
object.save({ key: value }).then(
 function(object) {
  // the object was saved.
 },
 function(error) {
  // saving the object failed.
 });

Pas beaucoup de différence ? Alors, quel est le problème ? Eh bien, le véritable pouvoir des promesses réside dans l'enchaînement de multiples. Lorsque promise.then(func) est appelé, une nouvelle promesse est renvoyée, qui n'est exécutée que lorsque la précédente est terminée. Mais il y a un cas particulier ici, si mon rappel renvoie une nouvelle promesse jusqu'à ce moment-là, alors la promesse renvoyée jusqu'à ce moment-là ne sera pas exécutée tant que l'exécution du rappel n'est pas terminée. Veuillez vous référer à Promises/A pour plus de détails. Il s'agit d'une règle complexe que nous pouvons comprendre plus clairement à travers des exemples.

Supposons que vous écriviez un code de connexion qui recherche un objet puis le met à jour. Dans l'ancien paradigme de rappel, vous pouviez utiliser la complétion du code pyramidal :

Parse.User.logIn("user","pass", {
 success:function(user) {
  query.find({
   success:function(results) {
    results[0].save({ key: value }, {
     success:function(result) {
      // the object was saved.
     }
    });
   }
  });
 }
});

Cela semble déjà ridicule, mais ce qui est encore plus ridicule, c'est qu'il n'y a même pas de gestion des erreurs. Mais la structure de la chaîne de promesses rend le code plus confortable :

Parse.User.logIn("user","pass").then(function(user) {
 returnquery.find();
}).then(function(results) {
 returnresults[0].save({ key: value });
}).then(function(result) {
 // the object was saved.
});

Wow ! Il y en a tellement !

Gestion des erreurs

Le code ci-dessus n'a pas ajouté de gestion des erreurs alors qu'il était simple, mais après l'avoir ajouté, vous constaterez que c'est un gâchis dans l'ancien code de rappel :

Parse.User.logIn("user","pass", {
 success:function(user) {
  query.find({
   success:function(results) {
    results[0].save({ key: value }, {
     success:function(result) {
      // the object was saved.
     },
     error:function(result, error) {
      // An error occurred.
     }
    });
   },
   error:function(error) {
    // An error occurred.
   }
  });
 },
 error:function(user, error) {
  // An error occurred.
 }
});

Puisque les promesses savent si le traitement est terminé, elles peuvent transmettre des erreurs sans exécuter de rappel jusqu'à ce qu'une erreur soit rencontrée. Par exemple, le code ci-dessus peut être abrégé comme suit :

Parse.User.logIn("user","pass").then(function(user) {
 returnquery.find();
}).then(function(results) {
 returnresults[0].save({ key: value });
}).then(function(result) {
 // the object was saved.
},function(error) {
 // there was some error.
});

Habituellement, les développeurs pensent qu'un échec de promesse asynchrone équivaut à lever une exception. En fait, si un rappel renvoie une erreur, la promesse renverra un message d'échec. Transmettre l'erreur au prochain gestionnaire d'erreurs disponible équivaut à lever une exception jusqu'à ce qu'elle soit interceptée.

jQuery, Backbone et Parse

Il existe de nombreuses bibliothèques qui mettent en œuvre des promesses que les développeurs peuvent utiliser. Comme Deferred de jQuery, WinJS.Promise de Microsoft, when.js, q et dojo.Deferred.

Cependant, il y a quelque chose d’intéressant à savoir. Vous pouvez lire la longue et fascinante discussion sur la demande d'extraction de jQuery ici. L'implémentation de jQuery ne suit pas complètement les règles de Promises/A. Lors des expérimentations, j'ai trouvé qu'il n'y avait qu'une seule différence. Si un gestionnaire d'erreurs renvoie d'autres informations que le simple renvoi d'une promesse, la plupart des implémentations envisageront de gérer l'erreur sans la propager. Cependant, jquery ne pense pas à gérer cette erreur ici et la transmet à la place. Même si les promesses des différents systèmes devraient se mélanger harmonieusement, vous devez néanmoins rester prudent. Un problème potentiel est que les promesses sont renvoyées (en remplacement des valeurs d'origine) dans le gestionnaire d'erreurs, puisqu'elles sont traitées de la même manière.

doFailingAsync().then(function() {
 // doFailingAsync doesn't succeed.
},function(error) {
 // Try to handle the error.
 return"It's all good.";
}).then(function(result) {
 // Non-jQuery implementations will reach this with result === "It's all good.".
},function(error) {
 // jQuery will reach this with error === "It's all good.".
});

Dans la dernière version de Backbone 0.9.10, les méthodes asynchrones renvoient désormais un jqXHR, qui est un type de promesse jQuery. L'un des objectifs du SDK Parse JavaScript est d'être aussi compatible que possible avec Backbone. Nous ne pouvons pas renvoyer un jqXHR car il ne fonctionne pas bien avec
Cloud Code. Par conséquent, nous ne le faisons pas tous. ajoutez une classe Parse.Promise, elle suit la norme jQuery Deferred. Parse JavaScript SDKLa dernière version a mis à jour toutes les méthodes asynchrones pour prendre en charge ces nouveaux objets, et les anciennes méthodes de rappel sont toujours disponibles. Mais sur la base des exemples énumérés ci-dessus, je pense que vous préférez la nouvelle méthode. Alors essayez les promesses !