Leçon 1 / 8
Leçon 01 · Node.js

C'est quoi Node.js ?

JavaScript… sans le navigateur ?

Pendant longtemps, JavaScript n'existait que dans le navigateur. C'était le langage du web côté client — animations, formulaires, interactions. En 2009, Ryan Dahl change la donne en créant Node.js : un environnement qui permet d'exécuter JavaScript en dehors du navigateur, directement sur ton système d'exploitation.

Concrètement, Node.js est un runtime JavaScript. Il prend le moteur V8 de Chrome — celui qui compile et exécute JavaScript ultra-rapidement — et l'emballe avec des bibliothèques pour accéder au système de fichiers, au réseau, aux processus, etc.

💡

V8 est le moteur JavaScript développé par Google pour Chrome. Il compile JavaScript en code machine natif à la volée (JIT), ce qui le rend extrêmement rapide. Node.js réutilise exactement ce moteur — le même qui fait tourner les onglets Chrome sur ton poste.

L'event loop : le cœur de Node.js

Node.js repose sur une architecture radicalement différente des serveurs traditionnels comme Apache ou PHP. Son modèle est non-bloquant, asynchrone et single-thread.

Un serveur PHP classique crée un nouveau thread (ou processus) pour chaque requête entrante. Si 1000 utilisateurs arrivent en même temps, tu gères 1000 threads simultanés — très coûteux en mémoire.

Node.js fonctionne différemment : un seul thread, une seule boucle d'événements (event loop). Quand Node.js fait une opération longue (lire un fichier, interroger une base de données), il ne bloque pas — il délègue l'opération, continue à traiter d'autres requêtes, et revient traiter le résultat quand il est prêt.

Modèle event loop — Node.js vs serveur bloquant
# Serveur bloquant (PHP, Java classique)
Requête 1  →  thread 1  →  attend la BDD (200ms)  →  répond
Requête 2  →  thread 2  →  attend la BDD (200ms)  →  répond
Requête 3  →  thread 3  →  attend la BDD (200ms)  →  répond
# 1000 requêtes = 1000 threads bloqués

# Node.js — event loop non-bloquant
Requête 1  →  lance la BDD (non-bloquant)  →  continue
Requête 2  →  lance la BDD (non-bloquant)  →  continue
Requête 3  →  lance la BDD (non-bloquant)  →  continue
# Les résultats reviennent → callbacks / promises exécutés
# 1 seul thread gère des milliers de connexions simultanées
⚠️

