Node.js - Concept de Callbacks

Bonjour à tous, futurs programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde des callbacks de Node.js. En tant que votre professeur d'informatique bienveillant du coin, je suis là pour vous guider pas à pas à travers ce concept. Ne vous inquiétez pas si vous êtes nouveau dans le domaine de la programmation - nous allons commencer par les bases et progresser étape par étape. Alors, prenez une tasse de café (ou de thé, si c'est votre truc), et plongons dedans !

Qu'est-ce qu'un Callback ?

Imaginez que vous êtes dans un restaurant très fréquenté. Vous passez votre commande au serveur, mais au lieu de rester debout en attendant votre nourriture, vous vous asseyez et discutez avec vos amis. Le serveur va vous " rappeler " lorsque votre nourriture sera prête. C'est essentiellement ce qu'est un callback dans la programmation !

En Node.js, un callback est une fonction qui est passée comme argument à une autre fonction et qui est exécutée après que cette fonction a terminé son opération. C'est un moyen de s'assurer que certain code n'exécute pas avant que l'opération précédente soit terminée.

Voyons un exemple simple :

function greet(name, callback) {
console.log('Bonjour, ' + name + '!');
callback();
}

function sayGoodbye() {
console.log('Au revoir!');
}

greet('Alice', sayGoodbye);

Dans cet exemple, sayGoodbye est notre fonction de callback. Nous la passons à la fonction greet, qui l'appelle après avoir affiché le salut. Lorsque vous exécutez ce code, vous verrez :

Bonjour, Alice!
Au revoir!

Le callback nous permet de contrôler la séquence des opérations, en nous assurant que "Au revoir !" est imprimé après le salut.

Exemple de Code Bloquant

Avant de plonger plus profondément dans les callbacks, regardons ce qui se passe lorsque nous ne les utilisons pas. Cela s'appelle le "code bloquant" car il arrête (ou bloque) l'exécution du code suivant jusqu'à ce que l'opération actuelle soit terminée.

Voici un exemple de code bloquant :

const fs = require('fs');

// Code bloquant
const data = fs.readFileSync('example.txt', 'utf8');
console.log(data);
console.log('Lecture du fichier terminée');
console.log('Programme terminé');

Dans cet exemple, readFileSync est une fonction synchrone qui lit un fichier. Le programme attendra jusqu'à ce que le fichier soit complètement lu avant de passer à la ligne suivante. Si le fichier est volumineux, cela pourrait causer un délai notable dans votre programme.

Exemple de Code Non-Bloquant

Maintenant, voyons comment nous pouvons utiliser des callbacks pour rendre notre code non-bloquant :

const fs = require('fs');

// Code non-bloquant
fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) {
console.error('Erreur lors de la lecture du fichier:', err);
return;
}
console.log(data);
});

console.log('Lecture du fichier commencée');
console.log('Programme terminé');

Dans cette version non-bloquante, readFile prend une fonction de callback comme dernier argument. Cette fonction est appelée lorsque la lecture du fichier est terminée (ou si une erreur se produit). Le programme n'attend pas que le fichier soit lu; il continue immédiatement l'exécution des lignes suivantes.

La sortie pourrait ressembler à ceci :

Lecture du fichier commencée
Programme terminé
[Contenu de example.txt]

Notez comment "Lecture du fichier commencée" et "Programme terminé" sont imprimés avant le contenu du fichier. C'est parce que la lecture du fichier se produit asynchronously, permettant au reste du programme de continuer à s'exécuter.

Callback en tant que Fonction Flèche

En JavaScript moderne, nous utilisons souvent des fonctions flèches pour les callbacks. Elles offrent une syntaxe plus concise. Reprenons notre exemple de salutation précédent en utilisant une fonction flèche :

function greet(name, callback) {
console.log('Bonjour, ' + name + '!');
callback();
}

greet('Bob', () => {
console.log('Au revoir!');
});

Ici, au lieu de définir une fonction separate sayGoodbye, nous avons inclus le callback directement dans l'appel de la fonction greet en utilisant une fonction flèche.

C'est particulièrement utile lorsque le callback est court et que nous n'avons pas besoin de le réutiliser ailleurs dans notre code.

Enfer des Callbacks et Comment L'éviter

À mesure que vos programmes deviennent plus complexes, vous pourriez vous trouver à imbriquer des callbacks à l'intérieur d'autres callbacks. Cela peut conduire à une situation connue sous le nom d'"enfer des callbacks" ou "pyramide de la destruction". Ça ressemble à ça :

asyncOperation1((error1, result1) => {
if (error1) {
handleError(error1);
} else {
asyncOperation2(result1, (error2, result2) => {
if (error2) {
handleError(error2);
} else {
asyncOperation3(result2, (error3, result3) => {
if (error3) {
handleError(error3);
} else {
// Et ainsi de suite...
}
});
}
});
}
});

Pour éviter cela, nous pouvons utiliser des techniques telles que :

1. Fonctions nommées au lieu de fonctions anonymes
2. Promesses
3. Async/await (qui utilise des promesses sous le capot)

Voici un tableau résumant ces méthodes :

Méthode	Description	Avantages	Inconvénients
Fonctions Nommées	Définir des fonctions séparées pour chaque callback	Améliore la lisibilité	Peut encore entraîner de nombreuses fonctions imbriquées
Promesses	Utiliser des chaînes .then()	Aplatit l'imbrication, meilleure gestion des erreurs	Nécessite de comprendre le concept de promesse
Async/Await	Utiliser des fonctions async et le mot-clé await	Ressemble à du code synchrone, très lisible	Nécessite de comprendre les promesses et les fonctions async

Conclusion

Les callbacks sont un concept fondamental dans Node.js et dans le JavaScript en général. Ils nous permettent de travailler avec des opérations asynchrones efficacement, rendant nos programmes plus efficaces et réactifs. Alors que vous poursuivez votre parcours en programmation, vous rencontrerez souvent des callbacks, et les comprendre bien vous rendra un développeur plus compétent.

Souvenez-vous, comme pour toute nouvelle compétence, maîtriser les callbacks nécessite de la pratique. Ne vous découragez pas si cela ne vous vient pas immédiatement - continuez à coder, continuez à expérimenter, et bientôt, vous serez un pro des callbacks !

Bonne programmation, futurs développeurs ! Et souvenez-vous, dans le monde de la programmation, nous ne disons pas adieu - nous nous callbackons plus tard !

Credits: Image by storyset