jQuery的延迟和承诺-.then（）与.done（）

#1 楼

解决延迟问题后，将触发done()附带的回调。

在jQuery 1.8之前，fail()只是语法糖：

promise.then( doneCallback, failCallback )
// was equivalent to
promise.done( doneCallback ).fail( failCallback )

从1.8版本开始，then()是then()的别名并返回新的Promise，请参见此处以获取有关pipe()的更多信息。它们分别是pipe()和success()的简单别名：带有应在1.8.1中修复的版本1.8中的字符串：

#2 楼

返回结果的处理方式也不同（称为链接，done不链接，而then生成调用链）

promise.then(function (x) { // Suppose promise returns "abc"
    console.log(x);
    return 123;
}).then(function (x){
    console.log(x);
}).then(function (x){
    console.log(x)
})

以下结果将被记录：

abc
123
undefined

，而

promise.done(function (x) { // Suppose promise returns "abc"
    console.log(x);
    return 123;
}).done(function (x){
    console.log(x);
}).done(function (x){
    console.log(x)
})

将得到以下内容：

abc
abc
abc

----------更新：

顺便说一句。我忘了提一下，如果您返回Promise而不是原子类型值，则外部诺言将等到内部诺言得到解决：

promise.then(function (x) { // Suppose promise returns "abc"
    console.log(x);
    return $http.get('/some/data').then(function (result) {
        console.log(result); // suppose result === "xyz"
        return result;
    });
}).then(function (result){
    console.log(result); // result === xyz
}).then(function (und){
    console.log(und) // und === undefined, because of absence of return statement in above then
})

这样变得非常简单组成并行或顺序异步操作，例如：

// Parallel http requests
promise.then(function (x) { // Suppose promise returns "abc"
    console.log(x);

    var promise1 = $http.get('/some/data?value=xyz').then(function (result) {
        console.log(result); // suppose result === "xyz"
        return result;
    });

    var promise2 = $http.get('/some/data?value=uvm').then(function (result) {
        console.log(result); // suppose result === "uvm"
        return result;
    });

    return promise1.then(function (result1) {
        return promise2.then(function (result2) {
           return { result1: result1, result2: result2; }
        });
    });
}).then(function (result){
    console.log(result); // result === { result1: 'xyz', result2: 'uvm' }
}).then(function (und){
    console.log(und) // und === undefined, because of absence of return statement in above then
})

上面的代码并行发出两个http请求，从而使请求尽快完成，而下面的那些http请求正在按顺序运行，从而减少服务器负载

// Sequential http requests
promise.then(function (x) { // Suppose promise returns "abc"
    console.log(x);

    return $http.get('/some/data?value=xyz').then(function (result1) {
        console.log(result1); // suppose result1 === "xyz"
        return $http.get('/some/data?value=uvm').then(function (result2) {
            console.log(result2); // suppose result2 === "uvm"
            return { result1: result1, result2: result2; };
        });
    });
}).then(function (result){
    console.log(result); // result === { result1: 'xyz', result2: 'uvm' }
}).then(function (und){
    console.log(und) // und === undefined, because of absence of return statement in above then
})

#3 楼

.done()只有一个回调，它是成功回调

.then()只有成功和失败回调，

.fail()只有一个失败回调，

所以它由您决定，您必须做什么...是否在乎它是否成功？

#4 楼

deferred.done（）

添加仅在解析Deferred后才调用的处理程序。您可以添加多个要调用的回调。 > deferred.then（）

添加要解析，拒绝或仍在进行Deferred时调用的处理程序。

var url = 'http://jsonplaceholder.typicode.com/posts/1';
$.ajax(url).done(doneCallback);

function doneCallback(result) {
    console.log('Result 1 ' + result);
}

#5 楼

实际上，有一个非常关键的区别，就jQuery的Deferreds而言，它是Promises的实现（而jQuery3.0实际上是试图将它们纳入规范）。
done / then之间的主要区别在于， >

.done()始终返回与开始时相同的Promise /包装值，无论您做什么或返回什么。

.then()从jQuery转换为原生ES2015 Promises，负责控制Promise的功能。承诺链，如果该链处于“解决”状态，它将向函数传递值...但是该函数的结果不会影响链本身。

const doneWrap = fn => x => { fn(x); return x };

Promise.resolve(5)
       .then(doneWrap( x => x + 1))
       .then(doneWrap(console.log.bind(console)));

$.Deferred().resolve(5)
            .done(x => x + 1)
            .done(console.log.bind(console));

这些都将记录5，而不是6。
请注意，我使用done和doneWrap进行日志记录，而不是.then。那是因为console.log函数实际上不返回任何东西。如果您传递.then函数不返回任何内容会发生什么呢？

