Avant de commencer l'introduction formelle, nous voulons voir à quoi ressemble JavaScript:
La copie de code est la suivante:
var p = nouvelle promesse (fonction (résoudre, rejeter) {
Résolve ("Hello World");
});
P. THEL (FONCTION (STR) {
alerte (str);
});
1. Ensuite () renvoie une promesse fourchue
Quelle est la différence entre les deux codes suivants?
La copie de code est la suivante:
// montre un
var p = nouvelle promesse (/*...*/);
P. puis (func1);
P. puis (func2);
// Exposition B
var p = nouvelle promesse (/*...*/);
P. Then (FUNC1)
.Then (func2);
Si vous considérez soigneusement les deux éléments de code ci-dessus équivalents, les promesses ne sont qu'un tableau unidimensionnel de fonctions de rappel. Cependant, ce n'est pas le cas. Chacun () appelle () un appel renvoie une promesse fourchue. Par conséquent, dans l'exposition, si func1 () lance une exception, func2 () est toujours appelé normalement.
Dans expositionb, si func1 () lance une erreur, fun2 () ne sera pas appelé parce que le premier appel renvoie une nouvelle promesse, qui sera rejetée dans func1 (). Le résultat est le saut de func2 ().
Résumé: Les promesses peuvent être fourches dans plusieurs chemins, similaires aux organigrammes complexes.
2. Le rappel doit passer le résultat
Qu'est-ce qui obtiendra un avertissement lorsque vous exécutez le code suivant?
La copie de code est la suivante:
var p = nouvelle promesse (fonction (résoudre, rejeter) {
Résolve ("Hello World");
});
P.Then (fonction (str) {})
.Then (fonction (str) {
alerte (str);
});
L'alerte dans la seconde alors () ne montre rien. En effet, la fonction de rappel, dans le contexte de la promesse, il n'y a pas de fonction de rappel car le résultat change. Promise s'attend à ce que votre rappel renvoie le même résultat ou un résultat de remplacement, qui est ensuite transmis au rappel suivant.
Semblable à l'utilisation d'ADPATAT pour modifier les résultats, comme suit:
La copie de code est la suivante:
var feetToMetRes = fonction (ft) {return ft * 12 * 0,0254};
var p = nouvelle promesse (/*...*/);
P. puis (feettomètres)
.Then (fonction (mètres) {
alerte (mètres);
});
3. Seules les exceptions de la couche précédente peuvent être capturées
Quelle est la différence entre ces deux pièces de code?
La copie de code est la suivante:
// montre un
Nouvelle promesse (fonction (résolution, rejet) {
Résolve ("Hello World");
})
.alors(
fonction (str) {
lancer une nouvelle erreur ("euh oh");
},
indéfini
)
.alors(
indéfini,
fonction (erreur) {
alert (erreur);
}
));
// Exposition B
Nouvelle promesse (fonction (résolution, rejet) {
Résolve ("Hello World");
})
.alors(
fonction (str) {
lancer une nouvelle erreur ("euh oh");
},
fonction (erreur) {
alert (erreur);
}
));
Dans le premier morceau de code, l'exception dans le premier alors () est lancée et sera capturée par la seconde alors (), et l'avertissement "euh oh" sera déclenché. Ce guide uniquement des exceptions au niveau précédent sera capturé.
Dans le deuxième morceau de code, la fonction de rappel et la fonction de rappel d'erreur sont au même niveau, ce qui signifie que lorsqu'une exception est lancée dans le rappel, elle ne sera pas capturée. En fait, le rappel d'erreur du deuxième code ne sera lancé que si la promesse est rejetée ou si la promesse elle-même est erronée.
4. Les erreurs peuvent être restaurées
Dans une fonction de rappel d'erreur, si vous ne remémorez pas l'erreur, Promise suppose que vous vous êtes remis de l'erreur et inversé à un état résolu. Dans l'exemple suivant, "Je suis enregistré" sera affiché car le rappel d'erreur dans le premier alors () n'a pas remonté l'exception.
La copie de code est la suivante:
var p = nouvelle promesse (fonction (résoudre, rejeter) {
rejeter (nouvelle erreur ("pebkac"));
});
P. then (
indéfini,
fonction (erreur) {}
)
.alors(
fonction (str) {
alert ("Je suis sauvé!");
},
fonction (erreur) {
alert ("mauvais ordinateur!");
}
));
La promesse peut être considérée comme une couche sur un oignon. Chacun alors () ajoute un autre niveau à l'oignon. Chaque niveau représente une activité traitée. Une fois la hiérarchie terminée, le résultat est considéré comme fixé et prêt pour la prochaine hiérarchie.
5. Les promesses peuvent être suspendues
Parce que vous êtes prêt à exécuter dans une méthode alors (), cela ne signifie pas que vous ne pouvez pas faire une pause et en exécuter d'autres à l'avance. Afin de mettre en pause la promesse actuelle, ou de laisser attendre une autre promesse terminée, renvoyez simplement une autre promesse dans alors ().
La copie de code est la suivante:
var p = nouvelle promesse (/*...*/);
P. THEL (FONCTION (STR) {
if (! loggedin) {
retourner une nouvelle promesse (/*...*/);
}
})
.Then (fonction (str) {
alerte ("fait.");
})
Dans le code précédent, l'invite n'apparaîtra pas tant que la nouvelle promesse sera analysée. Il s'agit d'un moyen pratique d'introduire plus de dépendances dans le chemin de code asynchrone existant. Par exemple, vous pouvez constater que la session utilisateur a un délai d'expiration et que vous souhaiterez peut-être initialiser la deuxième connexion avant de continuer avec le chemin de code précédent.
6. Les promesses résolues ne seront pas exécutées immédiatement
Obtenez-vous une boîte d'invite lors de l'exécution du code suivant?
La copie de code est la suivante:
fonction runme () {
var i = 0;
nouvelle promesse (fonction (résolution) {
résoudre();
})
.Then (function () {
i + = 2;
});
alerte (i);
}
Étant donné que la promesse est analysée immédiatement et que la méthode () est exécutée immédiatement, vous pouvez penser que Invite 2 sera sondé. Cependant, la définition de promesse nécessite que tous les appels soient forcés asynchrones. Par conséquent, l'invite sera générée avant d'être modifiée.