Comment synchroniser les fonctions de rappel dans nodejs

Node.js est un environnement d'exécution JavaScript basé sur des E/S événementielles et non bloquantes qui utilise le moteur V8 pour analyser le code JavaScript. Dans Node.js, les fonctions de rappel constituent un modèle de programmation courant pour le traitement des tâches de manière asynchrone. Cependant, nous devons parfois exécuter du code ultérieur après l'exécution de la fonction de rappel, ce qui signifie que nous devons exécuter la fonction de rappel de manière synchrone. Cet article explique comment implémenter des fonctions de rappel synchrone dans Node.js.

1. Fonction de rappel

La fonction de rappel est un modèle de programmation courant en JavaScript pour le traitement asynchrone des tâches. Un grand nombre d'API dans Node.js adoptent ce modèle. Par exemple, les requêtes réseau, la lecture et l'écriture de fichiers, les requêtes de base de données, etc. nécessitent toutes l'utilisation de fonctions de rappel. Voici un exemple simple :

const fs = require('fs');

fs.readFile('/path/to/file', function(err, data) {
  if (err) {
    console.error(err);
  } else {
    console.log(data);
  }
});

console.log('Hello, world!');

Dans l'exemple ci-dessus, la fonction fs.readFile() lit un fichier si la lecture réussit, le contenu du fichier est affiché via la fonction de rappel ; la lecture échoue, le message d'erreur est généré via la fonction de rappel. Lors de l'appel de la fonction fs.readFile(), le deuxième paramètre est une fonction de rappel qui sera exécutée une fois la lecture du fichier terminée.

2. Problèmes avec les fonctions de rappel asynchrones

Dans Node.js, la fonction de rappel est exécutée de manière asynchrone, ce qui signifie qu'elle sera asynchrone en arrière-plan Les tâches de traitement seront exécutées une fois la tâche terminée. Si nous avons plusieurs tâches asynchrones à exécuter, nous devons imbriquer plusieurs fonctions de rappel. Ce modèle de programmation de fonctions de rappel imbriquées est connu sous le nom de « l'enfer du rappel » et peut rendre le code difficile à lire et à maintenir.

const fs = require('fs');

fs.writeFile('/path/to/file', 'Hello, world!', function(err) {
  if (err) {
    console.error(err);
  } else {
    fs.readFile('/path/to/file', function(err, data) {
      if (err) {
        console.error(err);
      } else {
        console.log(data);
      }
    });
  }
});

Dans l'exemple ci-dessus, nous écrivons des données dans un fichier et lisons le contenu du fichier une fois l'écriture terminée. Puisque fs.writeFile() et fs.readFile() sont toutes deux des fonctions asynchrones, nous devons imbriquer deux fonctions de rappel pour terminer la tâche. Cette imbrication peut rendre le code complexe et difficile à maintenir et à tester.

3. Event-driven

Afin de résoudre le problème des fonctions de rappel asynchrones, Node.js adopte un modèle de programmation événementielle. Piloté par les événements est un modèle de programmation orienté événement qui considère un programme comme un ensemble d'événements, dont chacun peut produire une ou plusieurs réponses. Dans Node.js, la gestion des événements est implémentée par la classe EventEmitter. Voici un exemple simple :

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('event', function() {
  console.log('an event occurred!');
});

myEmitter.emit('event');

Dans l'exemple ci-dessus, nous avons créé une classe MyEmitter et implémenté le pilotage d'événements en héritant de la classe EventEmitter. Nous enregistrons une fonction de gestion d'événements via la méthode on(), et la méthode submit() déclenche l'événement et appelle la fonction de gestion d'événements. Lorsqu'un événement est déclenché, la fonction de gestionnaire d'événements est appelée et effectue l'opération correspondante.

4. Fonction de rappel synchrone

Dans Node.js, nous pouvons utiliser la fonction de rappel synchrone pour éviter le problème de l'enfer du rappel. La fonction de rappel synchrone sera exécutée immédiatement après la fin de la tâche asynchrone, au lieu d'attendre que la tâche asynchrone soit terminée avant de s'exécuter. Node.js propose deux manières d'implémenter des fonctions de rappel synchrones : Promise et async/await.

4.1 Promise

Promise est une solution de programmation asynchrone qui convertit les opérations asynchrones en appels chaînés pour traitement. La promesse a trois états : En attente, Réalisée et Rejetée. Une fois l'opération asynchrone terminée, la promesse transmettra le résultat de la fonction de rappel à la fonction chaînée suivante.

Ce qui suit est un exemple d'utilisation de Promise pour implémenter une fonction de rappel synchrone :

const fs = require('fs').promises;

const readAndWrite = async function() {
  try {
    await fs.writeFile('/path/to/file', 'Hello, world!');
    const data = await fs.readFile('/path/to/file');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
};

readAndWrite();

Dans l'exemple ci-dessus, nous utilisons la méthode Promise fournie par le module fs.promises pour lire et écrire Importer le fichier. Nous utilisons async/await pour implémenter la fonction d'exécution synchrone des fonctions de rappel. Puisque async/await doit être utilisé dans les fonctions asynchrones, nous devons utiliser une fonction async pour encapsuler les opérations asynchrones.

4.2 async/await

async/await est une solution de programmation asynchrone qui traite les opérations asynchrones en synchronisation, rendant le code plus concis et plus facile à lire.

Ce qui suit est un exemple d'utilisation de async/await pour implémenter une fonction de rappel synchrone :

const fs = require('fs').promises;

const readAndWrite = async function() {
  try {
    await fs.writeFile('/path/to/file', 'Hello, world!');
    const data = await fs.readFile('/path/to/file');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
};

readAndWrite();

Dans l'exemple ci-dessus, nous utilisons la méthode Promise fournie par fs.promises module pour lire et écrire dans le fichier. Nous utilisons async/await pour implémenter la fonction d'exécution synchrone des fonctions de rappel. Puisque async/await doit être utilisé dans les fonctions asynchrones, nous devons utiliser une fonction async pour encapsuler les opérations asynchrones.

5. Summary

Les fonctions de rappel sont un modèle de programmation courant dans Node.js pour le traitement asynchrone des tâches. Cependant, étant donné que les fonctions de rappel sont exécutées de manière asynchrone de par leur nature, cela peut introduire de la complexité et de l’illisibilité dans le code. Pour résoudre ce problème, nous pouvons utiliser un modèle de programmation basé sur les événements, ou utiliser Promise et async/await pour implémenter des fonctions de rappel synchrones. Dans le processus de programmation proprement dit, nous devons choisir des modèles de programmation et des solutions techniques appropriés en fonction des besoins et des scénarios commerciaux spécifiques.

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!