Comment attendre Qu'une promesse JavaScript se résolve avant de reprendre la fonction?

je me demande s'il y a un moyen d'obtenir une valeur d'une promesse ou attendre (bloquer / dormir) jusqu'à ce qu'il ait résolu, similaire à .NET IAsyncResult.WaitHandle.WaitOne (). Je sais que JavaScript est mono-thread, mais j'espère que cela ne signifie pas qu'une fonction ne peut pas céder.

La génération actuelle de Javascript dans les navigateurs n'ont pas de wait() ou sleep() qui permet à d'autres choses à courir. Donc, vous ne pouvez tout simplement pas faire ce que vous demandez. Au lieu de cela, il a des opérations asynchrones qui feront leur truc et vous appelleront quand ils auront fini (comme vous avez utilisé des promesses pour).

Ceci est en partie dû au fait que Javascript est un seul threadedness. Si le fil simple tourne, alors aucun autre Javascript ne peut s'exécuter jusqu'à ce que ce fil soit terminé. ES6 introduit yield et les générateurs qui permettront quelques astuces coopératives comme cela, mais nous sommes assez loin d'être en mesure d'utiliser ceux-ci dans un large éventail de navigateurs installés (ils peut être utilisé dans certains développements côté serveur où vous contrôlez le moteur JS qui est utilisé).

Attention, la gestion de la promesse code pouvez contrôler l'ordre d'exécution d'un ensemble d'opérations asynchrones.

Je ne suis pas sûr de comprendre exactement quel ordre vous essayez d'atteindre dans votre code, mais vous pourriez faire quelque chose comme ça en utilisant votre existant kickoff() fonction et ensuite seulement attacher un .then() gestionnaire après l'appel de c':

function kickOff() {
  return new Promise(function(resolve, reject) {
    $("#output").append("start");

    setTimeout(function() {
      resolve();
    }, 1000);
  }).then(function() {
    $("#output").append(" middle");
    return " end";
  });
}

kickoff().then(function(result) {
    // use the result here
    $("#output").append(result);
});

cela vous donnera une sortie comme celle-ci dans un ordre garanti:

start
middle
end

mise à jour en 2018 (trois ans après cette réponse a été écrite):

si vous transférez votre code ou exécutez votre code dans un environnement qui supporte les fonctionnalités ES7 telles que async et await, vous pouvez maintenant utiliser await faire "apparaître" votre code pour attendre le résultat d'une promesse. Elle se développe encore avec des promesses. Il n'a pas encore bloquez tout Javascript, mais cela vous permet d'écrire des opérations séquentielles dans une syntaxe plus conviviale.

au lieu de la façon ES6 de faire les choses:

someFunc().then(someFunc2).then(result => {
    // process result here
}).catch(err => {
    // process error here
});

Vous pouvez faire ceci:

// returns a promise
async function wrapperFunc() {
    try {
        let r1 = await someFunc();
        let r2 = await someFunc2(r1);
        // now process r2
        return someValue;     // this will be resolved value of the returned promise
    } catch(e) {
        console.log(e);
        throw e;      // let caller know the promise rejected with this reason
    }
}

wrapperFunc().then(result => {
    // got final result
}).catch(err => {
    // got error
});