Parlons de la façon d'utiliser les fonctions asynchrones dans Node.js

Avec l'aide du nouveau 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.

Qu'est-ce que la fonction asynchrone

En utilisant la fonction asynchrone, 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. [Recommandations de didacticiel associées : Tutoriel vidéo Nodejs, Enseignement de la programmation]

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)

Migrer 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)

Bonnes pratiques pour les fonctions asynchrones

Utiliser les fonctions asynchrones dans express

express prend intrinsèquement en charge Promise, donc dans Utilisation des fonctions asynchrones dans express 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, car il n'y a pas de gestion des erreurs ici, alors le processeur de route express sera 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)
}))

Exécution parallèle

Supposons que vous écriviez un programme dans lequel une opération nécessite deux entrées, l'une de la base de données et l'autre de un service externe :

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

Que se passe-t-il dans cet exemple ?

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.

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!