Comment puis-je établir une séquence de différé fonctions jQuery 1.8.x?

Compte tenu de ces fonctions:

function func1() {
  var dfd = $.Deferred();

  setTimeout(function() {
    dfd.resolve('Password');
  }, 1000);

  return dfd.promise();
}

function func2(message) {
  var dfd = $.Deferred();

  setTimeout(function() {
    if (message == 'Password') {
      dfd.resolve('Hello World');
    }
   }, 1000);

  return dfd.promise();
}

Je voudrais trouver une meilleure façon de faire les suivants. Remarque c'est à l'aide de jQuery 1.8.x. 

var promise = func1();

promise.done(function(message1) {

  var promise2 = func2(message1);

  promise2.done(function(message2) {
    alert(message2);
  });
});

Des idées? J'ai pensé à l'aide de jQuery #tuyau ou #puis pourrait fonctionner, mais je ne peux pas la comprendre. Voici un violon pour jouer: http://jsfiddle.net/Z7prn/

InformationsquelleAutor camwest | 2012-11-30
  1. 38

    Ce n'est pas compliqué (soit utiliser .then ou .pipe, ils sont tous les deux le même depuis jQuery 1.8 je crois).

    func1().then(func2).done(function(message) {
    alert(message);
});

    Depuis func2 renvoie un nouvel objet reporté, le .done de rappel est fixé à la place.

    DÉMO

    • j'aime quand les gens expliquer les choses de telle manière concise. plus facile à comprendre et à suivre
    • Remarque: Utilisez .then depuis .pipe a été déprécié en jQuery 1.8 (docs)
    InformationsquelleAutor Felix Kling
  2. 5

    J'ai eu un semblable de cas d'utilisation, donc je pense que cela devrait vous aider.

    La méthode suivante va prendre un éventail de méthodes (qui peut ou ne peut pas retourner de Promesses) et de les exécuter dans l'ordre, en attente jusqu'à ce que chaque différé est complète avant de procéder. Le comportement par défaut est de s'arrêter sur un échec; deuxième argument permet de procéder si l'appel échoue ou pas.

    fait échouer gestionnaire de signatures (Array<contexte>) Fonction (Array<Object{ rejeté|résolu: arguments }>), où contexte est le contexte de chaque resolveWith/rejectWith appel, ou le différé en question, et arguments est la thèse qui a été adopté dans la résolution de rejet.

    (function ($) {
"use strict";
var copy = function (a) {
return Array.prototype.slice.call(a);
};
/**
Handle a sequence of methods, stopping on failure by default
@param Array<Function> chain    List of methods to execute.  Non-deferred return values will be treated as successful deferreds.
@param Boolean  continueOnFailure   Continue executing even if one of the returned deferreds fails.
@returns Deferred
*/
$.sequence = function (chain, continueOnFailure) {
var handleStep, handleResult,
steps = copy(chain),
def = new $.Deferred(),
defs = [],
results = [];
handleStep = function () {
if (!steps.length) {
def.resolveWith(defs, [ results ]);
return;
}
var step = steps.shift(),
result = step();
handleResult(
$.when(result).always(function () {
defs.push(this);
}).done(function () {
results.push({ resolved: copy(arguments) });
}).fail(function () {
results.push({ rejected: copy(arguments) });
})
);
};
handleResult = continueOnFailure ?
function (result) {
result.always(function () {
handleStep();
});
} :
function (result) {
result.done(handleStep)
.fail(function () {
def.rejectWith(defs, [ results ]);
});
};
handleStep();
return def.promise();
};
}(this.jQuery));

    Un exemple simple d'utilisation: http://jsfiddle.net/rG9rA/

    function func1() {
var dfd = $.Deferred();
setTimeout(function() {
dfd.resolve('Password');
}, 1000);
return dfd.promise();
}
function func2(message) {
var dfd = $.Deferred();
setTimeout(function() {
if (message == 'Password') {
dfd.resolve('Hello World');
}
}, 1000);
return dfd.promise();
}
$.sequence([func1, func2, function () { alert('done'); }]);
    • Nice. J'ai ajouté une option de "retard" entre les appels, dans le cas où certaines externe, le code doit événements à régler (j'utilise Ko)
    InformationsquelleAutor Fordi