Versprechen in Node.js verstehen

Soweit ich verstanden habe, gibt es drei Möglichkeiten, asynchronen Code aufzurufen:

1. Ereignisse, z request.on("event", callback);
2. Rückrufe, z fs.open(path, flags, mode, callback);
3. Versprechen

Ich habe die Node-Promise-Bibliothek gefunden aber ich verstehe sie nicht.

Könnte jemand erklären, worum es bei Versprechungen geht und warum ich sie verwenden sollte?

Warum wurde es auch aus Node.js entfernt?

Versprechen in node.js versprachen, einige Arbeiten auszuführen, und hatten dann separate Rückrufe, die für Erfolg und Misserfolg sowie für die Behandlung von Zeitüberschreitungen ausgeführt wurden. Eine andere Möglichkeit, sich Versprechen in node.js vorzustellen, bestand darin, dass es sich um Emitter handelte, die nur zwei Ereignisse ausgeben konnten: Erfolg und Fehler.

Das Coole an Versprechungen ist, dass Sie sie zu Abhängigkeitsketten kombinieren können (Versprechen C nur ausführen, wenn Versprechen A und Versprechen B abgeschlossen sind).

Durch das Entfernen aus dem Kern node.js wurde die Möglichkeit geschaffen, Module mit unterschiedlichen Implementierungen von Versprechungen aufzubauen, die auf dem Kern sitzen können. Einige davon sind Node-Versprechen und Futures .

Da diese Frage immer noch viele Ansichten hat (wie meine), wollte ich darauf hinweisen, dass:

1. Node-Promise sieht für mich ziemlich tot aus (letztes Commit war vor ungefähr 1 Jahr) und enthält fast keine Tests.
2. Das Futures- Modul sieht für mich sehr aufgebläht aus und ist schlecht dokumentiert (und ich denke, dass die Namenskonventionen einfach schlecht sind)
3. Der beste Weg scheint das q-Framework zu sein , das sowohl aktiv als auch gut dokumentiert ist.

Ein Versprechen ist ein "Ding", das sozusagen die "möglichen" Ergebnisse einer Operation darstellt. Der Punkt hier zu beachten ist , dass es abstrahiert die Details , wenn etwas passiert , und ermöglicht es Ihnen , sich darauf zu konzentrieren , was passieren soll , nachdem das etwas passiert. Dies führt zu sauberem, wartbarem Code, bei dem anstelle eines Rückrufs innerhalb eines Rückrufs innerhalb eines Rückrufs Ihr Code ungefähr so ​​aussieht:

 var request = new Promise(function(resolve, reject) {
   //do an ajax call here. or a database request or whatever.
   //depending on its results, either call resolve(value) or reject(error)
   //where value is the thing which the operation's successful execution returns and
   //error is the thing which the operation's failure returns.
 });

 request.then(function successHandler(result) {
   //do something with the result
 }, function failureHandler(error) {
  //handle
 });

Die Spezifikation der Versprechen besagt, dass ein Versprechen ist

then

Die Methode sollte ein neues Versprechen zurückgeben, das erfüllt wird, wenn der angegebene SuccessHandler- oder FailureHandler-Rückruf beendet ist. Dies bedeutet, dass Sie Versprechen verketten können, wenn Sie eine Reihe von asynchronen Aufgaben haben, die ausgeführt werden müssen, und sicher sein können, dass die Reihenfolge der Vorgänge so gewährleistet ist, als hätten Sie Rückrufe verwendet. Anstatt einen Rückruf innerhalb eines Rückrufs innerhalb eines Rückrufs weiterzuleiten, sieht der Code mit verketteten Versprechungen folgendermaßen aus:

