C'est quoi Node.js ? Définition, installation et premier script

Node.js est un environnement d'exécution JavaScript : un programme qui fait tourner du JavaScript hors du navigateur, directement sur un ordinateur ou un serveur. Il sert surtout à écrire des serveurs web et des API, mais aussi des outils en ligne de commande et des scripts. Ce chapitre explique ce qu'est Node.js, pourquoi il gère très bien beaucoup de requêtes à la fois, quelle version installer, puis te fait écrire tes premiers scripts.

Node.js, JavaScript et Express : qui fait quoi

Trois mots reviennent sans cesse, et les confondre fait perdre des points à l'oral.

Node.js n'est donc ni un langage ni un framework. Tu écris du JavaScript ; Node.js l'exécute ; Express t'aide à structurer un serveur web. Un navigateur est aussi un environnement d'exécution JavaScript, mais il offre d'autres objets : document et window existent dans le navigateur et pas dans Node.js ; à l'inverse, Node.js donne accès au disque (node:fs), aux processus (process) et au réseau bas niveau (node:net), interdits à une page web.

Node.js a été créé en 2009 par Ryan Dahl. Il est libre (licence MIT) et piloté par l'OpenJS Foundation. Il est installé avec npm, le gestionnaire de paquets qui donne accès à des millions de bibliothèques (chapitre 2).

À quoi sert Node.js

• Des API et des back-ends web : c'est l'usage de ce cours. Le front (React, une application mobile) envoie des requêtes HTTP ; l'API Node.js répond en JSON.
• Du temps réel : messagerie, notifications, tableaux de bord mis à jour en direct (WebSocket).
• Des outils de développement : Vite, ESLint, Prettier, TypeScript et le serveur de développement de React tournent tous sous Node.js. Même si tu ne codes pas de back-end en JavaScript, tu utilises Node.js dès que tu fais du front moderne.
• Des scripts : traiter un fichier CSV, appeler une API la nuit, générer un rapport.

