La gestion de fichiers et Streams en Node.js avec fs
Tags: node, beginners, french, javascript
Published: 2024-01-26 10:26:49

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)`

```javascript
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)`

```javascript
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)`

```javascript
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)`

```javascript
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)`

```javascript
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)`

```javascript
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)`

```javascript
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)`

```javascript
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)`

```javascript
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])`

```javascript
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])`

```javascript
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.