poczekać na zakończenie po wielokrotnych obietnic równolegle z wykorzystaniem jQuery

Question

chcę stać w kolejce wiele żądań asynchronicznych ajax pomocą odroczony wdrożenia/obietnica jQuery:

function doSomething() { 
    console.log('doSomething')}; 

function makeMultiAjaxRequests1() { 
    console.log('makeMultiAjaxRequests1')}; 

function makeMultiAjaxRequests2() { 
    console.log('makeMultiAjaxRequests2')}; 

var step1 = function() { 
    var promise = new $.Deferred().promise(); 
    makeMultiAjaxRequests1(); 
    return promise; } 

var step2 = function() { 
    var promise = new $.Deferred().promise(); 
    makeMultiAjaxRequests2(); 
    return promise; } 

step1() 
    .then(step2()) 
    .done(doSomething()); 

$.when(step1(), 
     step2()) 
    .done(function() { 
    doSomething(); 
}); 

Oto fiddle link. Moje pytanie brzmi:

W schemacie, w którym krok 1 i krok 2 są wykonywane równolegle, kod nie osiąga ostatniej funkcji obsługi. Czemu?

Answer 1

To nie osiągnie swoją funkcję done jeśli dać mu adres URL może rzeczywiście osiągnąć (w przypadku jsfiddle, że byłoby powiedzieć /echo/html/: http://jsfiddle.net/LnaPt/2/

Zasadniczo, po prostu trzeba to zrobić:

var promise = $.ajax({ 
    type: "GET", 
    url: "/echo/html/", //<-- instead of google  
}).promise(); 

Answer 2

trzeba rozwiązać deferred obj w kroku 1 i STEP2

Spróbuj

function doSomething() { 
    console.log('doSomething')}; 

function makeMultiAjaxRequests1(deferred) { 
    console.log('makeMultiAjaxRequests1') 
    deferred.resolve()}; 

function makeMultiAjaxRequests2(deferred) { 
    console.log('makeMultiAjaxRequests2') 
    deferred.resolve()}; 

var step1 = function() { 
    var deferred = new $.Deferred(); 
    makeMultiAjaxRequests1(deferred); 
    return deferred; } 

var step2 = function() { 
    var deferred = new $.Deferred(); 
    makeMultiAjaxRequests2(deferred); 
    return deferred; } 

step1().then(step2).done(doSomething); 

$.when(step1(), step2()).done(function() { 
    doSomething(); 
}); 

Answer 3

@Daiwei daje dobrą odpowiedź.

Powszechnie obowiązującym określeniem jest https://gist.github.com/sergio-fry/3917217 autorstwa sergio-fry.

Jeżeli chcesz mieć bardziej dynamicznego podejścia, w którym nie wiem ile wcześniej argumenty używasz równolegle, jest tu dobrym przykładem rozszerzenie jQuery (1.10+):

$.whenAll = function (deferreds) { 
    function isPromise(fn) { 
     return fn && typeof fn.then === 'function' && 
      String($.Deferred().then) === String(fn.then); 
    } 
    var d = $.Deferred(), 
     keys = Object.keys(deferreds), 
     args = keys.map(function (k) { 
      return $.Deferred(function (d) { 
       var fn = deferreds[k]; 

       (isPromise(fn) ? fn : $.Deferred(fn)) 
        .done(d.resolve) 
        .fail(function (err) { d.reject(err, k); }) 
       ; 
      }); 
     }); 

    $.when.apply(this, args) 
     .done(function() { 
      var resObj = {}, 
       resArgs = Array.prototype.slice.call(arguments); 
      resArgs.forEach(function (v, i) { resObj[keys[i]] = v; }); 
      d.resolve(resObj); 
     }) 
     .fail(d.reject); 

    return d; 
}; 

Zobacz Kod w akcji z dynamicznym przykład żywej:

http://jsbin.com/nuxuciwabu/edit?js,console