Qu'est-ce que Node.js et à quoi sert-il ?

Question

Accepted Answer

**Node.js** est un runtime qui vous permet d'exécuter du JavaScript **en dehors du navigateur** — sur des serveurs, des CLIs et des outils. Il est basé sur le moteur **V8** de Chrome et ajoute un modèle d'E/S non-bloquant et piloté par événements, conçu pour les applications réseau scalables.

## L'idée centrale : E/S non-bloquante sur un seul thread

```js
const fs = require("fs");

// non-blocking: the read happens in the background; the callback fires when done
fs.readFile("big.txt", "utf8", (err, data) => {
  console.log("file read complete");
});
console.log("this prints FIRST — the read didn't block");
```

Node exécute votre JS sur un seul thread principal mais délègue les E/S (fichiers, réseau, BD) au système d'exploitation et continue l'exécution. Quand les E/S se terminent, un callback s'exécute. C'est pourquoi un seul processus Node peut gérer **des milliers de connexions concurrentes** sans un thread par requête.

## À quoi Node est bon

```text
✓ APIs & web servers (REST, GraphQL) — I/O-bound, many concurrent requests
✓ Real-time apps (chat, live updates) — WebSockets, event-driven model fits well
✓ Microservices — lightweight, fast startup
✓ CLIs & build tools (the entire npm/Vite/webpack ecosystem)
✓ Streaming (video, large files) via streams
```

## À quoi il NE convient PAS

```text
✗ CPU-heavy work (image processing, big computations) — blocks the single thread
  → offload to worker threads, a queue, or another service
```

Parce qu'il est single-threaded pour votre JS, les calculs CPU lourds bloquent tout — Node excelle pour les charges de travail **liées aux E/S**, pas celles liées au CPU.

## Pourquoi JavaScript partout est important

```text
Same language front-end and back-end → shared code/types, one skill set,
huge npm ecosystem (the largest package registry).
```

## Pourquoi c'est important

Node.js a apporté JavaScript au serveur et a popularisé le modèle non-bloquant piloté par événements qui le rend excellent pour les applications **gourmandes en E/S et à forte concurrence** (APIs, temps réel, microservices).

Comprendre *pourquoi* il est scalable (E/S asynchrone sur un seul thread) et *où il a du mal* (travail lié au CPU) est la base pour l'utiliser correctement — c'est l'épine dorsale de la plupart des back-ends JavaScript modernes et des outils.