Qu'est-ce que les Buffers dans Node.js ?

Question

Accepted Answer

Un **Buffer** est la façon qu'a Node de gérer **les données binaires brutes** — une séquence de bytes de longueur fixe stockée en dehors du tas V8. Puisque les chaînes JavaScript sont destinées au texte (Unicode), les Buffers existent pour travailler avec le binaire : contenu de fichiers, paquets réseau, images, chiffrement, etc.

## Pourquoi c'est important

```text
JavaScript strings → text (UTF-16). Can't cleanly represent arbitrary bytes.
Buffers → raw bytes (0–255 each). For binary data that isn't text.
```

Quand vous lisez un fichier ou recevez des données réseau, elles arrivent sous forme de bytes — un Buffer — que vous pouvez ensuite décoder en chaîne si c'est du texte, ou traiter comme du binaire si ce n'est pas le cas.

## Créer et utiliser des Buffers

```js
const buf = Buffer.from("Hello");          // from a string → bytes
const buf2 = Buffer.from([72, 105]);       // from byte values → "Hi"
const buf3 = Buffer.alloc(10);             // 10 zero-filled bytes

buf.length;          // 5 (bytes, not characters)
buf.toString("utf8"); // "Hello" — decode back to text
buf.toString("hex");  // "48656c6c6f"
buf.toString("base64"); // "SGVsbG8="
buf[0];              // 72 — access individual bytes
```

## Où les Buffers apparaissent

```js
// file reads without an encoding return a Buffer
const data = await fs.promises.readFile("image.png"); // Buffer (binary)
const text = await fs.promises.readFile("file.txt", "utf8"); // string (decoded)

// streams emit Buffer chunks
req.on("data", (chunk) => { /* chunk is a Buffer */ });

// crypto, compression, network protocols all work with Buffers
crypto.randomBytes(16); // a Buffer of 16 random bytes
```

Si vous lisez un fichier *sans* spécifier un encodage, vous obtenez un Buffer ; spécifiez `"utf8"` et Node le décode en chaîne pour vous.

## Un point subtil : bytes vs caractères

```js
Buffer.from("café").length; // 5 (é is 2 bytes in UTF-8) — NOT 4 characters
```

La longueur d'un Buffer est en **bytes**, ce qui peut différer du nombre de caractères pour le texte multi-byte (non-ASCII) — pertinent lors du découpage de données binaires.

## Pourquoi c'est important

Les Buffers sont la façon dont Node gère toutes les **données binaires**, ce qui est inévitable dans le travail serveur : lire des fichiers non-texte, traiter des flux, les protocoles réseau, la cryptographie, les uploads d'images/fichiers et la compression.

Comprendre que les I/O traitent fondamentalement les bytes (Buffers) — et comment convertir entre les Buffers et les chaînes avec le bon encodage — est essentiel dès que vous allez au-delà du texte brut, et cela sous-tend les flux, le système de fichiers et la cryptographie.