Gestion des fichiers dans JavaScript côté serveur

const fs = require('fs');

const filename="binary.bin";

fs.readFile(filename, (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log(data);

  // process the Buffer data using Buffer methods (e.g., slice, copy)
});

Diffusion de fichiers en JavaScript

Une autre facette de la gestion des fichiers est la diffusion en continu de blocs de données, ce qui devient une nécessité lors du traitement de fichiers volumineux. Voici un exemple artificiel d'écriture en blocs de diffusion en continu :

const fs = require('fs');

const filename="large_file.txt"; 
const chunkSize = 1024 * 1024; // (1)
const content="This is some content to be written in chunks."; // (2)
const fileSizeLimit = 5 * 1024 * 1024; // // (3)

let writtenBytes = 0; // (4)

const writeStream = fs.createWriteStream(filename, { highWaterMark: chunkSize }); // (5)

function writeChunk() { // (6)
  const chunk = content.repeat(Math.ceil(chunkSize / content.length)); // (7)

  if (writtenBytes + chunk.length  fileSizeLimit) {
      console.error('File size limit reached');
      writeStream.end(); 
      return;
    }
    console.log(`Wrote chunk of size: ${chunk.length}, Total written: ${writtenBytes}`);
  }
}

writeStream.on('error', (err) => { // (10)
  console.error('Error writing file:', err);
});

writeStream.on('finish', () => { // (10)
  console.log('Finished writing file');
});

writeChunk(); 

Le streaming vous donne plus de puissance, mais vous remarquerez qu'il implique plus de travail. Le travail que vous effectuez consiste à définir des tailles de blocs, puis à répondre aux événements en fonction des blocs. C'est l'essence même de l'évitement de mettre trop d'un fichier volumineux en mémoire à la fois. Au lieu de cela, vous le divisez en blocs et vous traitez chacun d'eux. Voici mes notes sur les parties intéressantes de l'exemple d'écriture ci-dessus :

1. Nous spécifions une taille de bloc en kilo-octets. Dans ce cas, nous avons un bloc de 1 Mo, ce qui correspond à la quantité de contenu qui sera écrite à la fois.
2. Voici du faux contenu à écrire.
3. Maintenant, nous créons une limite de taille de fichier, dans ce cas, 5 Mo.
4. Cette variable suit le nombre d'octets que nous avons écrits (nous pouvons donc arrêter d'écrire après 5 Mo).
5. Nous créons le réel writeStream objet. Le highWaterMark L'élément lui indique la taille des morceaux qu'il acceptera.
6. Le writeChunk() La fonction est récursive. Chaque fois qu'un fragment doit être traité, elle s'appelle elle-même. Elle le fait à moins que la limite du fichier ne soit atteinte, auquel cas elle se termine.
7. Ici, nous répétons simplement l'exemple de texte jusqu'à ce qu'il atteigne la taille de 1 Mo.
8. Voici la partie intéressante. Si la taille du fichier n'est pas dépassée, nous appelons writeStream.write(chunk):
   1. writeStream.write(chunk) retours false si la taille du tampon est dépassée. Cela signifie que nous ne pouvons pas mettre plus de données dans le tampon compte tenu de la limite de taille.
   2. Lorsque la mémoire tampon est dépassée, le drain l'événement se produit, géré par le premier gestionnaire, que nous définissons ici avec writeStream.once('drain', writeChunk);. Notez qu'il s'agit d'un rappel récursif à writeChunk.
9. Cela permet de garder une trace de ce que nous avons écrit.
10. Cela gère le cas où nous avons fini d'écrire et termine l'écriture du flux avec writeStream.end();.
11. Ceci montre l’ajout de gestionnaires d’événements pour error et finish.

Et pour le relire à partir du disque, nous pouvons utiliser une approche similaire :