标签: jquery-deferred

我试图使用jQuery.when两个ajax请求,然后在两个请求完成后调用一些函数.这是我的代码:

var count = 0;
var dfr;

var showData = function(data) {
    dfr.resolve();
    alert(count);
   // Do something with my data data received
};

var method1 = function() {
    dfr = $.Deferred();

    return $.ajax('localhost/MyDataService/DataMethod_ReturnsData', {
        dataType: "jsonp",
        jsonp: "$callback",
        success: showData
    });
};

var method2 = function() {
    return $.ajax('localhost/MyDataService/DataMethod_ReturnsCount', {
        dataType: "jsonp",
        jsonp: "$callback",
        success: function(data) {
            count = data.d.__count;
        }
    });
};

$.when(method1(), method2())
    .then(showData());

但是这没有按预期工作.Ajax调用method1将返回要使用的数据,showData()并且Ajax调用method2将返回计数,该计数将分配给var count并稍后用于showData(). …

我有一个三层深度的延迟ajax调用链,理想情况下,当最深层完成时,它们会一直向前推进(使我成为Inception ..."我们需要更深入!").

问题是我一次发送了许多ajax请求(可能是数百个),需要推迟直到所有这些请求完成.我不能依赖最后一次完成.

function updateAllNotes() {
    return $.Deferred(function(dfd_uan) {
        getcount = 0;
        getreturn = 0;
        for (i = 0; i <= index.data.length - 1; i++) {
            getcount++;
            $.when(getNote(index.data[i].key)).done(function() {
                // getNote is another deferred
                getreturn++
            });
        };
        // need help here
        // when getreturn == getcount, dfd_uan.resolve()
    }).promise();
};

可能重复:
Javascript中Deferred,Promise和Future之间有什么区别？

最近我一直在努力提高我的JavaScript应用程序的质量.

我采用的一种模式是使用单独的"数据上下文"对象来为我的应用程序加载数据(之前我在我的视图模型中直接执行此操作).

以下示例返回在客户端上初始化的数据:

var mockData = (function($, undefined) {

    var fruit = [
        "apple",
        "orange",
        "banana",
        "pear"
        ];

    var getFruit = function() {
        return fruit;
    };

    return {
        getFruit: getFruit
    }
})(jQuery);

在大多数情况下,我们将从服务器加载数据,因此我们无法立即返回响应.在我们的API中,我似乎有两种选择:

1. 使用回调
2. 回复承诺.

以前我总是使用回调方法:

var getFruit = function(onFruitReady) {
    onFruitReady(fruit);
};

// ...

var FruitModel = function(dataContext, $) {
    return {
        render: function() {
            dataContext.getFruit(function(fruit) {
                // do something with fruit
            });
        }
    };
};

但是,我可以看到如何最终回调地狱,特别是在构建复杂的JavaScript应用程序时.

然后我遇到了Promises的设计模式.我不是要求调用者提供回调,而是返回一个可以观察到的"承诺":

