Scrittura di file in Node.js

Ho cercato di trovare un modo per scrivere su un file quando si utilizza Node.js, ma senza successo. Come lo posso fare?

Ci sono molti dettagli nell’API del filesystem . Il modo più comune (per quanto ne so) è:

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

Attualmente ci sono tre modi per scrivere un file:

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

    È necessario attendere la richiamata per assicurarsi che il buffer venga scritto sul disco. Non è bufferizzato.

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

    Tutti i dati devono essere memorizzati allo stesso tempo; non è ansible eseguire scritture sequenziali.

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

    Crea un WriteStream , che è conveniente perché non è necessario attendere una richiamata. Ma di nuovo, non è bufferizzato.

Un WriteStream , come dice il nome, è un stream. Un stream per definizione è “un buffer” contenente dati che si muovono in una direzione (fonte ► destinazione). Ma un stream scrivibile non è necessariamente “bufferizzato”. Un stream viene “bufferizzato” quando scrivi n volte, e al tempo n+1 , il stream invia il buffer al kernel (perché è pieno e deve essere svuotato).

In altre parole: “Un buffer” è l’object. Che sia “buffered” o meno è una proprietà di quell’object.

Se si guarda il codice, WriteStream eredita da un object Stream scrivibile. Se presti attenzione, vedrai come scaricano il contenuto; non hanno alcun sistema di buffering.

Se scrivi una stringa, viene convertita in un buffer e quindi inviata al livello nativo e scritta sul disco. Quando si scrivono le stringhe, non riempiono alcun buffer. Quindi, se lo fai:

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

Stai facendo:

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

Sono tre chiamate al livello I / O. Sebbene tu stia usando “buffer”, i dati non vengono memorizzati nel buffer. Un stream bufferizzato dovrebbe fare: fs.write(new Buffer ("abc")) , una chiamata al livello I / O.

A partire da ora, in Node.js v0.12 (versione stabile annunciata il 02/06/2015) ora supporta due funzioni: cork() e uncork() . Sembra che queste funzioni ti consentiranno finalmente di bufferizzare / svuotare le chiamate di scrittura.

Ad esempio, in Java ci sono alcune classi che forniscono flussi bufferizzati ( BufferedOutputStream , BufferedWriter …). Se si scrivono tre byte, questi byte verranno memorizzati nel buffer (memoria) invece di eseguire una chiamata I / O solo per tre byte. Quando il buffer è pieno, il contenuto viene svuotato e salvato sul disco. Questo migliora le prestazioni.

Non sto scoprendo nulla, solo ricordando come dovrebbe essere fatto un accesso al disco.

Ovviamente puoi renderlo un po ‘più avanzato. Non bloccando, scrivendo bit e pezzi, non scrivendo l’intero file contemporaneamente:

 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(); }); 
 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'); }) }); }); 

Mi piaceva l’ indice di ./articles/file-system .

Ha funzionato per me.

Vedi anche Come scrivere file in 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'); }); 

Contenuto di helloworld.txt:

 Hello World! 

Aggiornare:
Come nel nodo Linux scrivere nella directory corrente, sembra che in altri no, quindi aggiungo questo commento nel caso in cui:
Utilizzando questo ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); per ottenere dove è scritto il file.

  var fs = require('fs'); fs.writeFile(path + "\\message.txt", "Hello", function(err){ if (err) throw err; console.log("success"); }); 

Ad esempio: leggi il file e scrivi in ​​un altro file:

  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"); }); } }); 

Scrittura sincrona

fs.writeFileSync (file, dati [, opzioni])

 fs = require('fs'); fs.writeFileSync("synchronous.txt", "synchronous write!") 

Scrittura asincrona

fs.writeFile (file, dati [, opzioni], callback)

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

Dove

 file  |  |  |  filename or file descriptor data  |  |  options  |  callback  

Vale la pena leggere i file di file system (fs) ufficiali.

Qui usiamo w + per leggere / scrivere entrambe le azioni e se il percorso del file non viene trovato, verrebbe creato automaticamente.

 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'); }) }); } }); 

Contenuto significa ciò che devi scrivere sul file e la sua lunghezza, ‘content.length’.

Ecco l’esempio di come leggere il file CSV dal locale e scrivere il file CSV sul locale.

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

Conosco la domanda “scrivere”, ma in un senso più generale “append” potrebbe essere utile in alcuni casi in quanto è facile da usare in un ciclo per aggiungere testo a un file (indipendentemente dal fatto che il file esista o meno). Usa un “\ n” se vuoi aggiungere delle righe, ad esempio:

 var fs = require('fs'); for (var i=0; i<10; i++){ fs.appendFileSync("junk.csv", "Line:"+i+"\n"); } 

Puoi usare la libreria easy-file-manager

installa prima da npm npm install easy-file-manager

Esempio per caricare e rimuovere file

 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); });