Analyse de l'utilisation de Promise dans les compétences NodeJS_javascript

La caractéristique de Javascript est asynchrone. Javascript ne peut pas attendre. Si vous implémentez quelque chose qui doit attendre, vous ne pouvez pas vous arrêter là et attendre que le résultat revienne. Au contraire, l'essentiel est d'utiliser le rappel : vous. définir une fonction, et cette fonction ne peut qu'attendre. Elle ne peut être appelée que lorsque les résultats sont disponibles.

Ce modèle de rappel ne pose aucun problème pour une bonne organisation du code, mais de nombreux problèmes peuvent également être résolus en passant des rappels originaux aux promesses. Traitez les promesses comme un conteneur de données standard, ce qui simplifiera votre organisation de code. architecture.

Qu'est-ce que la promesse ?

Une promesse est un objet avec une méthode ".then()". Cela signifie que le résultat d'une opération n'est peut-être pas encore disponible ou connu. Peu importe qui accède à cet objet, il peut utiliser le ".then()". ". Ajoutez un rappel pour attendre une notification de rappel lorsque l'opération réussit ou échoue.

Alors pourquoi est-ce mieux qu'un rappel ? Le mode de rappel standard nécessite une fonction de rappel lorsque nous traitons la demande :

request(url, function(error, response) { 

 // handle success or error.

});

doSomethingElse(); 

Malheureusement, ce code signifie que la fonction de requête ne sait pas quand elle sera terminée. Bien sûr, ce n'est pas nécessaire, et on finit par transmettre le résultat via le rappel. Cela entraîne plusieurs rappels formant des rappels imbriqués, ou pièges de rappel.

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 peut résoudre ce problème, permettant au code de bas niveau de créer une requête puis de renvoyer un objet, qui représente l'opération inachevée, permettant à l'appelant de décider quel rappel doit être ajouté.

Qu'est-ce que la promesse ?

Promise est une abstraction de la programmation asynchrone. C'est un objet proxy qui renvoie une valeur ou lève une exception. Généralement, les objets de promesse ont une méthode then. Cette méthode then permet d'obtenir la valeur de retour (la valeur résultat du. mise en œuvre réussie de la promesse, appelée accomplissement) ou lancer une exception (la raison du rejet de la promesse, appelée rejet), puis utilise deux rappels facultatifs comme paramètres, que nous pouvons appeler onFulfilled et OnRejected :

var promesse = doSomethingAync()
promise.then(onFulfilled, onRejected)

Lorsque cette promesse est résolue, c'est-à-dire une fois le processus asynchrone terminé, onFulfilled ou OnRejected sera appelé,

Par conséquent, une promesse a les trois états différents suivants :

■en attente promesse en attente - état initial de la promesse
■promesse tenue - le statut d'une promesse tenue avec succès
■rejeté - un état dans lequel une promesse a échoué

En prenant la lecture d'un fichier comme exemple, voici ce qui doit être fait après avoir utilisé les rappels pour implémenter la lecture du fichier (impression de sortie) :

readFile(function (err, data) {

 if (err) return console.error(err)

 console.log(data)

})

Si notre fonction readFile renvoie une promesse, alors nous pouvons implémenter la même logique (impression de sortie) comme suit :

var promesse = readFile()
promise.then(console.log, console.error)

Nous avons ici une promesse de valeur qui représente une opération asynchrone. Nous pouvons toujours transmettre cette promesse de valeur. Toute personne qui accède à cette valeur peut l'utiliser pour la consommer, que l'opération asynchrone représentée par cette valeur soit terminée ou non. , nous pouvons également garantir que le résultat asynchrone ne changera pas, car l'opération asynchrone représentée par cette promesse ne sera exécutée qu'une seule fois et le statut est soit rempli, soit rejeté.

Comprendre la promesse

La promesse peut être différente de l'intuition quotidienne. Afin de la comprendre, certains principes importants doivent être rappelés : .then() renvoie toujours une nouvelle promesse., comme le code suivant :

var promesse = readFile()
var promise2 = promise.then(readAnotherFile, console.error)

Les paramètres readAnotherFile et console.error de alors représentent ici l'action onFulfilled après la réussite de l'opération asynchrone ou l'action OnRejected après l'échec, c'est-à-dire que la fonction readAnotherFile est exécutée après la lecture réussie du fichier, sinon une erreur. est imprimé et enregistré en cas d'échec. Cette implémentation n'est qu'une des deux possibles.

Regardons le code ci-dessus comme suit :

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函数的执行结果

Parce que renvoie alors une promesse, cela signifie que la promesse peut être dépensée par la chaîne en série, ce qui peut éviter l'enfer des rappels :

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的用法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。