web-dev-qa-db-fra.com

Écrire des fichiers dans Node.js

J'ai essayé de trouver un moyen d'écrire dans un fichier lorsque j'utilisais Node.js, mais sans succès. Comment puis je faire ça?

javascriptnode.jsfileexpressfs
1311
Gjorgji

Il y a beaucoup de détails dans l'API système de fichiers . Le moyen le plus courant est:

const fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }

    console.log("The file was saved!");
});
2061
Brian McKenna

Il existe actuellement trois façons d'écrire un fichier:

  1. fs.write(fd, buffer, offset, length, position, callback)

    Vous devez attendre le rappel pour vous assurer que le tampon est écrit sur le disque. Ce n'est pas tamponné.

  2. fs.writeFile(filename, data, [encoding], callback)

    Toutes les données doivent être stockées en même temps; vous ne pouvez pas effectuer d'écriture séquentielle.

  3. fs.createWriteStream(path, [options])

    Crée un WriteStream , ce qui est pratique car vous n'avez pas besoin d'attendre un rappel. Mais encore une fois, ce n'est pas tamponné.

Un WriteStream , comme son nom l’indique, est un flux. Un flux par définition est "un tampon" contenant des données qui se déplacent dans une direction (source ► destination). Mais un flux en écriture n'est pas nécessairement "tamponné". Un flux est "mis en mémoire tampon" lorsque vous écrivez n fois et, au moment n+1, le flux envoie le tampon au noyau (car il est plein et doit être vidé).

En d'autres termes: "Un tampon" est l'objet. Qu'il soit ou non "tamponné" est une propriété de cet objet.

Si vous examinez le code, WriteStream hérite d'un objet Stream inscriptible. Si vous y prêtez attention, vous verrez comment ils vident le contenu. ils n'ont pas de système tampon.

Si vous écrivez une chaîne, elle est convertie en tampon, puis envoyée à la couche native et écrite sur le disque. Lors de l'écriture de chaînes, ils ne remplissent aucun tampon. Donc, si vous le faites:

write("a")
write("b")
write("c")

Tu fais:

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

C’est trois appels à la couche d’E/S. Bien que vous utilisiez des "tampons", les données ne sont pas tamponnées. Un flux en mémoire tampon ferait: fs.write(new Buffer ("abc")), un appel à la couche d'E/S.

Désormais, dans Node.js v0.12 (version stable annoncée le 02/06/2015), deux fonctions sont désormais disponibles: cork() et uncork() . Il semble que ces fonctions vous permettront enfin de mettre en tampon/vider les appels en écriture.

Par exemple, dans Java, certaines classes fournissent des flux mis en mémoire tampon (BufferedOutputStream, BufferedWriter...). Si vous écrivez trois octets, ces octets seront stockés dans la mémoire tampon (mémoire) au lieu de faire un appel d'E/S pour trois octets. Lorsque la mémoire tampon est pleine, le contenu est vidé et enregistré sur le disque. Cela améliore les performances.

Je ne découvre rien, je me rappelle simplement comment l'accès au disque devrait être fait.

508
Gabriel Llamas

Vous pouvez bien sûr le rendre un peu plus avancé. Ne bloque pas, écrit des bribes, n'écrit pas l'intégralité du fichier à la fois:

var fs = require('fs');
var stream = fs.createWriteStream("my_file.txt");
stream.once('open', function(fd) {
  stream.write("My first row\n");
  stream.write("My second row\n");
  stream.end();
});
216
Fredrik Andersson
var path = 'public/uploads/file.txt',
buffer = new Buffer("some content\n");

fs.open(path, 'w', function(err, fd) {
    if (err) {
        throw 'error opening file: ' + err;
    }

    fs.write(fd, buffer, 0, buffer.length, null, function(err) {
        if (err) throw 'error writing file: ' + err;
        fs.close(fd, function() {
            console.log('file written');
        })
    });
});
42
Mister P

J'ai aimé Index of ./articles/file-system.

Cela a fonctionné pour moi.

Voir aussi Comment puis-je écrire des fichiers dans node.js?.

fs = require('fs');
fs.writeFile('helloworld.txt', 'Hello World!', function (err) {
    if (err) 
        return console.log(err);
    console.log('Wrote Hello World in file helloworld.txt, just check it');
});

Contenu de helloworld.txt:

Hello World!