var getFruit = function() {
    return $.Deferred().resolve(fruit).promise(); …

如果我有一个函数,有时会返回一个延迟对象,但有时会返回一个非延迟对象.我怎么知道它是哪一个？

@Domenic有一篇关于jQuery延迟对象失败的非常详尽的文章:你错过了Point of Promises.在其中,Domenic突出了jQuery承诺的一些失败,与其他包括Q,when.js,RSVP.js和ES6承诺相比.

我离开了Domenic的文章,认为jQuery承诺在概念上有一个固有的失败.我试图把这个例子放在这个概念上.

我认为jQuery实现有两个问题:

1.该.then方法不可链接

换一种说法

promise.then(a).then(b)

jQuery将调用a随后b的时候promise满足.

由于.then在其他promise库中返回一个新的promise,它们的等价物将是:

promise.then(a)
promise.then(b)

2.异常处理在jQuery中冒泡.

另一个问题似乎是异常处理,即:

try {
  promise.then(a)
} catch (e) {
}

Q中的等价物是:

try {
  promise.then(a).done()
} catch (e) {
   // .done() re-throws any exceptions from a
}

在jQuery中,当acatch块失败时异常抛出并出现气泡.在其他承诺中,任何异常a将被传递到.done或.catch或其他异步捕获.如果没有任何promise API调用捕获异常,它就会消失(因此Q最佳实践,例如使用.done释放任何未处理的异常).

上述问题是否涵盖了jQuery实现承诺的问题,还是我误解或遗漏了问题？

编辑 此问题与jQuery <3.0; 从 jQuery 3.0开始,alpha jQuery是Promises/A +兼容的.

我有一个现有的项目,有很多异步函数返回promises.我正在添加一些缓存,以便在某些情况下异步函数将同步完成,并希望在可能的情况下使此代码更短/更好:

        return $.Deferred(function(def) { def.resolve(); }).promise();

例如,我有一个Data Service类来处理大多数看起来像这样的AJAX请求:

function DataService() {

    var self = this;

    self.makeRequest = function(functionName, data) {
        return $.Deferred(function(def) {

            var jsonData = JSON.stringify(data);

            $.ajax({
                type: "POST",
                url: "WebService.asmx/" + functionName,
                data: jsonData,
                contentType: "application/json; charset=utf-8",
                dataType: "json",
                error: function(xhr, status, error) {
                    var ex;
                    try {
                        ex = eval("(" + xhr.responseText + ")");
                        ex.message = ex.Message;
                        ex.Message = undefined;
                    } catch (ex2) {
                        ex = { message: "Invalid Response From Server:\r\n" + xhr.responseText };
                    }
                    if …

我有一种情况,我想取消延期.延迟与ajax调用相关联.

为什么我使用延期

我不使用$ .ajax返回的普通xhr对象.我正在使用jsonp,这意味着我无法使用HTTP状态代码进行错误处理,并且必须将它们嵌入到响应中.然后检查代码,并相应地将关联的延迟对象标记为已解决或拒绝.我有一个自定义api函数,为我这样做.

function api(options) {
  var url = settings('api') + options.url;
  var deferred = $.Deferred(function(){
    this.done(options.success);
    this.fail(options.error);
  });
  $.ajax({
    'url': url,
    'dataType':'jsonp',
    'data': (options.noAuth == true) ? options.data : $.extend(true, getAPICredentials(), options.data)
  }).success(function(jsonReturn){
    // Success
    if(hasStatus(jsonReturn, 'code', 200)) {
      deferred.resolveWith(this, [jsonReturn]);
    } 
    // Failure
    else {
      deferred.rejectWith(this, [jsonReturn]);
    }
  });

  return deferred;
}

为什么我要取消延期

有一个输入字段用作列表的过滤器,并在键入结束后半秒自动更新列表.因为一次可能有两个ajax调用是未完成的,所以我需要取消之前的调用以确保它在第二个调用之后不返回并显示旧数据.

解决方案我不喜欢

• 我不想拒绝延期,因为这将解雇附带的处理程序.fail().
• 我不能忽略它,因为它会在ajax返回时自动标记为已解决或被拒绝.
• 删除延迟将在ajax调用返回时导致错误,并尝试将延迟标记为已解决或已拒绝.

我该怎么办？

有没有办法取消延期或删除任何附加的处理程序？

有关如何修复我的设计的建议值得欢迎,但我们会优先考虑找到一种方法来删除处理程序或防止它们被触发.

当多个Deferred对象传递给jQuery.when时,该方法从一个新的"master"Deferred对象返回Promise,该对象跟踪它已经传递的所有Deferred的聚合状态.

该方法将

1. 一旦所有Deferred解决,就解决它的主延期,或者
2. 拒绝其主人一旦被拒绝一个延期,就拒绝延期.

如果主Deferred被解析(即所有Deferreds解析),则传递给传递给jQuery.when的所有Deferred的已解析值.例如,当Deferreds是jQuery.ajax()请求时,参数将是请求的jqXHR对象,按照它们在参数列表中给出的顺序:

$.when( $.getJSON('foo'), $.getJSON('bar') ).done(function(foo, bar) {

    // foo & bar are jqXHR objects for the requests

});

在其中一个Deferreds被拒绝的多个Deferreds案例中,jQuery.when立即激活其主Deferred的失败回调,即使某些Deferreds在此时仍未解决:

$.when( $.getJSON('foo'), $.getJSON('bar') ).fail(function(req) {

    // req is the jqXHR object for one of the failed requests

});

当所有传递给jQuery的Deferreds都不再"未解决"时,我需要触发一个回调(即所有的"被解决"或"被拒绝").我可以使用200 OK代码发送JSON对象(而不是发送带有404 Not Found错误状态代码的JSON)并在done()方法中确定成功/错误,但我更喜欢保持我的API RESTful.我怎么能做到这一点？

我正在尝试实现一个重试ajax请求的系统,这些请求因临时原因而失败.在我的例子中,它是关于在调用刷新web服务以恢复会话之后重试因401会议状态代码而失败的请求,因为会话已过期.

问题是成功重试时不会调用"done"回调,这与调用的"success"ajax选项回调不同.我在下面编写了一个简单的例子:

$.ajaxSetup({statusCode: {
    404: function() {
        this.url = '/existent_url';
        $.ajax(this);
    }
}});

$.ajax({
    url: '/inexistent_url',
    success: function() { alert('success'); }
})
.done(function() {
    alert('done');
});

是否有办法在成功重试时调用完成式回调？我知道延期不能被"拒绝"后"解决",是否有可能阻止拒绝？或者可能将原始延迟的doneList复制到新的延迟？我没有想法:)

下面是一个更现实的例子,我试图排队所有401拒绝的请求,并在成功调用/ refresh后重试它们.

var refreshRequest = null,
    waitingRequests = null;

var expiredTokenHandler = function(xhr, textStatus, errorThrown) {

    //only the first rejected request will fire up the /refresh call
    if(!refreshRequest) {
        waitingRequests = $.Deferred();
        refreshRequest = $.ajax({
            url: '/refresh',
            success: function(data) {
                // session refreshed, good
                refreshRequest = null;
                waitingRequests.resolve();
            },
            error: function(data) {
                // …

我有一个像这样的功能:

function do_something() {
    // some code

    return $.when(foo, bar, baz).then(do_something_else);
}

function do_something_else(_foo, _bar, _baz) {
    // do something else

    return /* the original inputs */;
}

因此,当有人使用时do_something,他们也可以链接更多回调,例如:

do_something().then(function(_foo_2, _bar_2, _baz_2) {
    console.log(_foo_2, _bar_2, _baz_2);
});

问题是我不知道如何绕过原来的返回do_something_else来描述匿名函数.我不想收到列表,而是接收位置参数,所以"当foo"为do_something_else的_foo插入一些值,然后相同的值转到_foo_2.

我怎么能在JS中做到这一点？