Promise.resolve(5)
       .then(doneWrap( x => x + 1))
       .then(console.log.bind(console))
       .then(console.log.bind(console));

将记录： />发生了什么事？当我使用.then并将其传递给任何不返回任何函数的函数时，它的隐式结果是“未定义” ...当然，该结果当然将Promise [undefined]返回给下一个then方法，该方法记录了未定义。因此，我们开始时使用的原始值基本上已经丢失。这就是为什么.done最好被认为是“敲击”的原因->它实际上不是组成部分，只是在某个步骤中偷偷看值并在该值上运行函数的东西，但实际上并没有改变以任何方式组成。
这是一个非常根本的差异，并且很可能有一个很好的理由，为什么本机Promises本身没有实现.done方法。我们无需深入探讨为什么没有.fail方法，因为这更加复杂（即，.fail / .catch不是.done / .then的镜像。.->。catch中返回裸值的函数不会像传递给.the的那些人一样拒绝了“ stay”，然后他们解决了！）

#6 楼

then()始终表示在任何情况下都将调用它。但是传递的参数在不同的jQuery版本中是不同的。

在jQuery 1.8之前，then()等于done().fail()。并且所有回调函数共享相同的参数。

但是从jQuery 1.8开始，then()返回一个新的promise，并且如果它返回一个值，它将被传递到下一个回调函数中。示例：

 var defer = jQuery.Deferred();

defer.done(function(a, b){
            return a + b;
}).done(function( result ) {
            console.log("result = " + result);
}).then(function( a, b ) {
            return a + b;
}).done(function( result ) {
            console.log("result = " + result);
}).then(function( a, b ) {
            return a + b;
}).done(function( result ) {
            console.log("result = " + result);
});

defer.resolve( 3, 4 );
 

在jQuery 1.8之前，答案应该是

 result = 3
result = 3
result = 3
 

所有result都需要3。并且then()函数始终将相同的延迟对象传递给下一个函数。

但是从jQuery 1.8开始，结果应该是：

 result = 3
result = 7
result = NaN
 

因为第一个then()函数返回一个新的promise，所以将值7（这是将传递的唯一参数）传递给下一个done()，因此第二个done()写入result = 7。第二个then()将7用作a的值，并将undefined用作b的值，因此第二个then()返回带有参数NaN的新promise，最后一个done()打印NaN作为其结果。

#7 楼

响应中有一个非常简单的思维导图，很难在其他答案中找到：承诺

#8 楼

jQuery 3.0还有一个重要的区别，它很容易导致意外行为，并且在以前的答案中没有提及：

 let d = $.Deferred();
d.done(() => console.log('then'));
d.resolve();
console.log('now'); 

 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.0.0/jquery.min.js"></script> 

这将输出： br />

 done() 

 then() 

输出现在是：同步方式，而传递给var d = $.Deferred(); d.then(() => console.log('then')); d.resolve(); console.log('now');的任何参数均异步调用。

这与升级版本中提到的同步调用两个回调的jQuery早期版本不同：
Deferred .then（）回调始终被异步调用。
以前，如果将.then（）回调添加到已经被解析或拒绝的Deferred中，则该回调将立即运行和
同步。

#9 楼

仅使用.then()


这些是.done()的缺点


不能链接
阻止resolve()调用（所有.done()处理程序将

resolve()可能会从已注册的.done()处理程序中获取异常（！）
.done()中的异常会杀死延迟的内容：
我进一步认为，.done()处理程序将被静默跳过



我暂时认为.then(oneArgOnly)始终需要.catch()，因此不会有任何异常被静默忽略，但这不再是真的：unhandledrejection事件在控制台上记录未处理的.then()异常（默认情况下）。很合理！完全没有理由完全使用.done()。在.done()点被称为同步


记录为1、3、5、7
在脚本掉入底部之前记录


> resolve()中的异常会影响.done()调用方


通过捕获resolve()捕获




例外会破坏进一步的resolve()分辨率的承诺
/>

8和10未记录！



.done()没有这些问题


在线程变为空闲后记录为2、4、6、9、11不能正确捕获：由于.then()的同步模式，错误要么在unhandledrejection的点（可能是库代码！）抛出，要么在.done()调用中抛出，如果延期已经解决。

 .done() 

 .resolve() 

#10 楼

.done()终止了promise链，确保没有其他东西可以附加进一步的步骤。这意味着jQuery Promise实现可以抛出任何未处理的异常，因为没有人可以使用.fail()来处理它。

实际上，如果您不打算对Promise附加更多步骤，则应该使用.done()。有关更多详细信息，请参见为什么需要兑现承诺