Glossaire Node.js de A à Z — Node.js

Glossaire Node.js — 115 définitions

Tous les termes définis dans les 23 sections du guide, classés par ordre alphabétique.
Astuce : Ctrl + F pour chercher un terme dans la page.

.on() / .emit(): on(événement, callback) : enregistrer un écouteur. emit(événement, données) : déclencher l'événement (tous ses écouteurs sont appelés avec les données).
.once() / .off(): once() : écouter un événement une seule fois (désabonnement auto). off()/removeListener() : arrêter d'écouter un événement.
.pipe(): Connecte un stream de lecture à un stream d'écriture : les données coulent automatiquement de l'un à l'autre, morceau par morceau, avec gestion du débit.
« Ça marche sur ma machine »: Le problème que Docker résout : une application dépend de son environnement et peut échouer ailleurs ; le conteneur embarque son environnement, tournant partout à l'identique.
Adoption progressive: TS s'apprend par étapes (typage léger puis avancé) ; comme sur-ensemble de JS, la maîtrise de JavaScript est réutilisée — on ajoute les types par-dessus.
API + front séparé (SPA): Alternative moderne : Node expose une API REST (JSON) consommée par un front séparé (React/Vue/Angular) qui gère l'affichage côté navigateur.
API REST: Style d'architecture d'API web : exposer des ressources (URL claires) manipulées par les méthodes HTTP selon leur sémantique, réponses en JSON avec les bons codes de statut.
async/await: Syntaxe moderne (sucre sur les Promises) : `await` attend le résultat d'une opération asynchrone sans bloquer ; le code asynchrone se lit comme du synchrone. Erreurs via try/catch.
Asynchrone non-bloquant: Modèle où les opérations lentes (fichiers, réseau, base) ne bloquent pas le programme : Node enregistre un rappel et passe à autre chose en attendant.
Asynchrone vs synchrone (fs): L'asynchrone (non-bloquant) est à privilégier en serveur pour ne pas bloquer la boucle d'événements ; le synchrone (Sync) est réservé aux scripts/config au démarrage.
Authentification vs autorisation: Authentification : QUI est l'utilisateur (401 si non authentifié). Autorisation : a-t-il le DROIT de faire cette action (403 si non autorisé).
Base de données / persistance: Système sauvegardant durablement les données (utilisateurs, produits…). Deux familles : NoSQL (MongoDB) et SQL/relationnel (section 3-4).
Bénéfices de Docker: Reproductibilité (identique partout), isolation (pas de conflits), portabilité (tout hôte Docker), facilité de déploiement, onboarding rapide (docker compose up).
Bénéfices de TypeScript: Erreurs attrapées à la compilation, autocomplétion/outillage supérieurs, documentation implicite (les types décrivent), robustesse et maintenabilité sur les gros projets.
Bénéfices des tests: Confiance (le code fait ce qu'il doit), non-régression (détecter ce qu'une modif casse), documentation (comportement attendu), meilleure conception (code testable = mieux structuré).
Bonnes pratiques REST: URL cohérentes au pluriel, bonnes méthodes/codes de statut, gestion d'erreurs propre, pagination, versionnage (/api/v1/), réponse JSON structurée.
Boucle d'événements (event loop): Mécanisme central orchestrant l'exécution : il lance les opérations lentes en arrière-plan et rappelle les fonctions quand les résultats arrivent.
Buffer: Zone de mémoire brute d'octets pour manipuler les données binaires (fichiers, réseau), que JavaScript n'a pas nativement ; les streams transportent souvent des Buffers.
Callback: Fonction passée en argument, appelée quand une opération asynchrone se termine. Convention Node « error-first » : premier argument = erreur (null si OK), puis le résultat.
Callback hell: Imbrication illisible de callbacks quand on enchaîne des opérations asynchrones dépendantes ; problème que les Promises et async/await résolvent.
Ce qu'Express simplifie: Le serveur natif gère tout à la main (routage par if, parsing du corps, en-têtes) ; Express fournit routage, parsing, middlewares — mais repose sur le module http.
Chemin de module: Local : commence par ./ ou ../ (fichiers du projet). Nom seul : module natif (fs) ou paquet npm de node_modules (express).
CI/CD (GitHub Actions): Automatiser le chemin code → production : CI (à chaque push, tester/vérifier), CD (déployer automatiquement si les vérifications passent). GitHub Actions crée ces pipelines.
Clustering: Lancer plusieurs instances de l'application (une par cœur, via le module cluster ou PM2) qui se répartissent les requêtes ; exploite tous les cœurs (Node étant mono-thread).
CommonJS (CJS): Système de modules historique de Node : export avec `module.exports`, import avec `require()`. Synchrone, simple, omniprésent dans l'écosystème npm.
Compilation (tsc) / tsconfig: TS ne s'exécute pas directement : le compilateur (tsc) vérifie et transforme les .ts en .js. Configuré via tsconfig.json ; ts-node exécute du TS directement en dev.
console.log(): Fonction d'affichage dans le terminal (équivalent de « print ») ; outil de base pour voir des valeurs, déboguer et tracer l'exécution.
const / let (vs var): const : constante non réassignable (à privilégier). let : variable réassignable. Tous deux à portée de bloc. `var` est à éviter (portée déroutante).
CRUD: Les quatre opérations de base : Create (créer), Read (lire), Update (modifier), Delete (supprimer) ; en Mongoose, méthodes asynchrones (await).
dependencies vs devDependencies / node_modules: dependencies : nécessaires en production. devDependencies : utiles en dev seulement (-D). node_modules : dossier des paquets installés (non versionné, régénérable).
Déploiement: Faire tourner l'application sur un serveur accessible sur Internet (au lieu de localhost) ; via une plateforme PaaS (simple) ou un VPS/cloud (plus de contrôle et de responsabilités).
Destructuration: Extraction de valeurs d'objets/tableaux en une ligne : `const { nom } = obj;` ou `const [a, b] = arr;`. Omniprésente (imports, données).
Docker / conteneurisation: Outil empaquetant une application AVEC tout son environnement (Node, dépendances, config) dans un conteneur isolé et portable, qui tourne identiquement partout.
Docker Compose: Fichier docker-compose.yml définissant plusieurs conteneurs (app Node + base + cache…) et leurs relations, lancés ensemble (docker compose up) ; décrit toute la pile.
emit / on / broadcast: emit(événement, data) : envoyer. on(événement, callback) : recevoir. Le serveur émet vers un client, vers TOUS (io.emit, broadcast), ou vers des groupes (rooms).
Erreurs attendues vs inattendues: Attendues : ressource non trouvée (404), validation échouée (400) — gérées explicitement. Inattendues : bugs (500). Aussi : gérer les erreurs async (try/catch autour des await).
error-first / try-catch: Gestion d'erreurs : erreur en premier argument des callbacks ; .catch() pour les Promises ; try/catch autour des await.
ES Modules (ESM): Système de modules standard du langage : export avec `export`, import avec `import`. La direction d'avenir ; activé via .mjs ou "type":"module" dans package.json.
Essentiels de production: Variables d'environnement (config + secrets, jamais dans le code/Git), HTTPS (chiffrement), logs et monitoring (surveiller), environnements séparés (dev/staging/prod).
Événement error: Événement spécial : un émetteur qui émet 'error' sans écouteur fait planter le programme — toujours écouter les erreurs.
EventEmitter: Classe native (module events) au cœur du modèle événementiel de Node ; de nombreux objets natifs (serveur HTTP, streams…) en héritent.
Exécuter un fichier: La façon principale de travailler : écrire son code dans un fichier .js et le lancer avec `node fichier.js` (Node exécute tout le fichier).
Express: Framework web de référence pour Node (minimaliste, flexible), bâti sur le module http ; simplifie routage, parsing et gestion des requêtes. Socle de la plupart des apps Node.
express.Router(): Outil regroupant les routes par ressource dans des fichiers séparés (routeur users, products…) montés sur l'app ; organise une API qui grossit.
Fichiers statiques: Ressources fixes livrées au navigateur (CSS, images, JS client, polices) ; servies simplement avec le middleware express.static('public').
Fonction fléchée (arrow): Syntaxe concise `(a) => ...` pour écrire des fonctions, très utilisée pour les callbacks ; sans `this` propre (évite des pièges).
fs (file system): Module de lecture/écriture de fichiers et dossiers ; fonctions en version asynchrone (à privilégier, fs.promises + await) ou synchrone (Sync, bloquante).
Gestion d'erreurs centralisée: Middleware Express spécial (err, req, res, next) placé en dernier, qui reçoit les erreurs et renvoie une réponse cohérente (bon code, message clair, sans fuite de détails sensibles).
Globaux Node vs navigateur: Node n'a PAS de window/document/DOM (pas de page web) ; il offre process, __dirname, __filename, global et l'accès au système.
Hachage des mots de passe (bcrypt): On ne stocke JAMAIS un mot de passe en clair, mais son hachage à sens unique (bcrypt, avec sel, volontairement lent). À la connexion, on compare sans déchiffrer.
http (module natif): Module permettant de créer un serveur web sans dépendance : http.createServer() avec une fonction appelée à chaque requête, puis .listen(port).
I/O-intensif vs CPU-intensif: Node excelle pour les tâches d'entrées/sorties (serveurs, API, temps réel) ; il est moins adapté aux calculs lourds prolongés (mono-thread).
Image / Dockerfile / conteneur: Image : modèle figé de l'app + environnement, défini par un Dockerfile (recette de construction). Conteneur : instance en exécution d'une image.
Injection SQL: Faille critique : ne JAMAIS concaténer des données utilisateur dans une requête SQL ; utiliser des requêtes paramétrées (les ORM protègent automatiquement).
JWT (JSON Web Token): Jeton signé cryptographiquement émis après connexion, renvoyé par le client à chaque requête (en-tête Authorization) et vérifié par le serveur ; sans état, populaire pour les API.
LTS vs Current: LTS (Long Term Support, versions paires) : stable et maintenue longtemps, à privilégier. Current (impaire) : plus récente mais moins stable, pour tester les nouveautés.
map / filter / reduce: Méthodes de tableaux modernes pour transformer, filtrer et agréger des collections de façon fonctionnelle ; la manière moderne de traiter les données.
Méthodes & codes HTTP: Méthodes : GET (lire), POST (créer), PUT/PATCH (modifier), DELETE (supprimer). Codes : 200 OK, 201 Created, 400/401/404 (erreurs client), 500 (erreur serveur).
Middleware: Fonction (req, res, next) s'exécutant pendant le traitement d'une requête ; peut inspecter/modifier, exécuter du code, puis next() pour passer au suivant. LE concept clé d'Express.
Mise en cache (Redis): Stocker en mémoire (ou dans Redis) les résultats coûteux (requêtes fréquentes, calculs) pour ne pas les refaire ; souvent le levier de performance le plus impactant.
Module: Fichier séparé avec une responsabilité, qui exporte ce qu'il rend disponible et importe ce dont il a besoin ; base de l'organisation du code.
Modules natifs (built-in): Bibliothèques intégrées à Node (aucune installation), donnant accès au système : fs, path, os, http, crypto, events, stream… Importées par leur nom.
MongoDB (NoSQL orienté documents): Base stockant des DOCUMENTS (structures type JSON/BSON) regroupés en COLLECTIONS, sans schéma rigide ; proche des objets JS, populaire avec Node.
Mongoose (ODM): Object Document Mapper ajoutant une couche pratique sur MongoDB : schémas (structure + validation), modèles (méthodes de manipulation).
Moteur de templates (vues): Outil générant du HTML dynamique à partir de templates (HTML + logique : variables, boucles, conditions) et de données ; EJS, Handlebars, Pug…
Moteur V8: Moteur JavaScript de Google Chrome (écrit en C++) qui compile et exécute le JS très rapidement ; le cœur de Node.js.
MVC / séparation des responsabilités: Modèles (données), Contrôleurs (logique de traitement), Routes (URL déléguant aux contrôleurs) ; sépare les préoccupations pour un code maintenable et évolutif.
Node + npm: L'installation de Node apporte l'exécutable Node (qui lance vos scripts) ET npm (le gestionnaire de paquets), installés ensemble.
Node.js: Environnement d'exécution permettant de faire tourner du JavaScript hors du navigateur (côté serveur), basé sur le moteur V8 plus une bibliothèque d'accès au système.
npm & le registre: Gestionnaire de paquets de Node, donnant accès au plus grand registre open source au monde (des centaines de milliers de bibliothèques réutilisables).
nvm (Node Version Manager): Outil permettant d'installer plusieurs versions de Node et de basculer entre elles ; précieux quand des projets exigent des versions différentes.
ORM (Prisma, Sequelize): Object-Relational Mapper faisant correspondre tables et objets JS et générant le SQL ; manipulation d'objets/méthodes plutôt que de SQL brut (lisible, sûr, productif).
os: Module d'accès aux informations système : plateforme, processeurs (os.cpus), mémoire, dossiers standard (homedir, tmpdir).
PaaS (Render, Railway…): Plateformes simplifiant le déploiement : on connecte son dépôt Git, elles construisent, lancent, gèrent serveur/HTTPS/scaling ; niveau gratuit courant. Idéales pour débuter.
package-lock.json: Fichier verrouillant les versions EXACTES installées ; garantit que tout le monde installe les mêmes versions (reproductibilité).
package.json: Manifeste du projet : nom, version, dépendances, scripts, métadonnées. Créé avec `npm init` ; point de référence de tout projet Node.
path: Module de manipulation portable des chemins (path.join, resolve, basename, extname…) : gère les différences de séparateur entre systèmes (/ vs \).
Pipeline de middlewares: Chaîne de fonctions que chaque requête traverse ; routage, parsing (express.json), auth, gestion d'erreurs sont tous des middlewares (app.use ou par route).
Prisma (moderne): ORM apprécié : schéma déclaratif (schema.prisma), migrations (versionner le schéma), client généré et TYPÉ (autocomplétion, sécurité des types — excellent avec TypeScript).
process: Objet global Node donnant accès au processus : arguments (process.argv), variables d'environnement (process.env), sortie (process.exit()).
Profilage / mesurer avant d'optimiser: Identifier les vrais goulots d'étranglement par la mesure avant d'optimiser (règle d'or) ; éviter d'optimiser à l'aveugle ou prématurément.
Programmation événementielle: Modèle où des objets émettent des événements et d'autres parties du code y réagissent en écoutant ; découplage par le nom de l'événement.
Promise: Objet représentant une valeur future (résultat d'une opération asynchrone). Trois états : pending, fulfilled (succès), rejected (erreur). Réactions via .then() et .catch().
Quand utiliser les streams: Dès qu'on traite de gros volumes (gros fichiers, uploads/téléchargements, flux réseau) ; pour de petits fichiers, readFile classique suffit.
REPL: Environnement interactif ouvert en tapant `node` seul : lit/évalue/imprime le JavaScript ligne par ligne. Idéal pour expérimenter sans créer de fichier.
req (request): Objet de la requête entrante : méthode (req.method : GET/POST…), chemin (req.url), en-têtes (req.headers), et corps (lu comme un stream pour POST).
req / res enrichis: req : req.params (route), req.query (query string), req.body (corps). res : res.json(data), res.status(201).json(...), res.send, res.redirect.
require vs import: require() (CommonJS) et import (ESM) sont les deux syntaxes d'import ; comprendre les deux car les deux coexistent dans le code réel.
res (response): Objet de construction de la réponse : statut (res.statusCode), en-têtes (res.setHeader), corps (res.write/res.end).
res.render(): Méthode Express rendant une vue : res.render('page', { données }) génère le HTML en injectant les données dans le template (dossier views/).
Ressources & méthodes HTTP: GET /users (lister), GET /users/:id (lire un), POST /users (créer), PUT/PATCH /users/:id (modifier), DELETE /users/:id (supprimer) — conventions cohérentes.
Rooms: Groupes de clients (un salon de chat, une partie) vers lesquels on diffuse sélectivement ; organisent la communication temps réel.
Routage: Association d'URL + méthode HTTP à des handlers : app.get('/users', ...), app.post(...), etc. Paramètres de route dynamiques : '/users/:id' → req.params.id.
Scaling horizontal / load balancer: Répartir la charge sur plusieurs serveurs/instances derrière un répartiteur de charge ; pour servir un très grand nombre d'utilisateurs (favorise les applications stateless).
Schéma & modèle: Le schéma définit la structure des documents (types, validations : required, unique, défauts) ; le modèle, créé depuis le schéma, offre les méthodes de manipulation.
Sécurité transversale: Helmet (en-têtes de sécurité), HTTPS, secrets en variables d'environnement (jamais dans le code), rate limiting, validation — et « ne jamais faire confiance aux entrées ».
semver & scripts npm: Versionnage MAJEUR.MINEUR.CORRECTIF (^ / ~ contrôlent les mises à jour acceptées). Les scripts npm définissent des commandes réutilisables (npm run ).
Session vs JWT: Session : état côté serveur + cookie d'identifiant. JWT : jeton auto-porteur sans stockage serveur. Deux façons de maintenir l'authentification (HTTP étant sans état).
Socket.IO: Bibliothèque de référence pour le temps réel en Node : événementielle (emit/on), avec reconnexion automatique, fallbacks, rooms et namespaces.
SQL (langage): Structured Query Language : SELECT (lire), INSERT (créer), UPDATE (modifier), DELETE (supprimer), JOIN (combiner des tables liées).
SQL / relationnel: Bases organisant les données en tables (colonnes typées), lignes et relations via clés étrangères ; PostgreSQL, MySQL. Garanties fortes (schéma strict, transactions ACID).
SSR (Server-Side Rendering): Le serveur génère le HTML complet et l'envoie au navigateur ; approche des sites classiques (contenu, SEO).
Stream (flux): Traitement des données par morceaux (chunks), au fur et à mesure, plutôt que tout charger en mémoire ; efficace pour les gros volumes (mémoire et temps).
Template literal: Chaîne avec accents graves permettant d'insérer des variables : `Bonjour ${nom}` — plus propre que la concaténation avec +.
Temps réel: Situations où le serveur envoie des données au client sans qu'il les demande, instantanément (chat, notifications, données live, jeux) ; inadapté au modèle requête-réponse HTTP.
Terminal / PATH: Console où l'on lance node et npm ; `node -v` et `npm -v` vérifient l'installation (si elles répondent, Node est dans le PATH).
Tests automatisés (Jest): Code qui teste votre code : unitaires (une fonction isolée), d'intégration (plusieurs parties/une route avec sa base), bout en bout. Jest est le framework populaire.
Typage statique vs dynamique: Statique (TS) : types déclarés et vérifiés AVANT l'exécution (à la compilation) — attrape des erreurs tôt. Dynamique (JS) : types vérifiés seulement à l'exécution (flexible mais source de bugs au runtime).
Types de streams: Readable (lecture), Writable (écriture), Duplex (les deux, ex. socket), Transform (transforme au passage : compression, chiffrement).
TypeScript: Sur-ensemble de JavaScript ajoutant le typage statique (tout JS valide est du TS valide) ; se compile en JavaScript ordinaire que Node exécute.
Validation des entrées: Vérifier que les données reçues d'un client ont le format attendu (champs requis, types, contraintes) AVANT de les traiter ; rejeter avec un 400 si invalides. Bibliothèques : Zod, Joi.
VPS: Serveur virtuel loué qu'on administre soi-même (Node, config, sécurité, PM2, Nginx, HTTPS) ; plus de contrôle et de flexibilité, mais plus de responsabilités.
VS Code: Éditeur standard pour Node/JavaScript : gratuit, support JS intégré, terminal intégré, extensions (ESLint, Prettier) pour la qualité et le formatage du code.
WebSocket: Protocole établissant une connexion PERSISTANTE et BIDIRECTIONNELLE : elle reste ouverte, et client et serveur s'envoient des messages à tout moment, dans les deux sens.
Worker threads: Threads séparés pour exécuter des tâches CPU-intensives (calculs lourds) sans bloquer le thread principal / la boucle d'événements.