Empurrando JQuery promessas em matriz executa diferidos funções de forma Assíncrona

Question

Estou tentando entender o Javascript diferidos funções.Eu vim com um problema em um aplicativo para celular que eu estou desenvolvendo com JQuery Mobile.

Eu fiz uma JSFiddle com o exemplo, mas eu cole aqui o código para maior clareza.

var promises = [];

function out() {
    var args = Array.prototype.slice.call(arguments, 0);
    document.getElementById('output').innerHTML += args.join(" ") + "\n";
}

function testDeferred(a) {
    return $.Deferred(function (d) {
        if (a == 1) {
            d.resolve(a);
        } else {
            d.reject(a);
        }
    });
}

function testDeferred2(a) {
    var deferred = new $.Deferred();

    if (a == 1) {
        deferred.resolve(a);
    } else {
        deferred.reject(a);
    }
    return deferred.promise();
}


promises.push(testDeferred(1));
promises.push(testDeferred2(1));

out(promises[0].state());
out(promises[1].state());

$.when.apply($, promises)
    .done(function () {
    out("Done");
});

O que eu pretendo:

1. Empurre ambos os testDeferred e testDeferred2 promessas para a matriz "promessas", forçando-os a resolver.
2. Executar usando $.quando.aplica.

O que eu conseguir é que ambas as funções estão sendo executadas no momento, eu empurrá-los.A prova é o seu estado depois de empurrá-los torna-se "resolvido".

Eu removi o ".(promessa)" terminando em testDeferred com o propósito de testar se eu deveria retornar de uma promessa ou apenas adiada.A mesma coisa aconteceu.

Por favor, eu preciso de alguma ajuda aqui...Obrigado antecipadamente.

Answer 1

ambas as funções estão sendo executadas no momento, eu empurrá-los

Sim, é isso que você está fazendo aqui:

promises.push(testDeferred(1));
promises.push(testDeferred2(1));

Você está chamando as funções, que irá retornar resolvido promessas (ou deferreds, para que o assunto).No entanto, será necessário distinguir entre execução a função, e resolução as promessas.

O código faz isso de forma síncrona, o que é bastante incomum, normalmente seria de esperar para executar as funções de imediato e resolver devolvidos promessa posteriores:
Quando escrever código assíncrono (imagine um setTimeout ou um $.ajax no teste de funções"), então você está chamando-o de imediato, que começa as tarefas assíncronas de imediato, mas para obter pendente a promessa para os seus resultados.

function testDeferredDelay(a, ms) {
    var deferred = new $.Deferred();
    setTimeout(function() { // happens now
        deferred.resolve(a); // happens later
    }, ms);
    return deferred.promise(); // happens now
}

promises.push(testDeferredDelay(1, 50));
promises.push(testDeferredDelay(2, 100));

out(promises[0].state()); // pending
out(promises[1].state()); // pending

$.when.apply($, promises) // happens now
.done(function () {
    out("Done"); // happens later
});

(atualizado demonstração de mexer)