Comment utiliser les fonctions asynchrones dans Node.js

Avec la nouvelle version du moteur V8, Node.js prend en charge les fonctionnalités des fonctions asynchrones à partir de la version 7.6. Le 31 octobre de cette année, Node.js 8 est également devenu une nouvelle version de support à long terme, afin que vous puissiez utiliser les fonctions asynchrones dans votre code en toute confiance. Dans cet article, je présenterai brièvement ce que sont les fonctions asynchrones et comment elles peuvent changer la façon dont nous écrivons les applications Node.js.

1 Qu'est-ce que la fonction asynchrone

En utilisant la fonction asynchrone, vous pouvez écrire du code asynchrone basé sur la promesse, 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é wait 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 Migrer vers la fonction asynchrone

Si votre application Node.js utilise déjà Promise, il vous suffit alors d'enchaîner l'appel d'origine est réécrit pour attendre vos promesses.

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 bonnes pratiques pour les fonctions asynchrones

3.1 Utilisation des fonctions asynchrones dans express

Express prend à l'origine en charge Promise, il est donc relativement simple d'utiliser les fonctions asynchrones dans express :

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é, il y a un sérieux problème avec l'exemple ci-dessus - si la promesse est finalement rejetée, parce qu'il n'y a pas de gestion des erreurs ici, le processeur de route express sera bloqué.

Pour résoudre ce problème, vous devez envelopper votre gestionnaire asynchrone dans une fonction de gestion des 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 du parallélisme

Par exemple, si vous écrivez un programme, une opération nécessite deux entrées, l'une provenant de la base de données et l'autre 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, ce qui se produit?

Votre code permettra d'abord d'obtenir l'utilisateur,
puis d'obtenir le produit,
et enfin d'effectuer 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)
}

Et parfois, vous n'avez besoin que de la valeur de retour de la promesse résolue la plus rapidement - à ce stade, vous pouvez utilisez 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)

Lorsque ce code est exécuté, vous verrez des messages comme celui-ci :

(node:69738) UnhandledPromiseRejectionWarning : rejet de promesse non gérée (identifiant de rejet : 2) : erreur : error
(node:69738) [DEP0018] DeprecationWarning : les rejets de promesses non gérés sont obsolètes à l'avenir. les refus de promesse qui ne sont pas traités mettront fin au processus Node.js avec un code de sortie différent de zéro, l'ensemble du processus Node.js sera interrompu. Par conséquent, vous devez utiliser try-catch lorsque cela est nécessaire : ​​

const util = require('util') fonction asynchrone main () { essayer { attendre une nouvelle promesse ((résoudre, rejeter) => { rejeter (nouvelle erreur ('

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!