Modules natifs de Node.js (core modules) : fs, http, path, etc.

Modules natifs : La boite a outils integree de Node.js

Au-delà des milliers de modules disponibles via npm, Node.js est livré avec un ensemble riche et puissant de modules natifs (ou core modules). Ces modules sont intégrés directement dans l'environnement d'exécution Node.js ; vous n'avez donc pas besoin de les installer séparément avec `npm install`. Ils fournissent les fonctionnalités fondamentales nécessaires pour interagir avec le système d'exploitation, le système de fichiers, le réseau, et bien plus encore.

Utiliser un module natif est simple : il suffit de l'importer en utilisant la fonction `require()` (pour CommonJS) ou `import` (pour ES Modules) avec le nom exact du module, sans chemin relatif ou absolu. Node.js reconnaîtra ces noms spécifiques et chargera le module intégré correspondant.

// En CommonJS
const fs = require('fs');
const http = require('http');

// En ES Modules (si configuré)
// import fs from 'fs'; // Importe l'objet principal (peut varier selon le module)
// import * as path from 'path'; // Importe toutes les exports nommés
// import { readFile } from 'fs/promises'; // Importation spécifique depuis un sous-module promisifié

Ces modules constituent la base sur laquelle de nombreuses applications et bibliothèques Node.js sont construites. Maîtriser les plus courants est indispensable pour le développement back-end.

Tour d'horizon des modules natifs incontournables

Voici un aperçu de quelques-uns des modules natifs les plus fréquemment utilisés :

• `fs` (File System) : Permet d'interagir avec le système de fichiers. Il offre des fonctions pour lire des fichiers (`fs.readFile`), écrire dans des fichiers (`fs.writeFile`), vérifier l'existence de fichiers (`fs.existsSync`), créer des répertoires (`fs.mkdir`), lister le contenu de répertoires (`fs.readdir`), manipuler les permissions, etc. La plupart de ses fonctions sont asynchrones (utilisant des callbacks error-first par défaut), mais des versions synchrones (bloquantes, ex: `fs.readFileSync`) existent également (à utiliser avec parcimonie !). Node.js propose aussi une API basée sur les Promesses via `require('fs').promises`.

  const fs = require('fs');
  const fsPromises = require('fs').promises;
  
  // Lecture asynchrone (callback)
  fs.readFile('mon_fichier.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log('Contenu (callback):', data);
  });
  
  // Lecture asynchrone (promesse)
  async function lireAvecPromise() {
    try {
      const data = await fsPromises.readFile('mon_fichier.txt', 'utf8');
      console.log('Contenu (promise):', data);
    } catch (err) {
      console.error('Erreur promise:', err);
    }
  }
  lireAvecPromise();

• `http` et `https` : Fournissent les fonctionnalités pour créer des serveurs et des clients HTTP et HTTPS. Le module `http` est fondamental pour construire des serveurs web et des API RESTful. Il permet de créer un serveur (`http.createServer`), d'écouter sur un port, de gérer les requêtes entrantes (`request`) et d'envoyer des réponses (`response`). Il permet aussi de faire des requêtes HTTP sortantes (`http.request`, `http.get`). Le module `https` fait de même mais pour des connexions sécurisées (SSL/TLS).

  const http = require('http');
  
  const server = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Requête reçue !\n');
  });
  
  // Décommenter pour lancer :
  // server.listen(8080, () => {
  //   console.log('Serveur HTTP écoute sur http://localhost:8080');
  // });

• `path` : Offre des utilitaires pour travailler avec les chemins de fichiers et de répertoires de manière indépendante du système d'exploitation (cross-platform). C'est essentiel car Windows utilise des anti-slashes (`\`) tandis que Linux et macOS utilisent des slashes (`/`). Des fonctions comme `path.join()`, `path.resolve()`, `path.basename()`, `path.dirname()`, `path.extname()` permettent de construire et de décomposer des chemins de manière fiable.

  const path = require('path');
  
  const cheminFichier = path.join(__dirname, '..', 'public', 'index.html');
  console.log('Chemin construit:', cheminFichier);
  console.log('Nom du fichier:', path.basename(cheminFichier));
  console.log('Répertoire:', path.dirname(cheminFichier));

• `os` (Operating System) : Permet d'obtenir des informations sur le système d'exploitation sur lequel Node.js s'exécute. Utile pour obtenir l'architecture CPU (`os.arch()`), la plateforme (`os.platform()`), les informations sur les coeurs CPU (`os.cpus()`), la mémoire libre et totale (`os.freemem()`, `os.totalmem()`), le répertoire personnel (`os.homedir()`), le caractère de fin de ligne (`os.EOL`), etc.
• `events` : Fournit la classe `EventEmitter`, qui est au coeur du modèle événementiel asynchrone de Node.js. De nombreux objets Node.js (comme les serveurs HTTP, les flux) héritent de `EventEmitter`. Elle permet d'émettre des événements nommés (`emitter.emit()`) et d'enregistrer des fonctions d'écoute (`emitter.on()` ou `emitter.addListener()`) pour réagir à ces événements.

Explorer plus loin : Autres modules et documentation officielle

La liste ci-dessus n'est pas exhaustive. Node.js inclut de nombreux autres modules natifs utiles :

• `url` : Pour l'analyse et la manipulation des URL.
• `util` : Contient diverses fonctions utilitaires, notamment `util.promisify()` pour convertir des fonctions callback en promesses, et `util.inspect()` pour le formatage avancé d'objets pour le débogage.
• `stream` : Fournit les interfaces fondamentales pour travailler avec des flux de données (streams), essentiels pour manipuler efficacement de grandes quantités de données ou des données arrivant au fil de l'eau (fichiers, réseau).
• `crypto` : Offre des fonctionnalités cryptographiques (hachage, chiffrement, signature, etc.).
• `zlib` : Permet la compression et la décompression de données (gzip, deflate).
• `child_process` : Permet de créer et de gérer des processus enfants, pour exécuter des commandes externes ou d'autres scripts.
• `cluster` : Permet de créer des processus Node.js enfants partageant le même port serveur, afin d'exploiter les systèmes multi-coeurs.
• Et bien d'autres...

La meilleure ressource pour découvrir tous les modules natifs et leurs API détaillées est la documentation officielle de Node.js. Elle est exhaustive, bien organisée et contient de nombreux exemples. Vous la trouverez à l'adresse : https://nodejs.org/api/.

Comprendre et savoir utiliser les modules natifs appropriés est une compétence clé pour tout développeur Node.js, car ils fournissent les blocs de construction essentiels pour la plupart des tâches serveur courantes sans nécessiter de dépendances externes.