Quelle est l'utilisation de l'async dans nodejs

Dans nodejs, le mot-clé async peut être utilisé pour définir une fonction. Lorsque la fonction async est appelée, elle renverra une promesse. Lorsque la fonction async renvoie une valeur, la promesse sera implémentée. la promesse sera rejetée.

L'environnement d'exploitation de ce tutoriel : système windows10, nodejs version 12.19.0, ordinateur DELL G3.

Quelle est l'utilisation de l'async dans nodejs

1 Qu'est-ce que la fonction async

En utilisant la fonction async, vous pouvez écrire du code asynchrone basé sur Promise, tout comme le code synchrone. Une fois que vous avez défini une fonction à l'aide du mot-clé async, vous pouvez utiliser le mot-clé wait dans la fonction. Lorsqu'une fonction asynchrone est appelée, elle renvoie une promesse. Lorsque la fonction asynchrone renvoie une valeur, la promesse est remplie ; si une erreur est générée dans la fonction, la promesse est rejetée. Le mot-clé

await peut être utilisé pour attendre qu'une promesse soit résolue et renvoyer sa valeur réalisée. Si la valeur transmise à wait n'est pas une promesse, elle convertit la valeur en promesse résolue.

const rp = require('request-promise')
async function main () {
 const result = await rp('https://google.com')
 const twenty = await 20
 // 睡个1秒钟
 await new Promise (resolve => {
  setTimeout(resolve, 1000)
 })
 return result
}
main()
 .then(console.log)
 .catch(console.error)

2 Migrez vers les fonctions asynchrones

Si votre application Node.js utilise déjà Promise, il vous suffit de réécrire l'appel de chaîne d'origine pour attendre votre promesse.

Si votre application utilise toujours des fonctions de rappel, vous devez progressivement passer à l'utilisation de fonctions asynchrones. Vous pouvez utiliser cette nouvelle technologie lors du développement de nouvelles fonctionnalités. Lorsque vous devez appeler un ancien code, vous pouvez simplement l'envelopper dans une promesse et l'appeler de la nouvelle manière.

Pour ce faire, vous pouvez utiliser la méthode util.promisify intégrée :

const util = require('util')
const {readFile} = require('fs')
const readFileAsync = util.promisify(readFile)
async function main () {
 const result = await readFileAsync('.gitignore')
 return result
}
main()
 .then(console.log)
 .catch(console.error)

3 Meilleures pratiques pour les fonctions asynchrones

3.1 Utiliser des fonctions asynchrones dans express

express prend à l'origine en charge Promise, donc dans express L'utilisation de fonctions asynchrones est relativement simple :

const express = require('express')
const app = express()
app.get('/', async (request, response) => {
 // 在这里等待 Promise
 // 如果你只是在等待一个单独的 Promise，你其实可以直接将将它作为返回值返回，不需要使用 await 去等待。
 const result = await getContent()
 response.send(result)
})
app.listen(process.env.PORT)

Mais comme Keith Smith l'a souligné, l'exemple ci-dessus présente un problème sérieux : si la promesse est finalement rejetée, puisqu'il n'y a pas de gestion des erreurs ici, alors le processeur de route express est suspendu.

Pour résoudre ce problème, vous devez envelopper votre gestionnaire asynchrone dans une fonction qui gère les erreurs :

const awaitHandlerFactory = (middleware) => {
 return async (req, res, next) => {
  try {
   await middleware(req, res, next)
  } catch (err) {
   next(err)
  }
 }
}
// 然后这样使用：
app.get('/', awaitHandlerFactory(async (request, response) => {
 const result = await getContent()
 response.send(result)
}))

3.2 Exécution parallèle

Par exemple, si vous écrivez un programme comme celui-ci, une opération nécessite deux entrées, l'une d'elles vient de la base de données et l'autre provient d'un service externe :

async function main () {
 const user = await Users.fetch(userId)
 const product = await Products.fetch(productId)
 await makePurchase(user, product)
}

Dans cet exemple, que se passe-t-il ?

Votre code obtiendra d'abord l'utilisateur,

puis obtiendra le produit,

et enfin effectuera le paiement.

Comme vous pouvez le constater, puisqu'il n'y a pas d'interdépendance entre les deux premières étapes, vous pouvez effectivement les exécuter en parallèle. Ici, vous devez utiliser la méthode Promise.all :

async function main () {
 const [user, product] = await Promise.all([
  Users.fetch(userId),
  Products.fetch(productId)
 ])
 await makePurchase(user, product)
}

Parfois, vous n'avez besoin que de la valeur de retour de la promesse résolue la plus rapide - dans ce cas, vous pouvez utiliser la méthode Promise.race.

3.3 Gestion des erreurs

Considérez l'exemple suivant :

async function main () {
 await new Promise((resolve, reject) => {
  reject(new Error('error'))
 })
}
main()
 .then(console.log)

Lors de l'exécution de ce code, vous verrez un message similaire à celui-ci :

(node:69738) UnhandledPromiseRejectionWarning : Rejet de promesse non géré (identifiant de rejet : 2) : Erreur : error

(node:69738) [DEP0018] DeprecationWarning : les rejets de promesses non gérés sont obsolètes. À l'avenir, les rejets de promesses qui ne sont pas traités mettront fin au processus Node.js avec un code de sortie différent de zéro.

Dans Dans un nœud plus récent. Versions .js, si une promesse est rejetée et non gérée, l'ensemble du processus Node.js est interrompu. Par conséquent, vous devez utiliser try-catch si nécessaire : ​​

const util = require('util')
async function main () {
 try {
  await new Promise((resolve, reject) => {
   reject(new Error('

Pour plus de connaissances sur les nœuds, veuillez visiter : tutoriel Nodejs ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!