jQuery Deferreda deux fonctions qui peuvent être utilisées pour implémenter le chaînage asynchrone des fonctions:

then()

deferred.then( doneCallbacks, failCallbacks ) Returns: Deferred

doneCallbacks Une fonction, ou un tableau de fonctions, appelée lorsque le différé est résolu.
failCallbacks Une fonction, ou un tableau de fonctions, appelée lorsque le Deferred est rejeté.

pipe()

deferred.pipe( [doneFilter] [, failFilter] ) Returns: Promise

doneFilter Une fonction facultative qui est appelée lorsque le différé est résolu.
failFilter Une fonction facultative qui est appelée lorsque le différé est rejeté.

Je sais que cela then()fait un peu plus longtemps que pipe()ce dernier doit ajouter un avantage supplémentaire, mais quelle est la différence précisément m'échappe. Les deux prennent à peu près les mêmes paramètres de rappel bien qu'ils diffèrent par leur nom et la différence entre renvoyer un Deferredet renvoyer un Promisesemble légère.

J'ai lu les documents officiels à maintes reprises, mais je les trouve toujours trop "denses" pour vraiment comprendre et la recherche a donné lieu à de nombreuses discussions sur l'une ou l'autre fonctionnalité, mais je n'ai rien trouvé qui clarifie vraiment les différentes avantages et inconvénients de chacun.

Alors, quand est-il préférable de l'utiliser thenet quand est-il préférable de l'utiliser pipe?

Une addition

L'excellente réponse de Felix a vraiment aidé à clarifier en quoi ces deux fonctions diffèrent. Mais je me demande s'il y a des moments où la fonctionnalité de then()est préférable à celle de pipe().

Il est évident que pipe()c'est plus puissant que then()et il semble que le premier puisse faire tout ce que le second peut faire. Une des raisons d'utiliser then()pourrait être que son nom reflète son rôle en tant que terminaison d'une chaîne de fonctions traitant les mêmes données.

Mais y a-t-il un cas d'utilisation qui nécessite then()le retour de l'original Deferredqui ne peut pas être fait pipe()car il renvoie un nouveauPromise ?

Puisque jQuery 1.8 .then se comporte de la même manière que .pipe:

Avis de deferred.pipe()dépréciation : à partir de jQuery 1.8, la méthode est obsolète. La deferred.then()méthode, qui la remplace, doit être utilisée à la place.

et

À partir de jQuery 1.8 , la deferred.then()méthode retourne une nouvelle promesse qui peut filtrer le statut et les valeurs d'un différé via une fonction, remplaçant la deferred.pipe()méthode désormais obsolète .

Les exemples ci-dessous pourraient encore être utiles à certains.

Ils servent à des fins différentes:

• .then()doit être utilisé chaque fois que vous souhaitez travailler avec le résultat du processus, c'est-à-dire comme le dit la documentation, lorsque l'objet différé est résolu ou rejeté. C'est la même chose que d'utiliser .done()ou .fail().

• Vous utiliseriez .pipe()pour (pré) filtrer le résultat d'une manière ou d'une autre. La valeur de retour d'un callback à .pipe()sera transmise en argument aux callbacks doneet fail. Il peut également renvoyer un autre objet différé et les rappels suivants seront enregistrés sur ce différé.

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

Ce n'est donc pas que vous utilisiez ni .then() ni .pipe() . Vous pouvez utiliser .pipe()aux mêmes fins que .then()mais l'inverse ne tient pas.

Exemple 1

Le résultat d'une 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 utilisons deux donerappels:

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 extraire la valeur de chaque objet.

Ne serait-il pas préférable d'extraire les valeurs à l'avance afin de ne pas avoir à le faire individuellement dans les deux rappels? 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 existe de nombreuses façons différentes (peut-être meilleures) de résoudre ce problème, mais j'espère que cela illustre ce point.

Exemple 2

Considérez les appels Ajax. Parfois, vous souhaitez lancer un appel Ajax après la fin d'un précédent. Une façon consiste à effectuer le deuxième appel dans un donerappel:

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

Supposons maintenant que vous souhaitiez 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 souhaitez utiliser l'objet différé pour permettre à un autre code qui appelle makeCallsde joindre 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 escompté car le second appel est effectué à l'intérieur d'un donecallback et n'est pas accessible de l'extérieur.

La solution serait d'utiliser à la .pipe()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 rendre possible l'ajout de rappels à l'appel Ajax "interne" sans exposer le flux / l'ordre réel des appels.

En général, les objets différés offrent un moyen intéressant de découpler votre code :)

Il n'y a aucun cas où vous DEVEZ utiliser then()over pipe(). Vous pouvez toujours choisir d'ignorer la valeur qui pipe()passera. Il peut y avoir un léger impact sur les performances de l'utilisation pipe, mais il est peu probable que cela ait une importance.

Il peut donc sembler que vous pouvez toujours utiliser pipe()dans les deux cas. Cependant , en utilisant pipe(), vous communiquez à d'autres personnes lisant votre code (y compris vous-même, dans six mois) qu'il y a une certaine importance à la valeur de retour. Si vous le rejetez, vous violez cette construction sémantique.

C'est comme avoir une fonction qui renvoie une valeur qui n'est jamais utilisée: déroutant.

Alors utilisez then()quand vous devriez, et pipe()quand vous devriez ...

En fait, il s'avère que la différence entre .then()et .pipe()a été jugée inutile et qu'ils ont été rendus identiques à ceux de la version 1.8 de jQuery.

D'après un commentaire dejaubourg dans le ticket de suivi des bogues de jQuery # 11010 "MAKE DEFERRED.THEN == DEFERRED.PIPE LIKE PROMISE / A":

Dans la version 1.8, nous supprimerons l'ancien et le remplacerons par le tuyau actuel. Mais la conséquence très triste est que nous devrons dire aux gens d'utiliser le fait, l'échec et le progrès non standard, car la proposition ne fournit pas de moyen simple, EFFICACE, d'ajouter simplement un rappel.

^{(mine d'emphassis)}