Wie Sie warten, bis der JavaScript-Versprechen zu beheben, bevor Sie die Funktion wieder aufnimmt?

Frage ich mich, ob es irgendeinen Weg gibt, um einen Wert aus einem Versprechen oder
warten (block/sleep), bis es sich aufgelöst hat, ähnlich .NET
IAsyncResult.WaitHandle.WaitOne(). Ich weiß, JavaScript ist
single-threaded, aber ich hoffe, dass bedeutet nicht, dass eine Funktion
kann nicht nachgeben.

Die aktuelle generation von Javascript im Browser nicht über eine wait() oder sleep(), die ermöglicht, dass die Dinge laufen. So, Sie können nicht einfach tun, was Sie gefragt haben. Stattdessen hat es async-Operationen, die machen Ihr Ding und dann rufen Sie an, wenn Sie fertig sind (wie Sie bisher verspricht).

Teil davon ist, weil Javascript single-threadedness. Wenn die single-thread dreht, dann keine anderen Javascript ausführen kann, bis das Spinnen-thread ist fertig. ES6 führt yield und Generatoren, die es erlauben, einige kooperative tricks wie, dass, aber wir sind ziemlich weit in der Lage, Sie zu verwenden diese in einem breiten swatch der installierten Browser (Sie können verwendet werden, in einigen server-side Entwicklung, wo Sie Steuern die JS-engine, die verwendet wird).

Sorgfältiger Umgang mit den promise-basierten code kann die Reihenfolge der Ausführung für viele asynchrone Operationen.

Ich bin mir nicht sicher, ob ich verstehe genau, was um Sie zu erreichen versuchen, in Ihrem code, aber Sie konnte etwas tun, wie diese mit Ihrem bestehenden kickOff() Funktion, und dann das anbringen einer .then() - handler, der nach Aufruf:

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

Zurückkehren Ausgang in einer garantierten Reihenfolge - so:

start
middle
end

Update im Jahr 2018 (drei Jahre nach dieser Antwort geschrieben wurde):

Wenn Sie entweder transpile code, oder führen Sie Ihren code in einer Umgebung, unterstützt ES7 Funktionen wie async und await können Sie jetzt await um Ihren code zu "erscheinen" auf das Ergebnis warten ein Versprechen. Es ist noch in der Entwicklung, mit dem Versprechen. Es tut immer noch nicht alle blockieren von Javascript, aber es erlaubt Ihnen, zu schreiben, sequenzielle Operationen in eine freundlichere syntax.

Anstelle des ES6 Weg, Dinge zu tun:

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

Können Sie dies tun:

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

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

Andere Möglichkeit ist die Verwendung Versprechen.alle warten, für eine Reihe von Versprechungen zu beheben.
Der Code unten zeigt, wie zu warten, bis alle Versprechen zu lösen, und befasst sich dann mit den Ergebnissen, sobald Sie sind alle bereit, (als, die zu sein schien das Ziel der Frage); Allerdings beginnen konnte, offensichtlich Ausgabe vor der Mitte aufgelöst hat, einfach durch hinzufügen von code, bevor Sie es nennt, zu lösen.

JS:

function kickOff() {
  let start = new Promise((resolve, reject) => resolve("start"))
  let middle = new Promise((resolve, reject) => {
    setTimeout(() => resolve(" middle"), 1000)
  })
  let end = new Promise((resolve, reject) => resolve(" end"))

  Promise.all([start, middle, end]).then(results => {
    results.forEach(result => $("#output").append(result))
  })
}

kickOff()

HTML:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="output"></div>