Mettre à jour:
Comme dans le noeud Linux, écrire dans le répertoire courant, il semble que certains autres ne le fassent pas, alors j’ajoute ce commentaire au cas où:
En utilisant cette ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); pour obtenir où le fichier est écrit.

26
Sérgio

Écriture synchrone

fs.writeFileSync (fichier, données [ options])

fs = require('fs');

fs.writeFileSync("synchronous.txt", "synchronous write!")

Écriture asynchrone

fs.writeFile (fichier, données [ options], rappel]

fs = require('fs');

fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
  if (err) throw err;
  console.log('The file has been saved!');
});

Où

file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

Il vaut la peine de lire le système de fichiers officiel (fs) docs .

21
Moriarty

Je connais la question posée à propos de "write" mais, dans un sens plus général, "append" pourrait être utile dans certains cas, car il est facile de l'utiliser en boucle pour ajouter du texte à un fichier (que le fichier existe ou non). Utilisez un "\ n" si vous voulez ajouter des lignes, par exemple:

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
9
Astra Bear
 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
});

Par exemple: lire le fichier et écrire dans un autre fichier:

  var fs = require('fs');
    var path = process.cwd();
    fs.readFile(path+"\\from.txt",function(err,data)
                {
                    if(err)
                        console.log(err)
                    else
                        {
                            fs.writeFile(path+"\\to.text",function(erro){
                                if(erro)
                                    console.log("error : "+erro);
                                else
                                    console.log("success");
                            });
                        }
                });
7
Masoud Siahkali

Ici, nous utilisons w + pour lire/écrire les deux actions et si le chemin du fichier n’est pas trouvé, il sera créé automatiquement.

fs.open(path, 'w+', function(err, data) {
    if (err) {
        console.log("ERROR !! " + err);
    } else {
        fs.write(data, 'content', 0, 'content length', null, function(err) {
            if (err)
                console.log("ERROR !! " + err);
            fs.close(data, function() {
                console.log('written success');
            })
        });
    }
});

Le contenu signifie ce que vous devez écrire dans le fichier et sa longueur, 'content.length'.

4
Gunjan Patel

Vous pouvez écrire dans un fichier en utilisant le module fs (système de fichiers).

Voici un exemple de la façon dont vous pouvez le faire:

const fs = require('fs');

const writeToFile = (fileName, callback) => {
  fs.open(fileName, 'wx', (error, fileDescriptor) => {
    if (!error && fileDescriptor) {
      // Do something with the file here ...
      fs.writeFile(fileDescriptor, newData, (error) => {
        if (!error) {
          fs.close(fileDescriptor, (error) => {
            if (!error) {
              callback(false);
            } else {
              callback('Error closing the file');
            }
          });
        } else {
          callback('Error writing to new file');
        }
      });
    } else {
      callback('Could not create new file, it may already exists');
    }
  });
};

Vous pouvez également vous débarrasser de cette structure de code callback-inside-callback en utilisant les instructions Promises et async/await Cela rendra la structure de code asynchrone beaucoup plus plate. Pour cela, une fonction util.promisify (original) peut être utilisée. Cela nous permet de passer des rappels aux promesses. Regardez l'exemple avec les fonctions fs ci-dessous:

// Dependencies.
const util = require('util');
const fs = require('fs');

// Promisify "error-back" functions.
const fsOpen = util.promisify(fs.open);
const fsWrite = util.promisify(fs.writeFile);
const fsClose = util.promisify(fs.close);

// Now we may create 'async' function with 'await's.
async function doSomethingWithFile(fileName) {
  const fileDescriptor = await fsOpen(fileName, 'wx');
  
  // Do something with the file here...
  
  await fsWrite(fileDescriptor, newData);
  await fsClose(fileDescriptor);
}

4
Oleksii Trekhleb

Voici un exemple de lecture de fichier csv à partir de local et d’écriture de fichier csv sur local.

var csvjson = require('csvjson'),
    fs = require('fs'),
    mongodb = require('mongodb'),
    MongoClient = mongodb.MongoClient,
    mongoDSN = 'mongodb://localhost:27017/test',
    collection;

