Qu'est-ce que les fonctions de rappel en Node.js

Pourquoi Node.js a adopter un modèle asynchrone et quels en sont les avantages ? Une traduction de l'article What are callbacks?

Classé dans Pour commencer > Structure de contrôle

Traduction

Dans un programme synchrone, vous écrirez quelque chose du genre :

function processData () {
  var data = fetchData ();
  data += 1;
  return data;
}

Cela fonctionne très bien et est très typique dans d'autres environnements de développement. Cependant, si fetchData prend beaucoup de temps pour charger les données (peut-être qu'il les diffuse à partir du disque dur ou d'Internet), le programme entier se “bloque” -autrement dit, il reste inactif et attend- jusqu'à ce que les données soient chargées. Node.js, étant une plateforme asynchrone, il n'attend pas que des choses comme les entrées/sorties ou E/S (I/O) de fichiers se terminent ; Node.js utilise des fonctions de rappel (callback functions). Un rappel est une fonction appelée à la fin d'une tâche donnée ; cela évite tout blocage et permet d'exécuter d'autres codes pendant ce temps.

La façon Node.js de gérer ce qui précède ressemblerait un peu plus à ceci :

function processData (callback) {
  fetchData(function (err, data) {
    if (err) {
      console.log("An error has occurred. Abort everything!");
      return callback(err);
    }
    data += 1;
    callback(data);
  });
}

À première vue, cela peut sembler inutilement compliqué, mais les fonctions de rappel sont la base de Node.js. Les fonctions d'appel vous donnent une interface avec laquelle vous pouvez dire « et quand vous avez fini de faire ça, faites tout ceci ». Cela vous permet d'avoir autant d'opérations d'entrée/sortie que votre système d'exploitation peut en gérer en même temps. Par exemple, sur un serveur web avec des centaines ou des milliers de requêtes en attente et plusieurs requêtes bloquantes, l'exécution asynchrone des requêtes bloquantes vous permet de continuer à travailler et de ne pas vous contenter d'attendre que les opérations bloquantes se terminent. Il s'agit d'une amélioration majeure.

La convention typique des fonctions asynchrones (que la plupart de vos fonctions devraient suivre) :

function asyncOperation ( a, b, c, callback ) {
  // ... plusieurs instructions ...
  if ( /* en cas d'erreur */ ) {
    return callback(new Error("An error has occurred"));
  }
  // ... encore des instructions ...
  callback(null, d, e, f);
}

asyncOperation ( params.., function ( err, returnValues.. ) {
  // Ce code sera exécuté après que les opérations asynchrones se soient terminées
});

Vous devrez presque toujours suivre la convention des erreurs de fonctions de rappel, car la plupart des utilisateurs de Node.js s'attendront à ce que votre projet les respecte. L'idée générale est que la fonction de rappel est le dernier paramètre. La fonction de rappel est appelé après que la fonction ait terminé toutes ses opérations. Traditionnellement, le premier paramètre de la fonction de rappel est la valeur d'erreur. Si la fonction rencontre une erreur, elle appelle généralement le rappel avec comme premier paramètre un objet Error. Si la fonction se termine proprement, elle appelle la fonction de rappel avec un premier paramètre null et le reste étant la ou les valeurs de retour.