Spingere le promesse jQuery in array esegue funzioni differite in modo asincrono

Question

Sto cercando di capire le funzioni differite JavaScript.Ho trovato un problema in un'applicazione mobile che sto sviluppando con JQuery Mobile.

Ho fatto un jsfiddle con l'esempio, ma incolla qui il codice per chiarezza.

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");
});

.

Cosa intendo:

.
1. Spingi sia TestDeferred e TestDeferred2 Promesse nell'array "Promesse", costringendoli a risolversi.
2. Esegui entrambi usando $. Quando.Apply.

Quello che ottengo sono entrambe le funzioni che vengono eseguite nel momento in cui li spingo.La dimostrazione è il loro stato dopo averle spinto diventa "risolta".

Ho rimosso il "Prompromesso ()" Ending in TestDeferred di proposito per verificare se dovessi restituire una promessa o solo il differito.La stessa cosa è successo.

Per favore, ho bisogno di aiuto qui ... grazie in anticipo.

Answer 1

.

Entrambe le funzioni che vengono eseguite nel momento in cui li spingono

Sì, è quello che stai facendo qui:

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

.

Stai chiamando le funzioni, che restituiranno le promesse risolte (o differite, per quella materia).Tuttavia, è necessario distinguere tra eseguire la funzione e risoluzione le promesse.

Il tuo codice è sincrono in modo sincrono, che è piuttosto insolito, normalmente ti aspetteresti di eseguire immediatamente le funzioni e risolvere la promessa restituita successivamente:
Durante la scrittura di codice asincrono (immagina un setTimeout o un $.ajax nelle funzioni di test), si sta chiamando immediatamente, quale avvia le attività asincroni subito, ma ottenere in attesa promessaper i loro risultati.

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
});

.

( Aggiornato demo violino )