Verwenden von Versprechen, wenn Antwort Callback

Question

Ich versuche herauszufinden, wie Versprechungen in einem Test zu verwenden Ich schreibe. Ich benutze einfache alte Versprechen im Browser. Keine Bibliotheken (noch)

Der Test erfordert asynchron mit einem Server in Verbindung steht, wo ich die Antwort des Servers über einen Rückruf erhalten

Ich habe einen Server-Objekt, wo ich den Rückruf zu registrieren wie so:

server.onresponse = function(data){ 
    //do stuff with data 
} 

Der Test erfordert das Senden einer Reihe von Befehlen an den Server, die sich basierend auf der Serverantwort ändern. Ich sende die Befehle an den Server wie folgt:

server.sendCommand({data:"do something"}) 

Basierend auf dem Befehl würde der Server den OnResponse Callback auslösen. Ich müsste die Daten lesen, die der Server gesendet hat, um zu entscheiden, was der nächste Befehl sein soll.

Die Wechselwirkung sollte wie

• Sendebefehl 1 und wartet
• Prozessdaten von onresponse Rückruf
• Sendebefehl 2 und wartet
• Prozessdaten von onresponse Rückruf seines

Ich würde gerne Versprechungen machen, um diese Interaktion etwas übersichtlicher zu gestalten. Wie etwas wie eine Reihe von .then() s.

Ich weiß, dass Versprechungen nicht wiederverwendet werden können, es ist also nicht so, dass ich jedes Mal, wenn der On-Response-Callback stattfindet, dasselbe Versprechen setzen kann.

Gibt es eine Möglichkeit, dies über Versprechen zu tun? Ich fing an, auch Generatoren auszulesen. Würden diese auch helfen?

function sendCommand(data) { 
    return new Promise(function(resolve,reject) { 
     server.onresponse = resolve; 
     server.sendCommand(data); 
    }); 
} 

und es wie folgt verwenden:

sendCommand({data:"do something"}) 
.then(function(data) { 
    console.log(data); 
    return sendCommand({data:"do something else "}) 
}) 
.then(function(data) { 
    console.log(data); 
}) 

Answer 1

Sie so etwas wie dieses haben könnte. Übergeben Sie den Befehl und geben Sie eine Promise zurück, die mit der Antwort vom Server aufgelöst wird. Wenn es einen Fehler gibt, der Rückruf behandelt, sollten Sie es auch verwenden. Zum Beispiel, nennen wir es server.onerror. Sie sollten dies durch den richtigen Handler ersetzen.

function sendCommand(cmd) { 
    const promise = new Promise((resolve, reject) => { 
    server.onresponse = resolve; 
    server.onerror = reject; 
    }); 
    server.sendCommand(cmd); 
    return promise; 
} 

Sie würden es verwenden, genau wie Sie beschrieben, eine Versprechenskette. Natürlich möchten Sie wahrscheinlich etwas mit der Antwort machen, anstatt nur den nächsten Befehl auszulösen. Und denken Sie immer daran, am Ende alle Fehler mit catch zu behandeln!

sendCommand({data: "do thing 1"}) 
    .then((response) => sendCommand({data: "do thing 2"})) 
    .then((response) => sendCommand({data: "do thing 3"})) 
    .then((response) => console.log("All done!")) 
    .catch((error) => console.log("Oops!")); 

Answer 2

Sie können eine Hilfsfunktion schreiben zu tun genau das, was Sie beschrieben

Dank