我如何获得所有的结果未能使用$。当（）回调

Question

说我有一个延迟功能：

尝试1：

$.when(validatePerson(123), validatePerson(456)) 
.done(function(data) { }) 
.fail(function(data1, data2) { }); 

尝试2：

$.when(validatePerson(123), validatePerson(456)) 
.done(function(data) { }) 
.fail(function(data1) { }, 
     function(data2) { }); 

我想进行2个AJAX调用异步，但在失败，我想能够确定哪一个第一，第二或两个调用fai导致我可以向用户显示适当的错误。

例如

• 验证人1（ID 123）失败
• 验证人2（编号456）失败

但我似乎无法得到它的工作。 在尝试1中，data1参数仅包含其中一个结果，并且data2未定义。

在尝试2中我得到了用相同的参数调用两次的函数回调。

Answer 1

$.when()终止时，第一个承诺，你通过它拒绝。你无法得到所有被拒绝的承诺。您可以将其与其他代码一起使用来跟踪所有故障。

这里有一个$.settle()是等待所有承诺你传递它是解决或拒绝，并返回PromiseInspection对象的数组，从中可以知道哪些解决和拒绝，以及他们的解决值或拒绝的理由是：

(function() {  

    function isPromise(p) { 
     return p && (typeof p === "object" || typeof p === "function") && typeof p.then === "function"; 
    } 

    function wrapInPromise(p) { 
     if (!isPromise(p)) { 
      p = $.Deferred().resolve(p); 
     } 
     return p; 
    } 

    function PromiseInspection(fulfilled, val) { 
     return { 
      isFulfilled: function() { 
       return fulfilled; 
      }, isRejected: function() { 
       return !fulfilled; 
      }, isPending: function() { 
       // PromiseInspection objects created here are never pending 
       return false; 
      }, value: function() { 
       if (!fulfilled) { 
        throw new Error("Can't call .value() on a promise that is not fulfilled"); 
       } 
       return val; 
      }, reason: function() { 
       if (fulfilled) { 
        throw new Error("Can't call .reason() on a promise that is fulfilled"); 
       } 
       return val; 
      } 
     }; 
    } 

    // pass either multiple promises as separate arguments or an array of promises 
    $.settle = function(p1) { 
     var args; 
     if (Array.isArray(p1)) { 
       args = p1; 
     } else { 
      args = Array.prototype.slice.call(arguments); 
     } 

     return $.when.apply($, args.map(function(p) { 
      // make sure p is a promise (it could be just a value) 
      p = wrapInPromise(p); 
      // Now we know for sure that p is a promise 
      // Make sure that the returned promise here is always resolved with a PromiseInspection object, never rejected 
      return p.then(function(val) { 
       return new PromiseInspection(true, val); 
      }, function(reason) { 
       // convert rejected promise into resolved promise by returning a resolved promised 
       // One could just return the promiseInspection object directly if jQuery was 
       // Promise spec compliant, but jQuery 1.x and 2.x are not so we have to take this extra step 
       return wrapInPromise(new PromiseInspection(false, reason)); 
      }); 
     })).then(function() { 
       // return an array of results which is just more convenient to work with 
       // than the separate arguments that $.when() would normally return 
      return Array.prototype.slice.call(arguments); 
     }); 
    } 

    // simpler version that just converts any failed promises 
    // to a resolved value of what is passed in, so the caller can just skip 
    // any of those values in the returned values array 
    // Typically, the caller would pass in null or 0 or an empty object 
    $.settleVal = function(errorVal, p1) { 
     var args; 
     if (Array.isArray(p1)) { 
       args = p1; 
     } else { 
      args = Array.prototype.slice.call(arguments, 1); 
     } 
     return $.when.apply($, args.map(function(p) { 
      p = wrapInPromise(p); 
      return p.then(null, function(err) { 
       return wrapInPromise(errorVal); 
      }); 
     })); 
    } 
})(); 

用法：

$.settle(arrayOfPromises).then(function(results) { 
    // results is an array of PromiseInspection objects and you can 
    // tell which are resolved and which are rejected 
    results.forEach(function(item, index) { 
     if (item.isFulfilled()) { 
      console.log("promise #" + index + " is fulfilled with value: ", item.value();); 
     } else { 
      console.log("promise #" + index + " is rejected with reason: ", item.reason();); 
     } 
    }); 
});