Nutzungsanalyse von Promise in NodeJS_javascript-Fähigkeiten

Die Eigenschaft von Javascript ist asynchron. Wenn Sie etwas implementieren, das warten muss, können Sie hier nicht aufhören und darauf warten, dass das Ergebnis zurückkommt Definieren Sie eine Funktion, und diese Funktion kann nur warten, bis sie aufgerufen werden kann, wenn die Ergebnisse verfügbar sind.

Dieses Rückrufmodell stellt für eine gute Codeorganisation kein Problem dar, aber viele Probleme können auch durch den Wechsel von ursprünglichen Rückrufen zu Versprechen gelöst werden. Behandeln Sie Versprechen als Standarddatencontainer, wodurch Ihre Codeorganisation vereinfacht werden kann Architektur.

Was ist Versprechen?

Ein Versprechen ist ein Objekt mit einer „.then()“-Methode. Es bedeutet, dass das Ergebnis einer Operation möglicherweise noch nicht verfügbar oder bekannt ist. Unabhängig davon, wer auf dieses Objekt zugreift, kann es die „.then()“-Methode verwenden. "-Methode. Fügen Sie einen Rückruf hinzu, um auf eine Erinnerungsbenachrichtigung zu warten, wenn der Vorgang erfolgreich ist oder fehlschlägt.

Warum ist das also besser als ein Rückruf? Der Standard-Rückrufmodus erfordert eine Rückruffunktion, wenn wir die Anfrage verarbeiten:

request(url, function(error, response) { 

 // handle success or error.

});

doSomethingElse(); 

Leider bedeutet dieser Code, dass die Anforderungsfunktion nicht weiß, wann sie abgeschlossen sein wird. Dies ist natürlich nicht erforderlich und wir übergeben das Ergebnis letztendlich über den Rückruf. Dies führt dazu, dass mehrere Rückrufe verschachtelte Rückrufe oder Rückruffallen bilden.

queryTheDatabase(query, function(error, result) { 

 request(url, function(error, response) {

  doSomethingElse(response, function(error, result) {

   doAnotherThing(result, function(error, result) {

    request(anotherUrl, function(error, response) {

     ...

    });

   });

  });

 });

});

Promise kann dieses Problem lösen, indem es Low-Level-Code ermöglicht, eine Anfrage zu erstellen und dann ein Objekt zurückzugeben, das den nicht abgeschlossenen Vorgang darstellt, sodass der Aufrufer entscheiden kann, welcher Rückruf hinzugefügt werden soll.

Was ist Versprechen?

Promise ist eine Abstraktion der asynchronen Programmierung. Es handelt sich um ein Proxy-Objekt, das einen Wert zurückgibt oder eine Ausnahme auslöst. Mit dieser Then-Methode erhalten wir den Rückgabewert Erfolgreiche Umsetzung des Versprechens, Erfüllung genannt) oder das Auslösen einer Ausnahme (der Grund für die Ablehnung des Versprechens, Ablehnung genannt), verwendet dann zwei optionale Rückrufe als Parameter, die wir onFulfilled und OnRejected aufrufen können:

var Promise = doSomethingAync()
Promise.then(onFulfilled, onRejected)

Wenn dieses Versprechen gelöst ist, also nachdem der asynchrone Prozess abgeschlossen ist, wird entweder onFulfilled oder OnRejected aufgerufen,

Daher hat ein Versprechen die folgenden drei verschiedenen Zustände:

■ausstehendes Versprechen – Anfangszustand des Versprechens
■erfülltes Versprechen – der Status eines Versprechens, das erfolgreich erfüllt wurde
■abgelehnt – ein Zustand, in dem ein Versprechen fehlgeschlagen ist

Am Beispiel des Lesens einer Datei ist Folgendes zu tun, nachdem Rückrufe zum Implementieren des Lesens der Datei (Ausgabedruck) verwendet wurden:

readFile(function (err, data) {

 if (err) return console.error(err)

 console.log(data)

})

Wenn unsere readFile-Funktion ein Versprechen zurückgibt, können wir dieselbe Logik (Ausgabedruck) wie folgt implementieren:

