Aujourd'hui, j'ai continué mon parcours d'apprentissage de Node.js avec l'aide de l'IA, et le sujet du jour 2 était le système de modules dans Node.js. Comme je connais déjà JavaScript, il était intéressant d'apprendre comment ce langage organise le code en modules, ce qui facilite sa structuration et sa réutilisation.

Partie théorique : bases des modules dans Node.js

J'ai d'abord parcouru la partie théorique, qui expliquait deux concepts clés :

1. require : Cette fonction est utilisée pour importer des modules dans votre code. Lorsque vous appelez require('module_name'), Node.js trouve le module spécifié et renvoie son contenu. Il peut s'agir d'un module intégré, d'un module du package node_modules ou de votre propre module personnalisé.

2. module.exports : cet objet est utilisé pour exporter les fonctionnalités d'un module afin qu'il puisse être utilisé par d'autres modules via require. Vous pouvez exporter des fonctions, des objets, des variables ou des classes.

Ces concepts étaient nouveaux pour moi dans le contexte de Node.js, mais similaires à ce que j'ai vu dans d'autres langages de programmation.

Application pratique : création de modules

J'ai commencé par créer plusieurs modules pour différentes opérations mathématiques, comme suggéré dans l'article.

1. addition.js : ce module effectue des additions.
   

   function add(a, b) {
       return a   b;
   }
   
   module.exports = add;
   

2. subtraction.js : Un module de soustraction.
   

   function subtract(a, b) {
       return a - b;
   }
   
   module.exports = subtract;
   

3. multiplication.js : Un module pour la multiplication.
   

   function multiply(a, b) {
       return a * b;
   }
   
   module.exports = multiply;
   

4. division.js : Un module pour la division.
   

   function divide(a, b) {
       if (b === 0) {
           return 'Error: Division by zero';
       }
       return a / b;
   }
   
   module.exports = divide;
   

Après avoir créé ces modules, j'ai commencé à écrire le fichier principal qui les utiliserait.

1. calculator.js : Dans ce fichier, j'ai importé tous les modules que j'ai créés et écrit du code pour effectuer des opérations arithmétiques.
   

   const add = require('./addition');
   const subtract = require('./subtraction');
   const multiply = require('./multiplication');
   const divide = require('./division');
   
   console.log("Addition: 5   3 =", add(5, 3));
   console.log("Subtraction: 5 - 3 =", subtract(5, 3));
   console.log("Multiplication: 5 * 3 =", multiply(5, 3));
   console.log("Division: 6 / 2 =", divide(6, 2));
   

Extension des fonctionnalités

Après avoir effectué les opérations de base, j'ai décidé de me mettre au défi en ajoutant de nouvelles fonctions à la calculatrice. J'ai créé des modules supplémentaires pour l'exponentiation et la racine carrée :

1. exponentiation.js : un module pour l'exponentiation.
   

   function exponentiate(base, exponent) {
       return Math.pow(base, exponent);
   }
   
   module.exports = exponentiate;
   

2. sqlt.js : Un module pour calculer la racine carrée.
   

   function sqrt(number) {
       return Math.sqrt(number);
   }
   
   module.exports = sqrt;
   

Je les ai ajoutés au fichier principal calculator.js, et maintenant ma calculatrice prend en charge les opérations étendues :

const add = require('./addition');
const subtract = require('./subtraction');
const multiply = require('./multiplication');
const divide = require('./division');
const exponentiate = require('./exponentiation');
const sqrt = require('./sqrt');

console.log("Addition: 5   3 =", add(5, 3));
console.log("Subtraction: 5 - 3 =", subtract(5, 3));
console.log("Multiplication: 5 * 3 =", multiply(5, 3));
console.log("Division: 6 / 2 =", divide(6, 2));
console.log("Exponentiation: 2 ^ 3 =", exponentiate(2, 3));
console.log("Square root of 16 =", sqrt(16));

Résultats et conclusions

En appliquant la théorie dans la pratique, j'ai mieux compris comment les modules aident à organiser le code et à quel point ils sont faciles à utiliser dans Node.js. Travailler avec des fichiers séparés pour chaque opération m'a fait réaliser l'importance de la modularité et comment elle améliore la lisibilité et l'évolutivité du code.

Cette expérience m'a montré à quel point il est crucial de bien organiser le code, d'autant plus qu'un projet devient plus complexe. Maintenant, je me sens en confiance pour travailler avec des modules dans Node.js et je suis prêt pour la prochaine étape de mon parcours d'apprentissage.

Pour plus de détails sur cette leçon, vous pouvez vous référer au didacticiel complet ici.

C'est ainsi que j'ai appris de l'article et compris comment les modules fonctionnent dans Node.js grâce à une application pratique.