var doStuff = firstAsyncFunction(url) {
                return new Promise(function(resolve, reject) {
                       $.ajax({
                        url: url,
                        success: function(data) {
                            resolve(data);
                        },
                        error: function(err) {
                             reject(err); 
                        } 
                  });
               };
doStuff
  .then(secondAsyncFunction) //returns a promise
  .then(thirdAsyncFunction); //returns a promise

Um mehr über Versprechen zu erfahren und warum sie super cool sind, lesen Sie Domenics Blog: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/

Dieses neue Tutorial zu Promises vom Autor von PouchDB ist wahrscheinlich das beste, das ich je gesehen habe. Es deckt mit Bedacht die klassischen Anfängerfehler ab, die Ihnen korrekte Verwendungsmuster und sogar einige Anti-Muster zeigen, die immer noch häufig verwendet werden - sogar in anderen Tutorials !!

• http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

Genießen!

PS Ich habe einige andere Teile dieser Frage nicht beantwortet, da sie von anderen gut behandelt wurden.

Mike Taulty hat eine Reihe von Videos , die jeweils weniger als zehn Minuten lang sind und beschreiben, wie die WinJS Promise-Bibliothek funktioniert.

Diese Videos sind sehr informativ und Mike schafft es, die Leistungsfähigkeit der Promise-API anhand einiger ausgewählter Codebeispiele zu demonstrieren.

var twitterUrl = "http://search.twitter.com/search.json?q=windows";
var promise = WinJS.xhr({ url: twitterUrl });

 promise = promise.then(
     function (xhr) {
     },
     function (xhr) {
         // handle error
     });

Die Behandlung des Umgangs mit Ausnahmen ist besonders gut.

Trotz der WinJs-Referenzen handelt es sich um eine Videoserie von allgemeinem Interesse, da die Promise-API in ihren zahlreichen Implementierungen weitgehend ähnlich ist.

RSVP ist eine leichtgewichtige Promise-Implementierung, die die Promise / A + -Testsuite besteht. Die API gefällt mir sehr gut, da sie im Stil der WinJS-Oberfläche ähnelt.

Update April 2014

Übrigens ist die WinJS-Bibliothek jetzt Open Source .

Ein weiterer Vorteil von Versprechungen besteht darin, dass die Fehlerbehandlung sowie das Auslösen und Abfangen von Ausnahmen viel besser sind als der Versuch, dies mit Rückrufen zu behandeln.

Die Bluebird- Bibliothek implementiert Versprechen und bietet Ihnen großartige Long-Stack-Traces, ist sehr schnell und warnt vor nicht erfassten Fehlern. Laut http://bluebirdjs.com/docs/benchmarks.html ist es außerdem schneller und benötigt weniger Speicher als die anderen Versprechen-Bibliotheken

Was genau ist ein Versprechen?

Ein Versprechen ist einfach ein Objekt, das das Ergebnis einer asynchronen Operation darstellt. Ein Versprechen kann in einem der folgenden 3 Zustände vorliegen:

ausstehend :: Dies ist der Ausgangszustand, dh das Versprechen wird weder erfüllt noch abgelehnt.

erfüllt :: Dies bedeutet, dass das Versprechen erfüllt wurde, dass der durch das Versprechen dargestellte Wert zur Verwendung bereit ist.

abgelehnt :: Dies bedeutet, dass die Operationen fehlgeschlagen sind und daher das Versprechen nicht erfüllen können. Abgesehen von den Staaten gibt es drei wichtige Einheiten, die mit Versprechungen verbunden sind, die wir wirklich verstehen müssen

1. executor function :: executor function definiert die asynchrone Operation, die ausgeführt werden muss und deren Ergebnis durch das Versprechen dargestellt wird. Die Ausführung wird gestartet, sobald das Versprechen-Objekt initialisiert wurde.

2. Auflösung :: Auflösung ist ein Parameter, der an die Executor-Funktion übergeben wird. Wenn der Executor erfolgreich ausgeführt wird, wird diese Auflösung als Übergabe des Ergebnisses bezeichnet.

3. Reject :: Reject ist ein weiterer Parameter, der an die Executor-Funktion übergeben wird. Er wird verwendet, wenn die Executor-Funktion fehlschlägt. Der Fehlergrund kann an die Ablehnung übergeben werden.

Wenn wir also ein Versprechungsobjekt erstellen, müssen wir Executor, Resolve und Reject bereitstellen.

Referenz :: Versprechen

Ich habe mich kürzlich auch mit Versprechungen in node.js befasst. Bisher scheint das when.js aufgrund seiner Geschwindigkeit und Ressourcennutzung der richtige Weg zu sein, aber die Dokumentation zu q.js hat mir ein viel besseres Verständnis gegeben. Verwenden Sie also when.js, aber die q.js-Dokumente, um das Thema zu verstehen.

Aus der q.js Readme auf Github:

Wenn eine Funktion keinen Wert zurückgeben oder eine Ausnahme auslösen kann, ohne sie zu blockieren, kann sie stattdessen ein Versprechen zurückgeben. Ein Versprechen ist ein Objekt, das den Rückgabewert oder die ausgelöste Ausnahme darstellt, die die Funktion möglicherweise irgendwann bereitstellt. Ein Versprechen kann auch als Proxy für ein entferntes Objekt verwendet werden, um die Latenz zu überwinden.

Das Promise-Objekt repräsentiert den Abschluss oder den Fehler einer asynchronen Operation.

Um ein Versprechen umzusetzen, benötigen Sie zwei Teile:

1. Versprechen erstellen:

Der Versprechen-Konstruktor akzeptiert eine Funktion namens Executor, bei der zwei Parameter aufgelöst und zurückgewiesen werden.

function example(){
   return new Promise (function(resolve , reject){   //return promise object
      if(success){
         resolve('success');  //onFullfiled
      }else{
         reject('error');     //onRejected
      }
   })
}

2. Umgang mit Versprechen:

Das Promise-Objekt verfügt über drei Methoden zum Behandeln von Promise-Objekten: -

1.Promise.prototype.catch (onRejected)

2.Promise.prototype.then (onFullfiled)

3.Promise.prototype.finally (onFullfiled, onRejected)

example.then((data) =>{
  //handles resolved data
  console.log(data); //prints success     
}).catch((err) => {
  //handles rejected error 
  console.log(err);  //prints error
})