La gestion de fichiers et Streams en Node.js avec fs

Le module fs (File System) de Node.js est un outil fondamental pour interagir avec le système de fichiers, offrant un éventail de fonctionnalités puissantes et flexibles.

Il permet d'accomplir une variété de tâches, des actions simples comme la lecture et l'écriture de fichiers, à des opérations plus complexes telles que la gestion de répertoires et l'obtention de statistiques sur le système de fichiers.

Comment l'utiliser ? 🛠️

Voici les méthodes les plus fréquemment utilisées.

📖 Lire un fichier : fs.readFile(path[, options], callback)

const fs = require('fs');

fs.readFile('text.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(`Error reading file: ${err.message}`);
        return;
    }
    console.log('File content:', data);
});

📝 Écrire dans un fichier : fs.writeFile(file, data[, options], callback)

const fs = require('fs');

const contentToWrite = 'Bonjour tout le monde !';

fs.writeFile('output.txt', contentToWrite, 'utf8', (err) => {
    if (err) {
        console.error(`Error writing to file: ${err.message}`);
        return;
    }
    console.log('File has been written successfully.');
});

✨ Renommer un fichier : fs.rename(oldPath, newPath, callback)

const fs = require('fs');

const oldFilePath = 'oldfile.txt';
const newFilePath = 'newfile.txt';

fs.rename(oldFilePath, newFilePath, (err) => {
    if (err) {
        console.error(`Error renaming file: ${err.message}`);
        return;
    }
    console.log('File has been renamed successfully.');
});

📂 Copier un fichier : fs.copyFile(srcPath, destPath, callback)

const fs = require('fs');

const sourceFilePath = 'sourcefile.txt';
const destinationFilePath = 'destinationfile.txt';

fs.copyFile(sourceFilePath, destinationFilePath, (err) => {
    if (err) {
        console.error(`Error copying file: ${err.message}`);
        return;
    }
    console.log('File has been copied successfully.');
});

🗑️ Supprimer un fichier : fs.unlink(path, callback)

const fs = require('fs');

const filePathToRemove = 'filetoremove.txt';

fs.unlink(filePathToRemove, (err) => {
    if (err) {
        console.error(`Error removing file: ${err.message}`);
        return;
    }
    console.log('File has been removed successfully.');
});

📂 Lire le contenu d'un répertoire : fs.readdir(path[, options], callback)

const fs = require('fs');

const directoryPath = './';

fs.readdir(directoryPath, 'utf8', (err, files) => {
    if (err) {
        console.error(`Error reading directory: ${err.message}`);
        return;
    }
    console.log('Files in the directory:', files);
});

📂 Créer un répertoire : fs.mkdir(path[, options], callback)

const fs = require('fs');

const newDirectoryPath = './new_directory';

fs.mkdir(newDirectoryPath, (err) => {
    if (err) {
        console.error(`Error creating directory: ${err.message}`);
        return;
    }
    console.log('Directory created successfully.');
});

📊 Obtenir les informations sur un fichier : fs.stat(path, callback)

const fs = require('fs');

const filePath = 'example.txt';

fs.stat(filePath, (err, stats) => {
    if (err) {
        console.error(`Error getting file stats: ${err.message}`);
        return;
    }
    console.log('File stats:', stats);
});

🔍 Vérifier l'accessibilité d'un fichier : fs.access(path[, mode], callback)

const fs = require('fs');

fs.readFile('text.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(`Error reading file: ${err.message}`);
        return;
    }
    console.log('File content:', data);
});

🌊 Les Streams Node.js

Les flux Node.js fournissent un mécanisme asynchrone et piloté par les événements pour traiter efficacement les données, ce qui est particulièrement utile lorsqu'il s'agit de fichiers volumineux . L'intégration avec le module fs améliore les capacités de lecture et d'écriture des fichiers.

📖 Lire des fichiers avec un flux : fs.createReadStream(path[, options])

const readStream = fs.createReadStream('largeFile.txt', 'utf8');

readStream.on('data', (chunk) => {
    console.log(`Received ${chunk.length} bytes of data.`);
});

readStream.on('end', () => {
    console.log('Reading file using stream completed.');
});

📝 Créer des fichiers avec un flux : fs.createWriteStream(path[, options])

const writeStream = fs.createWriteStream('output.txt', 'utf8');

writeStream.write('Writing data using streams.');

writeStream.end();

writeStream.on('finish', () => {
    console.log('Writing to file using stream completed.');
});

Avantages des flux de données :

Efficacité de la mémoire

Les flux fonctionnent par morceaux, ce qui optimise l'utilisation de la mémoire pour les fichiers volumineux.

Performances

Le traitement parallèle avec les flux améliore les performances globales des opérations de fichiers.

Canalisation

Les flux peuvent être facilement regroupés pour rationaliser le traitement des données.

L'intégration du module fs et des flux dans les applications Node.js dote les développeurs d'une puissante boîte à outils pour une manipulation des fichiers et un traitement des données efficaces, évolutifs et réactifs. Qu'il s'agisse de fichiers de petite ou de grande taille, ces modules contribuent à des solutions performantes et économes en ressources.