Le modèle single-thread a une limite importante : si tu effectues un calcul CPU-intensif (chiffrement lourd, traitement d'image…), cela bloque l'event loop et tout le serveur se fige pendant ce temps. Node.js est excellent pour les I/O (réseau, fichiers, BDD) mais moins adapté aux tâches de calcul pur — pour cela, on utilisera des worker threads ou d'autres outils.

À quoi sert Node.js concrètement ?

Node.js s'est imposé dans de nombreux domaines :

  • API REST : le cas d'usage le plus courant. Node.js + Express permet de créer une API JSON en quelques dizaines de lignes. Netflix, LinkedIn, Uber utilisent Node.js en production.
  • Outils CLI : npm, Yarn, Webpack, ESLint, Vite… presque tous les outils du développement front-end sont des programmes Node.js.
  • Applications temps réel : chats, notifications push, tableaux de bord live — la nature event-driven de Node.js est taillée pour ça.
  • Microservices : la légèreté de Node.js en fait un excellent candidat pour des services indépendants et déployables séparément.
  • SSR / BFF : Next.js, Nuxt, Remix… tous tournent sur Node.js pour faire du rendu serveur.

L'avantage stratégique de Node.js pour une équipe web : un seul langage, front et back. Un développeur JavaScript peut passer du navigateur au serveur sans changer d'outils, de syntaxe, ni de paradigme de pensée.

Node.js, Deno et Bun : les trois runtimes JS

Node.js n'est plus seul. Deux alternatives notables sont apparues ces dernières années :

Runtime Créé par Moteur Point fort Maturité
Node.js Ryan Dahl (2009) V8 Écosystème npm immense, standard de facto Très mature, production
Deno Ryan Dahl (2020) V8 Sécurité par défaut, TypeScript natif, ESM Stable, adoption croissante
Bun Jarred Sumner (2023) JavaScriptCore Vitesse extrême, bundler + test runner intégrés Récent, très prometteur

Deno a été créé par le même auteur que Node.js pour corriger les regrets de conception : gestion des modules (ESM natif au lieu de CommonJS), sécurité (permissions explicites), TypeScript sans compilation. Bun, lui, mise tout sur la performance : démarrage quasi instantané, installation des dépendances 10× plus rapide.

Pour débuter et travailler en équipe, Node.js reste le choix standard. L'écosystème npm (plus de 2 millions de packages) et la maturité de la plateforme l'emportent largement.

Installer Node.js avec nvm

Il existe plusieurs façons d'installer Node.js. La méthode recommandée pour les développeurs est nvm (Node Version Manager), qui permet de gérer plusieurs versions de Node.js sur la même machine et de switcher en une commande.

Pourquoi plusieurs versions ? Parce que selon les projets, tu auras besoin de Node 18 sur l'un et Node 22 sur l'autre. nvm t'évite les conflits.

Installer nvm (Linux / macOS)
# Télécharger et installer nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# Recharger le terminal, puis installer Node.js LTS
nvm install --lts

# Vérifier l'installation
node --version   # ex : v22.3.0
npm  --version   # ex : 10.8.1
nvm — commandes courantes
nvm install 20        # installe Node.js 20
nvm install --lts     # installe la dernière LTS
nvm use 20            # utilise Node.js 20 dans ce terminal
nvm alias default 22  # définit Node.js 22 par défaut
nvm ls                # liste les versions installées
💡

LTS vs Current : les versions LTS (Long Term Support) reçoivent des correctifs de sécurité pendant 3 ans. Les versions Current intègrent les dernières fonctionnalités mais sont moins stables. Pour tout projet sérieux ou en production, utilise toujours une version LTS. Sur le site officiel nodejs.org, la LTS est marquée "Recommended for most users".

Ton premier script Node.js

Une fois Node.js installé, tu peux créer un fichier JavaScript et l'exécuter directement dans ton terminal — sans navigateur, sans HTML.

app.js
// Premier script Node.js
console.log("Hello Node");

// Node.js a accès au système — impossible dans un navigateur
const os = require("os");
console.log("Système :", os.platform());
console.log("CPU :", os.cpus().length, "cœurs");
Terminal — exécuter le script
node app.js

# Sortie :
Hello Node
Système : linux
CPU : 8 cœurs

C'est tout. Pas de serveur web, pas de configuration particulière. node app.js execute le fichier et affiche le résultat dans le terminal.

Le REPL Node.js

Node.js embarque un REPL (Read-Eval-Print Loop) — un environnement interactif pour tester du code directement dans le terminal, sans créer de fichier. C'est l'équivalent de la console développeur de Chrome, mais en ligne de commande.

Lancer et utiliser le REPL Node.js
# Lancer le REPL
node

# Invite > apparaît — tu peux taper du JavaScript directement
> 2 + 2
4
> "Hello".toUpperCase()
'HELLO'
> const arr = [1, 2, 3]
undefined
> arr.map(x => x * 2)
[ 2, 4, 6 ]

# Quitter le REPL
> .exit    (ou Ctrl+C deux fois)

Le REPL est idéal pour tester rapidement une expression, explorer une API ou vérifier le comportement d'une fonction sans créer de fichier. Utilise-le comme calculatrice JavaScript avancée.

// À retenir
  • Node.js est un runtime JavaScript basé sur le moteur V8 de Chrome — il exécute JS hors du navigateur.
  • Son architecture event loop non-bloquante lui permet de gérer des milliers de connexions simultanées avec un seul thread.
  • Cas d'usage principaux : API REST, outils CLI, applications temps réel, microservices.
  • Installer Node.js via nvm pour gérer plusieurs versions. Toujours choisir une version LTS pour la production.
  • node app.js exécute un script. node seul lance le REPL interactif.
  • Deno et Bun sont des alternatives modernes, mais Node.js reste le standard de l'industrie grâce à son écosystème npm.