Node fournit différentes options pour écrire dans les fichiers de votre système via le fs module. Ceux-ci inclus écrireFichier(), ajouterFichier(), et createWriteStream().

Comme de nombreux langages, Node.js vous permet de choisir entre écraser un fichier existant ou y ajouter. Vous devriez également en savoir plus sur les compromis entre l'écriture d'un fichier en une seule fois et sa diffusion en continu.

Utilisation de writeFile()

écrireFichier() est peut-être la méthode la plus simple que vous puissiez utiliser pour écrire un fichier dans Node.

fs.writeFile (nom de fichier, données, rappel)

Voici un exemple montrant comment créer un fichier texte brut à l'aide de writeFile(). Vous pouvez bien sûr créer autres types de fichiers tels que CSV ou JSON.

constante fs = exiger("fs")
fs.writeFile("test.txt", "Nouveau contenu", err => {
si (erre) {
console.log (erreur)
 }
});

writeFile() prend en charge async/wait do au lieu d'utiliser des rappels comme dans l'exemple ci-dessus, vous pouvez créer le fichier comme suit.

constante fs = exiger("fs").promises
asynchronefonctionécrireVersFichier() {
essayer {
attendre fs.writeFile("test.txt", "Nouvelle suite")
 } attraper (erre) {
console.log (erreur);
 }
}
écrireVersFichier()

Par défaut, writeFile() fonctionne en remplaçant le contenu du fichier spécifié par un nouveau contenu si le fichier existe. Il existe cependant des indicateurs que vous pouvez utiliser pour remplacer cette fonctionnalité, tels que :

  • r+ - ouvre le fichier en lecture et en écriture.
  • w+ - ouvre le fichier en lecture et écriture au début du fichier
  • un - ouvre le fichier pour écrire à la fin du fichier.
  • un+ - ouvre le fichier en lecture et en écriture à la fin du fichier.

Par exemple, vous pouvez utiliser le drapeau a+ comme ceci :

constante fs = exiger("fs")
fs.writeFile("test.txt", "Contenu plus récent", { drapeau: "a+" }, err => {
si (erre) {
console.log (erreur)
 }
});

Il existe de nombreux autres indicateurs de système de fichiers que vous pouvez découvrir dans le Documentation des nœuds pour le module fs.

La fs module fournit également writeFileSync, la version synchrone de writeFile().

constante fs = exiger("fs")
fs.writeFileSync("test.txt", "Contenu plus récent", { drapeau: "a+" }, err => {
si (erre) {
console.log (erreur)
 }
});

Utilisation de createWriteStream()

L'inconvénient d'utiliser écrireFichier() est que vous devez stocker tout le contenu du fichier à la fois, ce qui n'est pas évolutif pour les fichiers volumineux. createWriteStream() cependant, prend en charge l'écriture séquentielle. Cela signifie que vous pouvez écrire un bloc de données dans un fichier à la fois. Voici le système général pour créer un flux inscriptible.

fs.createWriteStream (chemin, options)

Le code ci-dessous écrit des données dans un fichier texte à l'aide de flux

constante fs = exiger("fs")
// crée un flux inscriptible
laisser fluxinscriptible = fs.createWriteStream("test.txt") 
// Écrire dans le fichier en utilisant le flux inscriptible
writeableStream.write("Nouveau contenu");

Voici un autre exemple montrant comment vous pouvez diriger des données vers le flux inscriptible. Ce programme écrit toutes les entrées du terminal dans le fichier test.txt tant que le terminal est ouvert.

constante fs = exiger("fs")
laisser writableStream = fs.createWriteStream("test.txt"); 
process.stdin.pipe (writableStream);

Si vous exécutez ce programme à partir de la ligne de commande, vous pouvez le quitter avec Ctrl + d ou Ctrl + C.

Vous pouvez également écrire à partir d'un autre fichier dans le flux inscriptible. Considérez l'exemple suivant :

constante fs = exiger("fs")
laisser readableStream = fs.createReadStream("test.txt");
laisser writableStream = fs.createWriteStream("test2.txt");
readableStream.on("données", fonction(tronçon) {
 writableStream.write (morceau);
});

La création d'un flux lisible du fichier que vous souhaitez copier vous permet de lire son contenu en morceaux. Ainsi, pour chaque morceau reçu, le programme écrira dans le fichier de destination.

Utiliser appendFile()

ajouterFichier() est une méthode simple pour ajouter du contenu à la fin du fichier. Voici un exemple.

constante fs = exiger("fs")
fs.appendFile("test.txt", "contenu ajouté", err => {
si (erre) {
console.erreur (erreur);
 }
});

Vous pouvez également utiliser async/wait.

constante fs = exiger("fs").promises
asynchronefonctionappendToFile() {
essayer {
attendre fs.appendFile("test.txt", "contenu ajouté")
 } attraper (erre) {
console.log (erreur);
 }
}
appendToFile()

Comme écrireFichier(), appendFile a également une version synchrone :

fs.appendFileSync("test.txt", "contenu ajouté");

Utiliser des flux pour écrire des fichiers volumineux

Cet article a présenté plusieurs approches pour écrire des fichiers dans Node. Bien que writeFile() soit très simple, il convient mieux aux fichiers de petite taille car il n'autorise pas les écritures séquentielles. Si vous avez affaire à des fichiers volumineux, il est préférable d'utiliser des flux inscriptibles.