Pousser les promesses de JQuery dans le tableau exécute les fonctions différées de manière asynchrone

Question

J'essaie de comprendre les fonctions différées Javascript.J'ai rencontré un problème dans une application mobile que je développe avec JQuery Mobile.

j'ai fait un JSFiddle avec l'exemple mais je colle ici le code pour plus de clarté.

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

Ce que j'ai l'intention :

1. Poussez les deux testDifféré et testDifféré2 promesses dans le tableau "promesses", les forçant à se résoudre.
2. Exécutez les deux en utilisant $.quand.faire une demande.

Ce que j'obtiens, c'est que les deux fonctions sont exécutées au moment même où je les pousse.La preuve est que leur état après les avoir poussés devient « résolu ».

J'ai supprimé le ".promise()" se terminant par testDifféré exprès pour tester si je dois retourner une promesse ou simplement le différé.La même chose s'est produite.

S'il vous plaît, j'ai besoin d'aide ici...Merci d'avance.

Answer 1

les deux fonctions étant exécutées au moment même où je les pousse

Oui, c'est ce que tu fais ici :

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

Vous appelez les fonctions qui renverront des promesses résolues (ou différées, d'ailleurs).Il faudra cependant faire la distinction entre exécution la fonction, et résoudre les promesses.

Votre code le fait de manière synchrone, ce qui est plutôt inhabituel. Normalement, vous vous attendez à exécuter les fonctions immédiatement et à résoudre la promesse renvoyée plus tard :
Lors de l'écriture de code asynchrone (imaginez un setTimeout ou un $.ajax dans les fonctions de test), alors vous les appelez immédiatement, ce qui départs les tâches asynchrones tout de suite, mais obtenez en attente promesse pour leurs résultats.

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

(violon de démonstration mis à jour)