Utilisation de buffers avec les streams et le système de fichiers

Buffers : Le langage commun des I/O en Node.js

Nous avons établi que les Buffers sont la manière dont Node.js représente et manipule les données binaires brutes. Or, les opérations d'Entrées/Sorties (I/O), qui sont au coeur des fonctionnalités des Streams et du module `fs` (File System), traitent fondamentalement de telles données. Que ce soit lire les octets d'un fichier sur le disque, recevoir des paquets de données sur un socket réseau, ou écrire des informations dans un fichier log, ces opérations impliquent des séquences d'octets.

Par conséquent, les Buffers jouent un rôle central et sont omniprésents (même si parfois implicitement) lors de l'utilisation des Streams et du module `fs`. Comprendre comment ils interagissent est essentiel pour maîtriser la manipulation des données dans les applications Node.js.

Buffers dans les streams Readable (lecture)

Par défaut, lorsqu'un stream Readable (comme ceux créés par `fs.createReadStream`, ou l'objet `request` d'un serveur HTTP, ou `process.stdin`) a des données à fournir, il les émet sous forme de Buffers via l'événement `data` (ou les rend disponibles via `read()` en mode paused).

Chaque `chunk` reçu est un objet Buffer contenant un morceau des données brutes lues depuis la source. Si vous travaillez avec des données textuelles, vous devrez explicitement convertir ces Buffers en chaînes de caractères en utilisant `chunk.toString([encoding])`.

Exemple avec `fs.createReadStream` :

const fs = require('fs');

const readable = fs.createReadStream('mon_fichier.txt'); // Pas d'encodage spécifié

readable.on('data', (chunk) => {
  // chunk est un Buffer
  console.log(`Chunk reçu (${chunk.length} octets):`, chunk);
  console.log('Chunk en texte (UTF-8):', chunk.toString('utf8'));
  // Si on s'attend à autre chose (ex: image), on traiterait le Buffer différemment
});

readable.on('end', () => {
  console.log('Fin du fichier.');
});

readable.on('error', (err) => console.error('Erreur:', err));

Alternative : `readable.setEncoding()`

Si vous savez que le stream Readable contient uniquement des données textuelles dans un encodage spécifique, vous pouvez appeler `readable.setEncoding('utf8')` (ou autre encodage) sur le stream. Dans ce cas, les chunks émis par l'événement `data` seront directement des chaînes de caractères décodées, vous évitant d'appeler `toString()` manuellement sur chaque chunk. Cependant, cela ne fonctionne que pour les données textuelles ; pour les données binaires, vous devez travailler avec les Buffers.

const fs = require('fs');

const readableText = fs.createReadStream('mon_fichier.txt');
readableText.setEncoding('utf8'); // Spécifier l'encodage

readableText.on('data', (chunk) => {
  // chunk est maintenant une String
  console.log(`Chunk texte reçu (${typeof chunk}):`, chunk);
});
// ... reste identique ...

Buffers dans les streams Writable (ecriture)

Inversement, lorsque vous écrivez des données dans un stream Writable (comme ceux créés par `fs.createWriteStream`, ou l'objet `response` d'un serveur HTTP, ou `process.stdout`), la méthode `writable.write()` accepte deux types principaux de données :

• Une chaîne de caractères : Si vous passez une chaîne, Node.js la convertira implicitement en un Buffer en utilisant l'encodage spécifié dans les options du stream ou l'encodage par défaut (`'utf8'`).
• Un Buffer : Vous pouvez passer directement un objet Buffer. Dans ce cas, les octets du Buffer sont écrits tels quels, sans aucune conversion d'encodage.

Passer directement un Buffer est souvent préférable si :

• Vos données sont déjà sous forme binaire (résultat d'une autre opération, lecture d'un fichier binaire).
• Vous avez besoin d'un contrôle précis sur les octets écrits (par exemple, pour respecter un format de fichier binaire spécifique).
• Vous voulez éviter le surcoût potentiel de l'encodage de chaîne en Buffer.

Exemple avec `fs.createWriteStream` :

const fs = require('fs');
const writable = fs.createWriteStream('output.log');

// Ecriture d'une chaîne (encodée implicitement en UTF-8)
writable.write('Première ligne de log.\n');

// Création et écriture d'un Buffer
const binaryData = Buffer.from([0xCA, 0xFE, 0xBA, 0xBE]); // Octets arbitraires
writable.write(binaryData);

writable.write('\nFin du log.\n');

// Il est important de terminer le stream pour s'assurer que tout est écrit
writable.end(() => {
  console.log('Ecriture terminée dans output.log');
});

writable.on('error', (err) => console.error('Erreur écriture:', err));

Buffers et les methodes `fs.readFile` / `fs.writeFile`

Les méthodes de lecture/écriture de fichiers complètes interagissent aussi directement avec les Buffers :

• `fs.readFile(path, [options], callback)` (et ses variantes `promises`/`sync`) : Si vous n'incluez pas d'option `encoding` (ou si elle est `null`), la fonction retourne le contenu complet du fichier sous forme d'un Buffer dans l'argument `data` du callback (ou comme valeur de retour de la promesse/fonction synchrone). C'est idéal pour lire des fichiers binaires ou lorsque vous voulez contrôler le décodage vous-même.
• `fs.writeFile(file, data, [options], callback)` (et ses variantes) : L'argument `data` peut être une chaîne (qui sera encodée) ou directement un Buffer. Fournir un Buffer est la manière directe d'écrire des octets spécifiques dans un fichier.

Exemple `readFile` sans encodage et `writeFile` avec un Buffer :

const fs = require('fs').promises; // Utilisation des promesses

async function processBinaryFile(inputPath, outputPath) {
  try {
    // Lire le fichier binaire en tant que Buffer
    const inputBuffer = await fs.readFile(inputPath);
    console.log(`Lu ${inputBuffer.length} octets depuis ${inputPath}`);

    // Manipuler le Buffer (exemple simple : inverser les octets)
    // ATTENTION: slice() partage la mémoire, on crée une copie pour l'inversion
    const outputBuffer = Buffer.from(inputBuffer).reverse();

    // Ecrire le Buffer manipulé dans un nouveau fichier
    await fs.writeFile(outputPath, outputBuffer);
    console.log(`Buffer inversé écrit dans ${outputPath}`);

  } catch (err) {
    console.error('Erreur lors du traitement du fichier binaire:', err);
  }
}

// Supposons qu'il existe un fichier 'image.png'
// processBinaryFile('image.png', 'image_reversed.png'); // Attention : le png sera corrompu !
// Autre exemple : créer un fichier avec des octets précis
async function createMagicFile(filePath) {
    const magicBytes = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]); // Signature PNG
    try {
        await fs.writeFile(filePath, magicBytes);
        console.log(`Fichier ${filePath} créé avec les octets magiques.`);
    } catch (err) {
        console.error('Erreur création fichier:', err);
    }
}
createMagicFile('magic.bin');

Conclusion : L'interface binaire essentielle

Les Buffers sont le rouage essentiel qui permet à Node.js de gérer les opérations d'I/O de manière efficace et de bas niveau. Que vous utilisiez des streams pour traiter des données au fil de l'eau ou les fonctions `readFile`/`writeFile` pour des opérations complètes, les Buffers sont souvent le format de données sous-jacent.

Comprendre que les streams émettent et acceptent des Buffers par défaut, et que `fs.readFile` retourne des Buffers sans encodage, vous permet de manipuler correctement les données, qu'elles soient textuelles (en appliquant le bon décodage/encodage via `toString()` ou `setEncoding()`) ou purement binaires (en travaillant directement avec l'objet Buffer).