Empujando JQuery promesas en la matriz se ejecuta diferido funciones de forma Asincrónica

Question

Estoy tratando de entender Javascript diferido funciones.He venido para arriba con un problema en una aplicación móvil que estoy desarrollando con JQuery Mobile.

He hecho un JSFiddle con el ejemplo pero me pega aquí el código para mayor claridad.

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

Lo que pretendo:

1. Empuje los dos testDeferred y testDeferred2 de las promesas en la matriz de "promesas", lo que les obliga a resolver.
2. Ejecutar tanto el uso de $.cuando.se aplican.

Lo que quiero lograr es que ambas funciones están ejecutando en el momento, me empujan.La prueba es su estado después de empujar ellos se convierte en "resuelto".

He quitado el ".promesa()" que termina en testDeferred a propósito de poner a prueba si es que regreso una promesa o simplemente el diferido.Lo mismo ocurrió.

Por favor, necesito un poco de ayuda aquí...Gracias de antemano.

Answer 1

ambas funciones están ejecutando en el momento, me empujan

Sí, eso es lo que ustedes están haciendo aquí:

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

Te están llamando a las funciones, que volverá resuelto promesas (o deferreds, para esa materia).Sin embargo, tendrá que distinguir entre la ejecución de la función, y la resolución de las promesas.

Su código hace que de forma sincrónica, la cual es bastante inusual, normalmente se esperaría para ejecutar las funciones de inmediato y resolver regresado a la promesa más tarde:
Cuando la escritura de código asíncrono (imaginar un setTimeout o un $.ajax en la prueba de funciones), entonces usted está llamando de inmediato, que comienza las tareas asincrónicas de inmediato, pero pendiente prometen sus 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
});

(actualizado demo de violín)