Le mode de programmation prometteur est également appelé à l'époque, qui peut être compris comme une exécution après retard. Chaque promesse a une interface unique appelée alors, et lorsque la promesse échoue ou réussit, elle fera un rappel. Il représente un résultat d'opération qui peut fonctionner pendant longtemps et ne doit pas nécessairement être terminé. Ce modèle ne bloque pas et n'attend pas les opérations à long terme, mais renvoie un objet qui représente le résultat promis.
De nombreuses bibliothèques JavaScript actuelles (comme JQuery et Dojo, AngularJS) ajoutent cette abstraction appelée promesse. Grâce à ces bibliothèques, les développeurs peuvent utiliser le mode Promise dans la programmation réelle.
Ci-dessous, nous utiliserons JQuery comme exemple pour discuter de la façon dont les bibliothèques JavaScript utilisent le mode Promise pour gérer le traitement asynchrone, qui est en fait pour fournir un support tolérant aux pannes via des rappels. Lorsqu'une opération réussit ou échoue ou en tout cas, le rappel correspondant est exécuté et essayez de gérer toutes les situations possibles dans une certaine logique.
Tout d'abord, jetons un coup d'œil sur le fonctionnement généralement de JQuery:
La copie de code est la suivante:
var $ info = $ ("# info");
$ .ajax ({
URL: "/ echo / json /",
data: {json: json.stringify ({"name": "someValue"})},
Type: "Post",
Succès: fonction (réponse)
{
$ info.Text (réponse.name);
}
});
Dans cet exemple, vous pouvez voir que lorsque le paramètre réussit, un rappel sera spécifié, ce qui est une bonne méthode de rappel. Ce n'est pas une promesse, et la documentation officielle JQuery ne recommande plus cette méthode (http://api.jquery.com/jquery.ajax/#jqxhr). Lorsque l'appel AJAX se termine, il exécute la fonction de réussite. Selon les opérations asynchrones utilisées par la bibliothèque, vous pouvez utiliser divers rappels différents (c'est-à-dire que la tâche soit réussie ou non, elle sera rappelée et répondra). L'utilisation du mode Promise simplifie ce processus, les opérations asynchrones nécessitent uniquement le renvoi d'un appel d'objet. Cette promesse vous permet d'appeler une méthode appelée puis vous permet de spécifier le nombre de fonctions du rappel.
Jetons un coup d'œil à la façon dont JQuery tient une promesse:
La copie de code est la suivante:
var $ info = $ ("# info");
$ .ajax ({
URL: "/ echo / json /",
données: {
JSON: JSON.Strifify ({
"Nom": "SomeValue"
})
},
Type: "Post"
})
.Then (fonction (réponse) {
$ info.Text (réponse.name);
});
L'objet jQuery Ajax implémente le mode Promise en renvoyant l'objet XHR, afin que nous puissions appeler la méthode alors. L'avantage de le faire est que vous pouvez chaîner les appels et mettre en œuvre des opérations indépendantes, comme indiqué ci-dessous:
La copie de code est la suivante:
var $ info = $ ("# info");
$ .ajax ({
URL: "/ echo / json /",
données: {
JSON: JSON.Strifify ({
"Nom": "SomeValue"
})
},
Type: "Post"
})
.Then (fonction (réponse) {
$ info.Text (réponse.name);
})
.Then (function () {
$ info.append ("... plus");
})
.Done (function () {
$ info.append ("... enfin!");
});
Les opérations asynchrones deviennent très faciles car de nombreuses bibliothèques commencent à utiliser le mode Promise. Mais si vous pensez du point de vue opposé, à quoi ressemblerait-il? L'un des modèles très importants est que la fonction peut accepter deux fonctions, l'une est un rappel lorsqu'il réussit, et l'autre est un rappel lors de l'échec.
La copie de code est la suivante:
var $ info = $ ("# info");
$ .ajax ({
// Changer l'URL pour voir l'erreur se produire
URL: "/ echo / json /",
données: {
JSON: JSON.Strifify ({
"Nom": "SomeValue"
})
},
Type: "Post"
})
.Then (fonction (réponse) {
// succès
$ info.Text (réponse.name);
},
fonction () {
// échec
$ info.text ("Les mauvaises choses arrivent aux bons développeurs");
})
.Always (function () {
$ info.append ("... enfin");
});
Il convient de noter que dans jQuery, qu'il soit réussi ou échoué, nous utiliserons un appel pour spécifier ce que nous voulons appeler.
En fait, vous pouvez également écrire ceci ici, qui est également la méthode recommandée dans le document officiel de JQuery:
La copie de code est la suivante:
var $ info = $ ("# info");
$ .ajax ({
// Changer l'URL pour voir l'erreur se produire
URL: "/ echo / json /",
données: {
JSON: JSON.Strifify ({
"Nom": "SomeValue"
})
},
Type: "Post"
})
.Done (fonction (réponse) {
// succès
$ info.Text (réponse.name);
}). fail (function () {
// échec
$ info.text ("Les mauvaises choses arrivent aux bons développeurs");
})
.Always (function () {
$ info.append ("... enfin");
});
Jetons un coup d'œil à la façon dont AngularJS utilise le mode de promesse:
La copie de code est la suivante:
var m = angular.module ("myApp", []);
m.factory ("dataService", fonction ($ q) {
fonction _Callme () {
var d = $ q.defer ();
setTimeout (function () {
D.Resolve ();
//defer.reject ();
}, 100);
retour d.promes;
}
retour {
callme: _Callme
};
});
fonction myctrl ($ scope, dataService) {
$ scope.name = "Aucun";
$ scope.isbusy = true;
dataService.callme ()
.Then (function () {
// Réussi
$ scope.name = "succès";
},
fonction () {
// échec
$ scope.name = "échec";
})
.Then (function () {
// comme une clause enfin
$ scope.isbusy = false;
});
}
Vous pouvez essayer ces exemples dans JSFiddle et voir quels effets seront produits. Utiliser la promesse de fonctionner asynchrone est un moyen très simple, et il peut également simplifier votre code. C'est en effet un bon moyen de tuer deux oiseaux avec une pierre.
Pour plus de présentations et d'exemples sur la promesse, vous pouvez vous rendre sur le site officiel (http://www.promisejs.org/).