强制jQuery延迟到“then”处理程序中的Ajax完成

Question

我有这样的情况，我相信我需要创建一个具有“然后”处理程序的延迟对象，但是要等到“然后”处理程序完成了它自己的promise之后再继续。

用例是一个记录对象，上面的功能是它的保存方法。记录对象有一个名为SaveQueue的属性，该属性设置为$。延迟（）记录的实例化。SaveQueue上的解析调用应该确保Deferred总是尽快执行附加到它的每个新处理程序。这个想法是，您可以在短时间内连续多次调用记录上的保存，但是调用将一个接一个地运行，而不是重叠。

我使用延迟来排队Ajax调用，这样直到前一个调用完成后才会运行。但是，从相同的方法，我想返回一个可以由jQuery Ajax对象解析/拒绝的Deferred，就像这样：

 record.saveQueue = $.Deferred();

 self.save = function( record ){
    var deferredAction = $.Deferred();

    deferredAction.then(function() {
        return $.post("/example_save_endpoint");
    });

    record.saveQueue.always(function(){
      deferredAction.resolve();
    }).resolve();

    return deferredAction;
  }

但是，当我使用此代码时，延迟动作promise总是以已解决结束，这可能是因为#then处理程序正在返回一个“挂起”（因此不拒绝）promise。是否有任何方法可以迫使延迟的用户在解决/拒绝Ajaxpromise之前等待Ajaxpromise完成？还是有其他更好的方法来穿这根针？

Answer 1

我可能会选择不这样做，但延迟/promise确实可以用作排队设备。

你需要对你已经尝试过的东西稍加改变。

self.queue = $.when();//A resolved promise, used to form a queue of functions in a .then() chain.

self.save = function(data) {
    var dfrd = $.Deferred();//A Deferred dedicated to this particular save.
    self.queue = self.queue.then(function() {
        return $.post("/example_save_endpoint", data) //Make the AJAX call, and return a jqXHR to ensure the downstream queue waits for this jqXHR to resolve/reject.
            .then(dfrd.resolve, dfrd.reject) //Resolve/reject the Deferred for the caller's benefit
            .then(null, function() {
                //Force failure down the success path to ensure the queue is not killed by an AJAX failure.
                return $.when();//Return a resolved promsie, for the queue's benefit.
            });
    });
    return dfrd.promise();//allow the caller to do something when the AJAX eventually responds
}

有关说明，请参见代码中的注释

Answer 2

你的想法可能行得通，但是

• 每次调用该方法时，不能使用.resolve（）解析队列，而应仅使用已解析的promise对其进行初始化。

我们不需要任何延迟，因为我们可以处理$.post返回的promise。

所以用这个：

var emptyQueue = $.when(undefined); // an already fulfilled promise as the start
// equivalent: = $.Deferred().resolve().promise();

function startQueue() {
    return emptyQueue; // yes, this delibaretely returns a constant, the begin
                       // of the queue always looks the same (and is never mutated)
}

// every time you create a record, do
record.saveQueue = startQueue();

// and use that in your methods:
this.save = function(record) {
    var queuedRequestResult = record.saveQueue.then(function() {
        return $.post("/example_save_endpoint");
//      ^^^^^^ promises chain :-)
    });
    // Magic happens here:
    record.saveQueue = queuedRequestResult // we swap the previous queue promise for a new
                                           // one that resolves only after the request
      .then(startQueue, startQueue);       // and make sure it then starts with a fresh
                                           // queue, especially when the request failed
    //.then(null, startQueue) is similar, except unnecessarily remembering the last result
    return queuedRequestResult;
}