Depuis jQuery 1.8 .then a le même comportement que .pipe:
La dépréciation de l'Avis: Que de jQuery 1.8, l' deferred.pipe() méthode est obsolète. L' deferred.then() méthode, qui le remplace, doit être utilisé à la place.
et
Comme de jQuery 1.8, l' deferred.then() méthode retourne une nouvelle promesse qui permet de filtrer le statut et les valeurs reportées au travers d'une fonction, en remplacement de la désormais obsolète deferred.pipe() méthode.
Les exemples ci-dessous peuvent encore être utile à certains.
Ils servent à des fins différentes:
.then() doit être utilisé chaque fois que vous voulez travailler avec le résultat de ce processus, à savoir que la documentation dit, lorsque le report de l'objet est résolu ou rejeté. C'est le même que l'utilisation de .done() ou .fail().
-
Vous pouvez utiliser .pipe() de (pré)filtre le résultat d'une certaine manière. La valeur de retour d'un rappel à l' .pipe() sera passé en argument de la done et fail rappels. Il peut aussi retourner une autre différée objet et les rappels suivants seront enregistrés sur cette différé.
Ce n'est pas le cas avec .then() (ou .done(), .fail()), les valeurs de retour des rappels enregistrés sont tout simplement ignorées.
Donc, ce n'est pas que vous utilisez soit .then() ou .pipe(). Vous pourriez utiliser .pipe() pour les mêmes fins que l' .then() , mais l'inverse ne tient pas.
Exemple 1
Le résultat d'une opération est un ensemble d'objets:
[{value: 2}, {value: 4}, {value: 6}]
et vous voulez calculer le minimum et le maximum des valeurs. Supposons que nous utilisons deux done rappels:
deferred.then(function(result) {
// result = [{value: 2}, {value: 4}, {value: 6}]
var values = [];
for(var i = 0, len = result.length; i < len; i++) {
values.push(result[i].value);
}
var min = Math.min.apply(Math, values);
/* do something with "min" */
}).then(function(result) {
// result = [{value: 2}, {value: 4}, {value: 6}]
var values = [];
for(var i = 0, len = result.length; i < len; i++) {
values.push(result[i].value);
}
var max = Math.max.apply(Math, values);
/* do something with "max" */
});
Dans les deux cas, vous devez parcourir la liste et d'en extraire la valeur de chaque objet.
Ne serait-il pas mieux de faire en quelque sorte extraire les valeurs d'avance de sorte que vous n'avez pas à le faire dans les deux rappels individuellement? Oui! Et c'est ce que l'on peut utiliser .pipe() pour:
deferred.pipe(function(result) {
// result = [{value: 2}, {value: 4}, {value: 6}]
var values = [];
for(var i = 0, len = result.length; i < len; i++) {
values.push(result[i].value);
}
return values; // [2, 4, 6]
}).then(function(result) {
// result = [2, 4, 6]
var min = Math.min.apply(Math, result);
/* do something with "min" */
}).then(function(result) {
// result = [2, 4, 6]
var max = Math.max.apply(Math, result);
/* do something with "max" */
});
Bien évidemment, ceci est un exemple, et il ya de nombreux différents (peut-être mieux) des moyens pour résoudre ce problème, mais j'espère que ça illustre bien le propos.
Exemple 2
Examiner les appels Ajax. Parfois, vous voulez lancer un appel Ajax après une précédente est terminée. Une façon est de faire l'appel de la deuxième à l'intérieur d'un done de rappel:
$.ajax(...).done(function() {
// executed after first Ajax
$.ajax(...).done(function() {
// executed after second call
});
});
Maintenant, supposons que vous souhaitez dissocier votre code et de mettre ces deux appels Ajax à l'intérieur d'une fonction:
function makeCalls() {
// here we return the return value of `$.ajax().done()`, which
// is the same deferred object as returned by `$.ajax()` alone
return $.ajax(...).done(function() {
// executed after first call
$.ajax(...).done(function() {
// executed after second call
});
});
}
Vous souhaitez utiliser le différée objet de permettre à d'autres de code qui appelle makeCalls d'attacher des rappels pour le deuxième appel Ajax, mais
makeCalls().done(function() {
// this is executed after the first Ajax call
});
n'aurait pas l'effet désiré que le deuxième appel est effectué à l'intérieur d'un done de rappel et ne sont pas accessibles de l'extérieur.
La solution serait d'utiliser des .pipe() à la place:
function makeCalls() {
// here we return the return value of `$.ajax().pipe()`, which is
// a new deferred/promise object and connected to the one returned
// by the callback passed to `pipe`
return $.ajax(...).pipe(function() {
// executed after first call
return $.ajax(...).done(function() {
// executed after second call
});
});
}
makeCalls().done(function() {
// this is executed after the second Ajax call
});
En utilisant .pipe() vous pouvez maintenant possible d'ajouter des rappels à l' "intérieure" appel Ajax sans exposer le débit réel/ordre des appels.
En général, les différés d'objets fournir un moyen intéressant de dissocier votre code :)
