Analyse de l'utilisation de Nodejs Promise

JavaScript est caractérisé par l'asynchrone. JavaScript ne peut pas attendre. Si vous implémentez quelque chose qui doit être attendu, vous ne pouvez pas vous arrêter là et attendre que le résultat revienne. Au contraire, l'essentiel consiste à utiliser le rappel de rappel: vous définissez une fonction, qui ne peut être appelée que jusqu'à ce que le résultat soit disponible.

Ce modèle de rappel n'a aucun problème avec une bonne organisation de code, mais elle peut également résoudre de nombreux problèmes en passant du rappel d'origine à promettre. Traitez la promesse comme un conteneur de données standard, qui simplifiera votre organisation de code et deviendra une architecture basée sur les promesses.

Qu'est-ce qu'une promesse?

Une promesse est un objet avec la méthode ".then ()", qui représente le résultat d'une opération qui n'est peut-être pas encore connue. Peu importe qui accède à cet objet, il peut utiliser la méthode ".then ()" pour ajouter un rappel pour attendre un rappel pour attendre que l'opération ait un résultat ou un échec réussi.

Alors, pourquoi les avantages de faire cela mieux que les rappels? Le mode de rappel standard nécessite que nous fournissions des fonctions de rappel en même temps lors du traitement des demandes:

 request (URL, fonction (erreur, réponse) {// gérer le succès ou l'erreur.}); DoSomethingELSE ();

Malheureusement, ce code signifie que cette fonction de demande ne sait pas quand elle sera terminée par elle-même, et bien sûr, elle n'est pas nécessaire. Nous passons enfin le résultat par le rappel. Cela fait que plusieurs rappels forment des rappels imbriqués ou des pièges de rappel.

 QuerytheDatabase (Query, fonction (erreur, résultat) {request (URL, fonction (erreur, réponse) {dosomethingElSE (réponse, fonction (erreur, résultat) {doanothething (résultat, fonction (erreur, résultat) {request (an autre, fonction (erreur, réponse) {...});});});});});

Promise peut résoudre ce problème en permettant au code de bas niveau de créer une demande, puis à renvoyer un objet, qui représente une opération inachevée, permettant à l'appelant de décider quels rappels doivent être ajoutés.

Qu'est-ce qu'une promesse?

La promesse est une abstraction de la programmation asynchrone. Il s'agit d'un objet proxy qui renvoie une valeur ou lance une exception. Généralement, les objets prometteurs ont une méthode alors. Cette méthode est alors de savoir comment nous obtenons la valeur de retour (la valeur du résultat de la mise en œuvre réussie de la promesse est appelée épanouissement) ou jetez une exception (la raison de rejeter la promesse est appelée rejet). Ensuite, utilisez deux rappels facultatifs comme paramètres, que nous pouvons appeler onful et rejeté:

var promesse = dosomethingaync ()

promesse.

Lorsque cette promesse est résolue, c'est-à-dire une fois le processus asynchrone terminé, il est appelé sur le plan et sur les projections.

Par conséquent, une promesse a les trois états différents suivants:

■ En attente à promettre - État de promesse initial

■ Engagement de mise en œuvre réalisé - un engagement à succès État de mise en œuvre

■ Rejet rejeté de l'engagement - un État où la promesse a échoué

En prenant le fichier de lecture comme un cas, ce qui suit est ce qui devrait être fait après avoir lu le fichier à l'aide d'un rappel (imprimerie de sortie):

 readFile (fonction (err, data) {if (err) return console.error (err) console.log (data)})

Si notre fonction ReadFile renvoie une promesse, nous pouvons implémenter la même logique que celle-ci (impression de sortie):

var promesse = readFile ()

promesse.then (console.log, console.error)

Ici, nous avons une promesse de valeur qui représente une opération asynchrone. Nous pouvons passer cette valeur de valeur tout le temps. Quiconque accède à cette valeur peut être utilisé pour le consommer. Peu importe que l'opération asynchrone représentée par cette valeur soit terminée ou non terminée, nous pouvons également nous assurer que le résultat asynchrone ne changera pas, car l'opération asynchrone représentée par cette promesse ne sera exécutée qu'une seule fois, et l'état est rempli ou rejeté.

Comprendre la promesse

La promesse peut être différente de l'intuition quotidienne. Afin de le comprendre, certains principes importants doivent être gardés à l'esprit: .Then () renvoie toujours une nouvelle promesse. Comme indiqué dans le code suivant:

var promesse = readFile ()

var promest2 = promest.then (readanotherfile, console.error)

Ici, le paramètre alors Readanotherfile, Console.Error représente l'action sur la durée après la réussite de l'opération asynchrone ou l'action sur le succès après le succès de l'échec. C'est-à-dire, après l'exécution de la fonction ReadAnotherFile, sinon l'enregistrement d'impression défaillant est incorrect. Cette implémentation n'est possible que de deux manières.

Regardons le code suivant:

 var promes promesse = readFile () var promes promest2 = promest.phes (function (data) {return readanotherfile () // Si readFile réussit, exécutez readanotherfile}, fonction (err) {console.error (err) // si readfile n'est pas réussi, enregistrez-le, mais exécutez ReadanotherFile. Résultat d'exécution de la fonction readanotherfile

Parce que ensuite renvoie une promesse, cela signifie que la promesse peut être dépensée en trafiquant la chaîne en série, ce qui peut éviter l'enfer de rappel:

 readFile () .Then (readanotherfile) .Pes puis (dosomethingelse) .Then (...)

Il y a deux parties de la règle de promesse qui doivent être séparées:

(1) .Then () renvoie toujours une nouvelle promesse. Chaque fois que vous l'appelez, peu importe le rappel, car .then () vous donne déjà une promesse avant que le rappel ne soit appelé. Le comportement du rappel affecte uniquement la mise en œuvre de la promesse prometteuse. Si le rappel renvoie une valeur, la promesse utilisera cette valeur. Si cette valeur est une promesse, renvoyez la valeur après l'implémentation de la promesse à cette valeur. Si le rappel lance une erreur, la promesse rejetera l'erreur.

(2) La promesse rendue par .phe () est une nouvelle promesse, qui est différente de celle. Puis () appelé. La longue chaîne de promesses cache parfois le fait que, quoi qu'il arrive, chaque appel () produira une nouvelle promesse. Ce que vous devez noter ici, c'est que ce que vous devez vraiment considérer, c'est que votre dernier appel. Puis () peut représenter l'échec, donc si vous n'attrapez pas cet échec, il est facile de faire disparaître votre exception d'erreur.

Certaines personnes pensent que l'appel de chaîne.

 fonction getTtasks () {return $ http.get ('http://example.com/api/v1/tasks') .then (fonction (réponse) {return réponse.data;});} function getMyTasks () {return getTasks () .Then (fonction (tasks) {return filtertasks (tasks, {propriétaire: user. });}

Dans cet exemple, les deux fonctions obtiennent chacune une promesse, portant une fonction de rappel.

Promesse intéressante

La même promesse peut accepter n'importe quel nombre de rappels. Lorsqu'une promesse est résolue et implémentée, toutes les fonctions de rappel seront appelées. De plus, une promesse peut même accepter un nouveau rappel après avoir été résolu et mis en œuvre. Ces rappels peuvent être appelés de manière normale, ce qui nous permet d'utiliser des rappels pour implémenter une forme simple de cache:

 VAR TASKSPROMISE; function getTasks () {taskPromise = taskPromise || getTasksFromTheServer (); Retour Programme de tâche;}

Dans ce cas, la fonction getTasks () peut être appelée n'importe quel nombre de fois, il renvoie toujours la promesse des dents de cuivre, où la fonction getTasksFromTheServer () n'est appelée qu'une seule fois.

L'utilisation de Nodejs Promise ci-dessus est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.