Comment attendre l'exécution avant la fermeture de nodejs

Node.js est un environnement d'exécution JavaScript très populaire qui peut être utilisé pour créer des applications Web hautes performances, des outils de ligne de commande, des robots d'exploration Web, etc. Dans les applications Node.js, nous devons souvent effectuer certaines opérations avant la fermeture de Node.js, telles que la libération de ressources, la sauvegarde de l'état, etc. Cependant, avant l'arrêt de Node.js, nous devons nous assurer que toutes les opérations asynchrones ont été terminées, sinon une perte de données ou une incohérence pourrait en résulter. Alors, comment attendre l’exécution avant la fermeture de Node.js ? Cet article vous présentera plusieurs méthodes couramment utilisées.

Méthode 1 : utiliser process.exitCode

Le processus objet de processus de Node.js fournit un attribut exitCode, qui est utilisé pour spécifier le code de sortie de l'application et peut également effectuer certaines opérations avant la fermeture de l'application. Par exemple, nous pouvons encapsuler l'opération asynchrone dans un objet Promise, puis attendre la fin de l'objet Promise dans l'événement process.on('beforeExit'). Si l'objet Promise est résolu, nous pouvons définir process.exitCode sur 0, sinon sur 1.

const fs = require('fs');

function readFile(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, (err, data) => {
      if (err) {
        reject(err);
      } else {
        resolve(data);
      }
    });
  });
}

process.on('beforeExit', async () => {
  try {
    const data = await readFile('data.txt');
    console.log(data.toString());
    process.exitCode = 0;
  } catch (err) {
    console.error(err);
    process.exitCode = 1;
  }
});

Méthode 2 : utiliser dans Promise.all et setTimeout

Une autre méthode couramment utilisée consiste à utiliser Promise.all et setTimeout pour attendre la fin de l'opération asynchrone. Promise.all est utilisé pour exécuter un ensemble d'opérations asynchrones en parallèle. Lorsque toutes les opérations asynchrones sont terminées, Promise.all renverra un objet Promise, puis nous pourrons attendre un certain temps dans setTimeout, et enfin quitter l'application dans la fonction de rappel setTimeout. Par exemple :

async function myApp() {
  const promises = [promise1(), promise2(), promise3()];
  await Promise.all(promises);
  setTimeout(() => {
    process.exit();
  }, 1000);
}

myApp();

Dans cet exemple, nous définissons d'abord un ensemble d'opérations asynchrones promise1, promise2 et promise3, puis utilisons Promise.all pour attendre la fin de toutes les opérations. Ensuite, nous attendons 1 seconde dans setTimeout, et enfin quittons l'application via la méthode process.exit() dans la fonction de rappel setTimeout.

Méthode 3 : Utiliser async_hooks

Enfin, nous introduisons une méthode avancée : utiliser async_hooks. Il s'agit d'un module intégré à Node.js pour suivre le cycle de vie des opérations asynchrones. Nous pouvons créer une ressource asynchrone via async_hooks et suivre son cycle de vie. Plus précisément, nous pouvons utiliser la méthode async_hooks.createHook() pour créer un hook asynchrone, puis définir des fonctions avant, après et destroy dans le hook. Ces fonctions sont appelées à différentes étapes de l'opération asynchrone. Par exemple :

const async_hooks = require('async_hooks');

const resources = new Map();

const hook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    if (type === 'Promise') {
      resources.set(asyncId, 'Promise');
    }
  },
  destroy(asyncId) {
    resources.delete(asyncId);
  },
});

hook.enable();

async function myApp() {
  const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve();
    }, 1000);
  });
  await promise;
}

myApp();

process.on('beforeExit', () => {
  if (resources.size > 0) {
    console.warn('There are some unhandled promises!');
  } else {
    console.log('Everything is OK!');
  }
});

Dans cet exemple, nous créons d'abord un hook asynchrone et suivons la ressource Promise dans la fonction init du hook. Ensuite, dans la fonction myApp, nous créons un objet Promise et attendons qu'il se termine après 1 seconde. Enfin, dans l'événement process.on('beforeExit'), nous vérifions s'il existe des ressources Promise non traitées. Si tel est le cas, générons un message d'avertissement, sinon générons un message normal.

Résumé

Cet article présente plusieurs façons d'attendre la fin des opérations asynchrones dans Node.js. Ils incluent l'utilisation de process.exitCode, Promise.all et setTimeout, ainsi que async_hooks. Dans le développement réel, nous devons choisir la méthode appropriée en fonction des besoins de l'application et nous assurer que toutes les opérations asynchrones sont traitées correctement pour garantir l'intégrité et l'exactitude des données.

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!