var Promise = readFile()
Promise.then(console.log, console.error)

Hier haben wir ein Wertversprechen, das eine asynchrone Operation darstellt. Wir können dieses Wertversprechen immer weitergeben, um es zu konsumieren, unabhängig davon, ob die durch diesen Wert dargestellte asynchrone Operation abgeschlossen ist. Wir können auch garantieren, dass sich das asynchrone Ergebnis nicht ändert, da der durch dieses Versprechen dargestellte asynchrone Vorgang nur einmal ausgeführt wird und der Status entweder erfüllt oder abgelehnt ist.

Versprechen verstehen

Versprechen kann sich von der täglichen Intuition unterscheiden, um es zu verstehen, müssen einige wichtige Prinzipien beachtet werden: .then() gibt immer ein neues Versprechen zurück, wie zum Beispiel den folgenden Code:

var Promise = readFile()
var Promise2 = Promise.then(readAnotherFile, console.error)

Die Parameter readAnotherFile und console.error stellen hier die Aktion onFulfilled dar, nachdem der asynchrone Vorgang erfolgreich war, oder die Aktion OnRejected nach dem Fehler. Das heißt, die Funktion readAnotherFile wird ausgeführt, nachdem die Datei erfolgreich gelesen wurde, andernfalls ein Fehler wird im Fehlerfall ausgedruckt und protokolliert. Diese Implementierung ist nur eine der beiden möglichen.

Sehen wir uns den obigen Code wie folgt an:

var promise = readFile()

var promise2 = promise.then(function (data) {

 return readAnotherFile() // 如果readFile成功，执行readAnotherFile

}, function (err) {

 console.error(err) // 如果readFile不成功，记录，但是还是执行readAnotherFile

 return readAnotherFile()

})

promise2.then(console.log, console.error) // readAnotherFile函数的执行结果

Da dann ein Versprechen zurückgegeben wird, bedeutet dies, dass das Versprechen von der Kettenserienkette ausgegeben werden kann, wodurch die Rückrufhölle vermieden werden kann:

readFile()

 .then(readAnotherFile)

 .then(doSomethingElse)

 .then(...)

Promise法则有两部分必须分离：

（1）.then()总是返回一个新的promise，每次你调用它，它不管回调做什么，因为.then()在回调被调用之前已经给了你一个承诺promise，回调的行为只影响承诺promise的实施，如果回调返回一个值，那么promise将使用那个值，如果这个值是一个promise，返回这个promise实施后的值给这个值，如果回调抛出错误，promise将拒绝错误。

（2）被.then()返回的promise是一个新的promise，它不同于那些.then()被调用的promise，promise长长的链条有时会好些隐藏这个事实，不管如何，每次.then()调用都会产生一个新的promise，这里必须注意的是你真正需要考虑的是你最后调用.then()可能代表失败，那么如果你不捕获这种失败，那么容易导致你的错误exception消失。

一些人认为.then()串联链条调用很类似fluent风格，但是长长的promise链条会让人迷惑，最后切分为一个个有意义的函数：

function getTasks() { 

 return $http.get('http://example.com/api/v1/tasks')

  .then(function(response) {

   return response.data;

  });

}

 

function getMyTasks() { 

 return getTasks()

  .then(function(tasks) {

   return filterTasks(tasks, {

    owner: user.username

   });

  });

}

在这个例子中，两个函数各自获得一个promise，携带了一个回调函数。

有趣的Promise

同样的promise能够接受任何数目的回调，当一个Promise被解决实施后，其中所有回调函数都会被调用，此外，一个promise在被解决实施后，甚至可以接受一个新的回调，这些回调完成能以正常方式被调用，这就允许我们使用回调实现简单形式的缓存：

var tasksPromise; 

function getTasks() { 

 taskPromise = taskPromise || getTasksFromTheServer();

 return taskPromise;

}

这个案例中，getTasks()函数可以被任意次数调用，它总是返回铜牙的promise，其中函数getTasksFromTheServer()却只是被调用一次。

以上这篇NodeJS的Promise的用法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。