Comment travaillez-vous avec le système de fichiers dans Node ?

Question

Accepted Answer

Le module intégré **`fs`** lit et écrit des fichiers et des répertoires. Il offre trois styles d'API — **promises** (moderne, recommandé), **callbacks** (async original) et **sync** (bloquant) — afin que vous puissiez choisir le bon pour la situation.

## L'API promise (recommandé)

```js
import { readFile, writeFile, mkdir, readdir } from "fs/promises";

async function work() {
  const data = await readFile("input.txt", "utf8");     // read (utf8 → string)
  await writeFile("output.txt", "Hello");                // write (overwrites)
  await mkdir("new-dir", { recursive: true });           // create dirs (recursive = mkdir -p)
  const files = await readdir("./");                      // list directory contents
}
```

L'API `fs/promises` fonctionne proprement avec async/await — la valeur par défaut moderne pour les I/O de fichiers.

## Variantes callback et sync

```js
import fs from "fs";

fs.readFile("file.txt", "utf8", (err, data) => { ... }); // async callback
const data = fs.readFileSync("file.txt", "utf8");         // SYNC — blocks the event loop!
```

**Attention :** Les méthodes `*Sync` **bloquent la boucle d'événements entière** jusqu'à la fin de l'opération. Elles sont correctes au démarrage (chargement de la configuration une fois) mais doivent être évitées dans les gestionnaires de requêtes — une lecture bloquante gèle toutes les requêtes concurrentes.

## Opérations courantes

```js
await fs.promises.appendFile("log.txt", "new line
"); // append
await fs.promises.unlink("old.txt");                    // delete a file
await fs.promises.rename("a.txt", "b.txt");             // rename/move
const stats = await fs.promises.stat("file.txt");       // metadata (size, mtime)
const exists = fs.existsSync("file.txt");               // check existence
```

## Pour les grands fichiers : utilisez des streams

```js
// ❌ readFile loads the WHOLE file into memory — bad for huge files
const huge = await readFile("10gb.txt"); // could exhaust memory

// ✅ stream it in chunks (constant memory)
fs.createReadStream("10gb.txt").pipe(fs.createWriteStream("copy.txt"));
```

Pour les gros fichiers, `readFile` charge tout en mémoire à la fois ; les **streams** traitent les données par chunks avec une mémoire constante.

## Pourquoi c'est important

Les I/O de fichiers sont une capacité fondamentale de Node pour le chargement de configuration, la journalisation, les téléchargements/téléversements de fichiers et l'outillage.

Connaître les trois styles d'API — et surtout, que **les méthodes sync bloquent la boucle d'événements** (évitez-les sur les serveurs) et que **les grands fichiers ont besoin de streams** (pas `readFile`) — est essentiel pour écrire un code de gestion de fichiers qui est à la fois correct et performant en cas de concurrence.

L'API promise avec async/await est la valeur par défaut propre pour l'usage quotidien.