Node.js est moins adapté aux calculs lourds qui monopolisent le processeur (traitement d'image, calcul scientifique) : la section sur la boucle d'événements explique pourquoi.

Aucune des deux approches n'est « meilleure » : PHP est simple à héberger et omniprésent, Node.js brille quand l'application passe son temps à attendre la base de données ou d'autres services, ce qui est le cas de la plupart des API.

Le moteur V8 et la boucle d'événements

Node.js exécute ton JavaScript avec V8, le moteur de Google Chrome, qui compile le code en langage machine à la volée. Ton code tourne sur un seul fil d'exécution (thread) : une seule instruction JavaScript s'exécute à un instant donné.

Comment un seul fil peut-il servir des centaines de requêtes ? Parce qu'une API passe l'essentiel de son temps à attendre : la réponse de MySQL, la lecture d'un fichier, la réponse d'un autre service. Node.js ne reste pas les bras croisés pendant ces attentes. Il confie l'opération au système d'exploitation (ou à un petit groupe de fils internes, géré par la bibliothèque libuv), passe à la requête suivante, et reprend le traitement quand le résultat arrive. C'est le modèle asynchrone non bloquant, orchestré par la boucle d'événements (event loop).

Voici ce que ça change concrètement. Ce script affiche quatre lignes ; devine l'ordre avant de lire le résultat.

console.log('1. début du script');
setTimeout(() => console.log('4. minuteur à 0 ms'), 0);
Promise.resolve().then(() => console.log('3. promesse résolue'));
console.log('2. fin du script');

1. début du script
2. fin du script
3. promesse résolue
4. minuteur à 0 ms

Le code synchrone s'exécute d'abord, jusqu'au bout. Ensuite seulement, la boucle traite ce qui attend : d'abord les suites de promesses (les microtâches), puis les minuteurs. Un setTimeout(…, 0) ne veut pas dire « tout de suite », mais « dès que possible, quand la pile est vide ».

Ne bloque jamais la boucle

Puisqu'il n'y a qu'un fil pour ton code, une instruction qui l'occupe longtemps bloque toutes les requêtes en même temps. Avec PHP, un script lent ne pénalise que son propre visiteur ; avec Node.js, il fige tout le serveur.

// À NE PAS FAIRE dans une route : 3 secondes de calcul pendant lesquelles
// aucune autre requête n'est servie, même /sante
const fin = Date.now() + 3000;
while (Date.now() < fin) { /* le processeur tourne à vide */ }

Les causes classiques, et leur remède :

Les fonctions …Sync ne sont pas interdites partout : dans un script lancé à la main, ou au démarrage du serveur avant qu'il n'accepte des requêtes, elles sont acceptables. Dans le traitement d'une requête, jamais.

Quelle version de Node.js choisir ?

Une nouvelle version majeure de Node.js sort tous les six mois. Les versions paires deviennent LTS (Long Term Support) en octobre : elles reçoivent ensuite des correctifs pendant deux ans et demi environ. Les versions impaires restent « Current » quelques mois puis s'arrêtent. Pour un projet, prends toujours une LTS.

Le calendrier officiel du projet change à partir de Node.js 27, prévu en avril 2027 : une seule version majeure par an, qui deviendra LTS à l'automne suivant. Vérifie toujours la page des versions sur nodejs.org avant de démarrer un projet.

Installer Node.js

Trois façons de l'installer :

• L'installeur officiel (nodejs.org, bouton LTS) : le plus simple sous Windows et macOS. Il installe node et npm.
• Un gestionnaire de versions : nvm (Linux, macOS), nvm-windows ou fnm (tous systèmes). Il permet d'avoir plusieurs versions et d'en changer par projet. C'est le choix des développeurs qui jonglent entre plusieurs projets.
• Un conteneur Docker (node:24-slim) : la même version pour toute l'équipe, sans rien installer sur le poste (chapitre 14).

# Avec nvm : installer la LTS 24 et l'utiliser
nvm install 24
nvm use 24

# Vérifier
node --version     # v24.15.0 (le dernier chiffre change avec les correctifs)
npm --version      # 11.12.1

Sous Linux, évite le paquet nodejs des dépôts de ta distribution s'il est ancien : prends nvm ou le dépôt officiel de NodeSource.

Premier script et REPL

Crée un fichier bonjour.js :

const prenom = process.argv[2] ?? 'inconnu';
console.log(`Bonjour ${prenom}, Node.js ${process.version} tourne sur ${process.platform}.`);

node bonjour.js Lucas

Bonjour Lucas, Node.js v24.15.0 tourne sur darwin.

process est un objet global de Node.js : process.argv contient les arguments de la ligne de commande (argv[0] est le chemin de node, argv[1] celui du script, puis tes arguments), process.env les variables d'environnement, process.exitCode le code de retour du programme. process.platform vaut win32 sous Windows, linux sous Linux, darwin sous macOS.

Lancé sans fichier, node ouvre le REPL (Read-Eval-Print Loop), une console où tu tapes du JavaScript et lis le résultat immédiatement. Pratique pour tester une méthode de tableau ou une expression régulière. .exit (ou deux fois Ctrl+C) pour en sortir.

Lire un fichier avec node:fs/promises

Les modules intégrés à Node.js s'importent avec le préfixe node:. Ce script lit le fichier tarifs.json placé à côté de lui et affiche les forfaits de frais d'AppliFrais :

[
  { "code": "ETP", "libelle": "Forfait étape", "montant": 110 },
  { "code": "KM", "libelle": "Frais kilométriques", "montant": 0.62 },
  { "code": "NUI", "libelle": "Nuitée hôtel", "montant": 80 },
  { "code": "REP", "libelle": "Repas restaurant", "montant": 25 }
]

// tarifs.js
import { readFile } from 'node:fs/promises';
import { join } from 'node:path';

const chemin = join(import.meta.dirname, 'tarifs.json');

try {
  const texte = await readFile(chemin, 'utf8');
  const tarifs = JSON.parse(texte);
  for (const { code, libelle, montant } of tarifs) {
    console.log(`${code.padEnd(4)}${libelle.padEnd(22)}${montant.toFixed(2).padStart(7)} €`);
  }
} catch (erreur) {
  if (erreur.code === 'ENOENT') {
    console.error(`Fichier introuvable : ${chemin}`);
    process.exitCode = 1;
  } else {
    throw erreur;
  }
}

ETP Forfait étape          110.00 €
KM  Frais kilométriques      0.62 €
NUI Nuitée hôtel            80.00 €
REP Repas restaurant        25.00 €

Quatre détails à retenir :

• ce fichier utilise import : le projet doit être en modules ES, avec "type": "module" dans le package.json (chapitre 2). Avec "type": "commonjs", la valeur que npm init écrit par défaut, Node.js s'arrête sur SyntaxError: Cannot use import statement outside a module ; sans champ type, il relit le fichier comme module ES et affiche un avertissement ;
• await est permis directement au niveau du module (top-level await), sans fonction async autour ;
• import.meta.dirname est le dossier du fichier en cours. Sans lui, un chemin relatif comme 'tarifs.json' est résolu depuis le dossier où tu as lancé la commande, pas depuis celui du script : une source d'erreurs fréquente ;
• une erreur système porte un code lisible : ENOENT (fichier absent), EACCES (droits insuffisants), EADDRINUSE (port déjà utilisé), ECONNREFUSED (service injoignable, souvent MySQL arrêté). Teste erreur.code plutôt que le texte du message.

Les modules intégrés à connaître

Certaines fonctions sont globales et n'ont pas besoin d'import : console, process, setTimeout, structuredClone, et surtout fetch, le même que dans le navigateur, pour appeler une autre API depuis ton serveur.

Exercices

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
queueMicrotask(() => console.log('D'));
console.log('E');

import { readFile } from 'node:fs/promises';
import { join } from 'node:path';

const tarifs = JSON.parse(await readFile(join(import.meta.dirname, 'tarifs.json'), 'utf8'));
const quantites = { ETP: 3, KM: 420, NUI: 2, REP: 5 };

let centimes = 0;
for (const { code, montant } of tarifs) {
  centimes += quantites[code] * Math.round(montant * 100);
}
console.log(`${(centimes / 100).toFixed(2)} €`);