function uploadcsvModule(){
    var data = fs.readFileSync( '/home/limitless/Downloads/orders_sample.csv', { encoding : 'utf8'});
    var importOptions = {
        delimiter : ',', // optional 
        quote     : '"' // optional 
    },ExportOptions = {
        delimiter   : ",",
        wrap        : false
    }
    var myobj = csvjson.toSchemaObject(data, importOptions)
    var exportArr = [], importArr = [];
    myobj.forEach(d=>{
        if(d.orderId==undefined || d.orderId=='') {
            exportArr.Push(d)
        } else {
            importArr.Push(d)
        }
    })
    var csv = csvjson.toCSV(exportArr, ExportOptions);
    MongoClient.connect(mongoDSN, function(error, db) {
        collection = db.collection("orders")
        collection.insertMany(importArr, function(err,result){
            fs.writeFile('/home/limitless/Downloads/orders_sample1.csv', csv, { encoding : 'utf8'});
            db.close();
        });            
    })
}

uploadcsvModule()
3
KARTHIKEYAN.A

Vous pouvez utiliser la bibliothèque easy-file-manager

installez d'abord à partir de npm npm install easy-file-manager

Échantillon pour télécharger et supprimer des fichiers

var filemanager = require('easy-file-manager')
var path = "/public"
var filename = "test.jpg"
var data; // buffered image

filemanager.upload(path,filename,data,function(err){
    if (err) console.log(err);
});

filemanager.remove(path,"aa,filename,function(isSuccess){
    if (err) console.log(err);
});
2
Christoper

Vous pouvez écrire dans un fichier à l'aide de l'exemple de code suivant:

  var data = [{'test': '123', 'test2': 'Lorem Ipsem '}];        
  fs.open(datapath + '/data/topplayers.json', 'wx', function(error, fileDescriptor){        
    if(!error && fileDescriptor){        
        var stringData = JSON.stringify(data);        
        fs.writeFile(fileDescriptor, stringData, function(error){        
            if(!error){        
                fs.close(fileDescriptor, function(error){        
                    if(!error){        
                        callback(false);        
                    }else{        
                        callback('Error in close file');        
                    }        
                });        
            }else{        
                callback('Error in writing file.');        
            }        
        });        
    }        
}
2
Mudassir

Les réponses fournies sont datées et une nouvelle façon de procéder est la suivante:

const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')

voir doco ici pour plus d'informations

1
TrevTheDev

OK, c'est assez simple car Node a une fonctionnalité intégrée pour cela, il s'appelle fs qui signifie Système de fichiers et, en gros, Module du système de fichiers NodeJS ...

Donc, commencez par en avoir besoin dans votre fichier server.js comme ceci:

var fs = require('fs');

fs a peu de méthodes pour écrire dans un fichier, mais ma méthode préférée consiste à utiliser appendFile, ceci ajoutera les éléments au fichier et si le fichier n'existe pas, en créera une, le code pourrait être comme ci-dessous:

fs.appendFile('myFile.txt', 'Hi ALi!', function (err) {
  if (err) throw err;
  console.log('Thanks, It's saved to the file!');
});
1
Alireza

fs.createWriteStream(path[,options])

options peut également inclure une option start afin de permettre l'écriture de données à une position ultérieure au début du fichier. Modifier un fichier plutôt que le remplacer peut nécessiter un mode flags de r+ plutôt que le mode par défaut w. Le codage peut être n'importe lequel de ceux acceptés par Buffer .

Si autoClose est défini sur true (comportement par défaut) sur 'error' ou 'finish', le descripteur de fichier sera automatiquement fermé. Si autoClose est false, le descripteur de fichier ne sera pas fermé, même en cas d'erreur. Il est de la responsabilité de l'application de le fermer et de s'assurer qu'il n'y a pas de fuite de descripteur de fichier.

Comme ReadStream , si fd est spécifié, WriteStream ignorera l’argument path et utilisera le descripteur de fichier spécifié. Cela signifie qu'aucun événement 'open' ne sera émis. fd devrait être bloquant; les fds non bloquants doivent être passés à net.Socket .

Si options est une chaîne, il spécifie le codage.

Après avoir lu ce long article. Vous devriez comprendre comment cela fonctionne ... Donc, voici un exemple de createWriteStream().

/* The fs.createWriteStream() returns an (WritableStream {aka} internal.Writeable) and we want the encoding as 'utf'-8 */
/* The WriteableStream has the method write() */
fs.createWriteStream('out.txt', 'utf-8')
.write('hello world');
0
user9258013

Essayez ce qui suit:

fs.readFile(`${__dirname}/fileName`, 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});
0
sultan aslam