Système de fichiers : module `fs` de Node.js

Le module fs (File System) de Node.js est un outil puissant pour travailler avec le système de fichiers, vous permettant d'interagir avec les fichiers et les répertoires de votre serveur. Il est intégré à Node.js, vous n'avez donc pas besoin d'installer quoi que ce soit de plus pour l'utiliser. Explorons le fonctionnement de fs et ses fonctions clés.

1. Qu'est-ce que le module fs ?

Le module fs fournit une API pour interagir avec le système de fichiers d'une manière étroitement calquée sur les fonctions POSIX standard. Ce module est utilisé pour des tâches telles que la lecture et l'écriture de fichiers, la création de répertoires, etc.

2. Configuration de base

Pour utiliser le module fs, vous devez l'exiger au début de votre script Node.js :

const fs = require('fs');

3. Lecture de fichiers

Il existe deux manières principales de lire des fichiers : de manière asynchrone et synchrone.

Lecture asynchrone

Cette méthode est non bloquante, ce qui signifie qu'elle n'arrêtera pas l'exécution de votre programme pendant qu'il lit le fichier.

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

• 'exemple.txt' : le fichier que vous souhaitez lire.
• 'utf8' : Spécifie l'encodage à utiliser.
• Fonction de rappel : gère l'erreur et les données du fichier.

Lecture Synchrone

Cette méthode est bloquante, ce qui signifie qu'elle arrêtera l'exécution de votre programme jusqu'à ce que le fichier soit lu.

try {
    const data = fs.readFileSync('example.txt', 'utf8');
    console.log(data);
} catch (err) {
    console.error(err);
}

4. Écriture de fichiers

Semblable à la lecture de fichiers, l'écriture peut également être effectuée de manière asynchrone ou synchrone.

Écriture asynchrone

fs.writeFile('example.txt', 'Hello, World!', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File has been saved!');
});

Écriture synchrone

try {
    fs.writeFileSync('example.txt', 'Hello, World!');
    console.log('File has been saved!');
} catch (err) {
    console.error(err);
}

5. Ajout aux fichiers

Si vous souhaitez ajouter du contenu à un fichier existant sans l'écraser, utilisez la méthode appendFile.

Ajout asynchrone

fs.appendFile('example.txt', '\nAppended Content', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Content has been appended!');
});

Ajout synchrone

try {
    fs.appendFileSync('example.txt', '\nAppended Content');
    console.log('Content has been appended!');
} catch (err) {
    console.error(err);
}

6. Suppression de fichiers

Pour supprimer un fichier, utilisez la méthode de dissociation.

Suppression asynchrone

fs.unlink('example.txt', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File deleted!');
});

Suppression synchrone

try {
    fs.unlinkSync('example.txt');
    console.log('File deleted!');
} catch (err) {
    console.error(err);
}

7. Travailler avec des répertoires

Création d'un répertoire

fs.mkdir('newDir', { recursive: true }, (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Directory created!');
});

Lire un répertoire

fs.readdir('newDir', (err, files) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Files in directory:', files);
});

Supprimer un répertoire

fs.rmdir('newDir', { recursive: true }, (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Directory deleted!');
});

8. Regarder des fichiers

Vous pouvez surveiller les modifications dans un fichier en utilisant la méthode fs.watch :

fs.watch('example.txt', (eventType, filename) => {
    if (filename) {
        console.log(`${filename} file Changed!`);
    }
});

9. Travailler avec des flux

Node.js fournit des flux fs pour gérer les fichiers volumineux qui peuvent ne pas tenir dans la mémoire.

Lire avec Streams

const readStream = fs.createReadStream('example.txt', 'utf8');
readStream.on('data', (chunk) => {
    console.log(chunk);
});

Écrire avec des flux

const writeStream = fs.createWriteStream('example.txt');
writeStream.write('Hello, ');
writeStream.write('World!');
writeStream.end();

10. Copie de fichiers

Node.js fournit une méthode simple pour copier des fichiers :

fs.copyFile('source.txt', 'destination.txt', (err) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File copied successfully!');
});

11. FS promis

Le module fs dispose également de méthodes basées sur des promesses, ce qui facilite le travail avec des fonctionnalités JavaScript modernes telles que async/await.

const fsPromises = require('fs').promises;

async function readFile() {
    try {
        const data = await fsPromises.readFile('example.txt', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

readFile();

12. Cas d'utilisation pratiques

• Fichiers de configuration : lisez ou écrivez des fichiers de configuration (par exemple, des fichiers JSON) pour stocker les paramètres.
• Fichiers journaux : ajoutez-les aux fichiers journaux pour suivre les événements de l'application.
• Téléchargements de fichiers : stockez et récupérez les fichiers téléchargés.
• Traitement des données : lisez, traitez et écrivez efficacement de grands ensembles de données à l'aide de flux.

13. Gestion des erreurs et meilleures pratiques

• Toujours gérer les erreurs dans les fonctions de rappel ou utiliser des blocs try-catch avec du code synchrone.
• Utilisez des méthodes asynchrones pour de meilleures performances dans la plupart des cas.
• Envisagez d'utiliser fs.promises pour un code plus propre et plus moderne.
• Soyez prudent avec les méthodes synchrones car elles peuvent bloquer la boucle d'événements.
• Utilisez fs.constants pour les indicateurs du système de fichiers (par exemple, fs.constants.O_RDONLY pour un accès en lecture seule).

14. Considérations de sécurité

• Validez et désinfectez les chemins de fichiers pour empêcher les attaques par traversée de répertoires.
• Soyez prudent lorsque vous travaillez avec des noms de fichiers ou des chemins fournis par l'utilisateur.
• Utilisez les autorisations de fichiers appropriées lors de la création ou de la modification de fichiers et de répertoires.

15. Conclusion

Le module fs est polyvalent et essentiel pour toute application Node.js qui doit interagir avec le système de fichiers. En comprenant ses différentes méthodes, en gérant efficacement les flux et en employant les meilleures pratiques, vous serez bien équipé pour gérer les opérations sur les fichiers dans Node.js de manière efficace et sécurisée.

N'oubliez pas de consulter la documentation officielle de Node.js pour obtenir les informations les plus récentes et les fonctionnalités supplémentaires du module fs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!