Exécuter une fonction après une autre dans Node.js

Node.js est une plateforme logicielle qui permet d’exécuter du code JavaScript côté serveur. Une caractéristique importante de Node.js est son fonctionnement asynchrone, ce qui signifie que certaines fonctions peuvent s’exécuter en arrière-plan pendant que d’autres parties du code continuent de s’exécuter. Cela peut conduire à des situations où vous voulez exécuter une fonction après une autre. Dans cette section, nous allons explorer comment cela peut être réalisé dans Node.js.

Comprendre les fonctions asynchrones

Dans Node.js, les fonctions asynchrones sont des fonctions qui ne bloquent pas l’exécution du reste du code. Elles permettent à Node.js de gérer plusieurs opérations en même temps, ce qui est essentiel pour les applications à haute performance.

Lorsqu’une fonction asynchrone est appelée, elle est mise en file d’attente pour être exécutée plus tard. Pendant ce temps, le reste du code continue de s’exécuter. Une fois que la fonction asynchrone a terminé son exécution, une fonction de rappel est généralement appelée pour gérer le résultat.

Cela peut être déroutant si vous êtes habitué à un code synchrone, où chaque opération est effectuée l’une après l’autre. Cependant, une fois que vous comprenez comment fonctionnent les fonctions asynchrones, vous pouvez écrire du code plus efficace et performant. Dans les sections suivantes, nous allons explorer comment utiliser les callbacks et les promesses pour gérer les fonctions asynchrones dans Node.js.

Utilisation des callbacks

Un callback est une fonction qui est passée en tant qu’argument à une autre fonction et qui est exécutée après que cette dernière a terminé son exécution. Dans Node.js, les callbacks sont souvent utilisés pour gérer les opérations asynchrones.

Par exemple, supposons que vous ayez une fonction qui lit un fichier sur le disque. Cette opération peut prendre un certain temps, donc au lieu de bloquer l’exécution du reste du code, vous pouvez passer une fonction de callback qui sera appelée une fois que le fichier a été lu.

Voici un exemple de code qui utilise un callback :

const fs = require('fs');

fs.readFile('/chemin/vers/le/fichier', 'utf8', function(err, data) {
  if (err) {
    console.error('Une erreur est survenue lors de la lecture du fichier', err);
    return;
  }
  console.log('Le contenu du fichier est :', data);
});

Dans cet exemple, la fonction readFile de Node.js est utilisée pour lire un fichier de manière asynchrone. La fonction de callback est passée en tant que dernier argument et est appelée une fois que le fichier a été lu.

Cependant, l’utilisation de callbacks peut rapidement devenir compliquée, surtout lorsque vous avez besoin d’exécuter plusieurs opérations asynchrones en série ou en parallèle. C’est là que les promesses entrent en jeu, comme nous le verrons dans la section suivante.

Utilisation des promesses

Une promesse est un objet qui représente le résultat éventuel d’une opération asynchrone. Dans Node.js, vous pouvez utiliser des promesses pour gérer les opérations asynchrones de manière plus lisible et gérable.

Voici un exemple de code qui utilise une promesse :

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

fs.readFile('/chemin/vers/le/fichier', 'utf8')
  .then(data => {
    console.log('Le contenu du fichier est :', data);
  })
  .catch(err => {
    console.error('Une erreur est survenue lors de la lecture du fichier', err);
  });

Dans cet exemple, la fonction readFile renvoie une promesse qui se résout avec les données du fichier une fois qu’il a été lu. La méthode then est utilisée pour spécifier une fonction de callback qui est appelée lorsque la promesse est résolue. La méthode catch est utilisée pour gérer les erreurs.

Les promesses peuvent être chaînées ensemble pour exécuter plusieurs opérations asynchrones en série. Elles peuvent également être utilisées avec la syntaxe async/await pour écrire du code asynchrone qui ressemble à du code synchrone.

Cependant, il est important de noter que les promesses ne rendent pas le code synchrone. Elles fournissent simplement une manière plus pratique de gérer les opérations asynchrones. Dans la section suivante, nous allons voir quelques exemples de code qui utilisent des callbacks et des promesses.

Exemples de code

Voici quelques exemples de code qui illustrent comment exécuter une fonction après une autre dans Node.js en utilisant des callbacks et des promesses.

Exemple avec un callback :

function premiereFonction(callback) {
  // Simule une opération asynchrone
  setTimeout(function() {
    console.log('Première fonction terminée');
    callback();
  }, 1000);
}

function deuxiemeFonction() {
  console.log('Deuxième fonction exécutée après la première');
}

// Appelle la première fonction et passe la deuxième en callback
premiereFonction(deuxiemeFonction);

Dans cet exemple, deuxiemeFonction est passé en tant que callback à premiereFonction et est exécuté après que premiereFonction a terminé son exécution.

Exemple avec une promesse :

function premiereFonction() {
  // Retourne une promesse qui se résout après 1 seconde
  return new Promise(function(resolve, reject) {
    setTimeout(function() {
      console.log('Première fonction terminée');
      resolve();
    }, 1000);
  });
}

function deuxiemeFonction() {
  console.log('Deuxième fonction exécutée après la première');
}

// Appelle la première fonction et utilise `then` pour exécuter la deuxième après la première
premiereFonction().then(deuxiemeFonction);

Dans cet exemple, premiereFonction retourne une promesse qui se résout après 1 seconde. La méthode then est utilisée pour exécuter deuxiemeFonction une fois que la promesse est résolue.

Ces exemples illustrent comment vous pouvez contrôler l’ordre d’exécution des fonctions dans Node.js en utilisant des callbacks et des promesses. Cependant, il est important de noter que ces techniques ne rendent pas le code synchrone et que le reste du code continuera à s’exécuter pendant que ces fonctions sont en cours d’exécution.