Depuis jQuery 1.8 .then se comporte de la même façon que .pipe :

avis de dépréciation: à partir de jQuery 1.8, la méthode deferred.pipe() est dépréciée. La méthode deferred.then() , qui la remplace, devrait être utilisée à la place.

et

à partir de jQuery 1.8 , la méthode deferred.then() renvoie une nouvelle promesse qui peut filtrer le statut et les valeurs d'un différé à travers une fonction, en remplaçant la méthode maintenant dépréciée deferred.pipe() .

les exemples ci-dessous peuvent encore être utiles à certains.

---

ils ont des buts différents:

• .then() doit être utilisé chaque fois que vous voulez travailler avec le résultat du processus, c.-à-d. comme la documentation dit, lorsque l'objet différé est résolu ou rejeté. Il est identique à l'utilisation de .done() ou .fail() .

• Vous pouvez utiliser .pipe() à (pré) filtre le résultat d'une certaine manière. La valeur de retour d'un callback vers .pipe() sera transmise comme argument aux callbacks done et fail . Il peut également retourner un autre objet différé et les callbacks suivants seront enregistrés sur ce différé.

  ce n'est pas le cas avec .then() (ou .done() , .fail() ), les valeurs de retour des callbacks enregistrés sont simplement ignorées.

ce n'est donc pas que vous utilisez soit .then() ou .pipe() . Vous pourrait utiliser .pipe() pour les mêmes fins que .then() mais l'inverse ne tient pas.

---

exemple 1

le résultat d'une certaine opération est un tableau d'objets:

[{value: 2}, {value: 4}, {value: 6}]

et vous voulez calculer le minimum et le maximum des valeurs. Supposons que nous utilisions deux done callbacks:

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 itérer sur la liste et extraire la valeur de chaque objet.

ne vaudrait-il pas mieux extraire valeurs à l'avance afin que vous ne devez pas faire cela dans les deux callbacks individuellement? Oui! Et c'est ce que nous pouvons 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" */

});

évidemment c'est un exemple inventé et il y a beaucoup de différentes (peut-être mieux) façons de résoudre ce problème, mais j'espère qu'il illustre le point.

---

exemple 2

considère les appels Ajax. Parfois, vous voulez lancer un appel Ajax après un le précédent est terminé. Une façon est de faire le deuxième appel à l'intérieur d'un done callback:

$.ajax(...).done(function() {
    // executed after first Ajax
    $.ajax(...).done(function() {
        // executed after second call
    });
});

laisse maintenant supposer que vous voulez découpler votre code et mettre ces deux appels Ajax dans 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 aimeriez utiliser l'objet différé pour permettre à un autre code qui appelle makeCalls de joindre les callbacks pour le second appel Ajax, mais

makeCalls().done(function() {
    // this is executed after the first Ajax call
});

n'aurait pas l'effet désiré puisque le second appel est effectué à l'intérieur d'un done et non accessible de l'extérieur.

la solution serait d'utiliser .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 permettre d'ajouter des callbacks à L'appel Ajax" interne " sans exposer le flux/ordre réel des appels.

---

en général, les articles différés fournissent intéressante façon de découpler votre code:)