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

Avec la nouvelle version du moteur V8, Node prend en charge les fonctionnalités de fonction asynchrone à 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 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. [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)

3 Meilleures pratiques pour les fonctions asynchrones

Utiliser les fonctions asynchrones dans express

express prend intrinsèquement en charge Promise, donc l'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 a un sérieux problème - si la promesse est finalement rejetée, puisqu'il n'y a pas de gestion des erreurs ici, alors ce processus de routage express Le serveur 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 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)
}

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!