Scrivere file in Node.js

Ho provato a trovare un modo per scrivere su un file quando utilizzo Node.js, ma senza successo. Come lo posso fare?

Ci sono molti dettagli nell'API del file system . Il modo più comune è:

const fs = require('fs');

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

// Or
fs.writeFileSync('/tmp/test-sync', 'Hey there!');

Attualmente ci sono tre modi per scrivere un file:

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

   È necessario attendere il callback per assicurarsi che il buffer sia scritto sul disco. Non è bufferizzato.

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

   Tutti i dati devono essere archiviati contemporaneamente; non è possibile eseguire scritture sequenziali.

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

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

A WriteStream, come dice il nome, è un flusso. Un flusso per definizione è "un buffer" contenente dati che si muovono in una direzione (sorgente ► destinazione). Ma un flusso scrivibile non è necessariamente "bufferizzato". Uno stream viene “bufferizzato” quando si scrivono i ntempi, e alla volta n+1lo stream invia il buffer al kernel (perché è pieno e deve essere scaricato).

In altre parole: "un buffer" è l'oggetto. Se "è bufferizzato" è una proprietà di quell'oggetto.

Se guardi il codice, WriteStreameredita da un Streamoggetto scrivibile . Se presti attenzione, vedrai come svuotano il contenuto; non hanno alcun sistema di buffering.

Se scrivi una stringa, viene convertita in un buffer, quindi inviata al livello nativo e scritta su disco. Quando scrivono stringhe, non stanno riempiendo 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 utilizzando "buffer", i dati non sono bufferizzati. Un flusso buffer farebbe:, 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 archiviati nel buffer (memoria) invece di eseguire una chiamata I / O solo per tre byte. Quando il buffer è pieno, il contenuto viene scaricato e salvato su disco. Questo migliora le prestazioni.

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

Ovviamente puoi renderlo un po 'più avanzato. Non bloccando, scrivendo bit e pezzi, non scrivendo l'intero file in una volta:

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

Scrittura sincrona

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

fs = require('fs');

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

Scrittura asincrona

fs.writeFile (file, data [, 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 <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

La pena di leggere il file di sistema ufficiale (fs) docs .

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 è piaciuto l' indice di ./articles/file-system .

Ha funzionato per me.

Vedi anche Come scrivo i 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');
});

Contenuti di helloworld.txt:

Hello World!

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

Le risposte fornite sono datate e un modo più nuovo per farlo è:

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

vedere i documenti qui per maggiori informazioni

So che la domanda posta su "scrivere", ma in 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). Utilizzare un "\ n" se si desidera aggiungere righe, ad esempio:

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

OK, è abbastanza semplice in quanto Node ha funzionalità integrate per questo, si chiama fsche sta per File System e fondamentalmente, modulo NodeJS File System ...

Quindi prima richiedilo nel tuo file server.js in questo modo:

var fs = require('fs');

fsha pochi metodi per scrivere su file, ma il mio modo preferito è usare appendFile, questo aggiungerà le cose al file e se il file non esiste, ne creerà uno, il codice potrebbe essere come di seguito:

fs.appendFile('myFile.txt', 'Hi Ali!', function (err) {
  if (err) throw err;
  console.log('Thanks, It\'s saved to the 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 su 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");
                            });
                        }
                });

È possibile scrivere su un file usando il modulo fs (file system).

Ecco un esempio di come puoi farlo:

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

Potresti anche voler sbarazzarti di questa struttura di codice callback-inside-callback usando Promises e async/ awaitdichiarazioni. Ciò renderà la struttura del codice asincrono molto più piatta. Per fare ciò, è possibile utilizzare una utile funzione util.promisify (originale) . Ci consente di passare da callback a promesse. Dai un'occhiata all'esempio con le fsfunzioni seguenti:

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

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 indica ciò che devi scrivere nel file e la sua lunghezza, "content.length".

Ecco l'esempio di come leggere il file CSV da locale e scrivere il file CSV in 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()

fs.createWriteStream(path[,options])

optionspuò anche includere startun'opzione per consentire la scrittura di dati in una certa posizione oltre l'inizio del file. La modifica di un file anziché la sua sostituzione potrebbe richiedere una flagsmodalità r+anziché la modalità predefinita w. La codifica può essere una di quelle accettate da Buffer .

Se autoCloseè impostato su true (comportamento predefinito) 'error'o 'finish'il descrittore di file verrà chiuso automaticamente. Se autoCloseè falso, il descrittore di file non verrà chiuso, anche se si verifica un errore. È responsabilità dell'applicazione chiuderlo e assicurarsi che non vi siano perdite dal descrittore di file.

Come ReadStream , se fdspecificato, WriteStream ignorerà l' pathargomento e utilizzerà il descrittore di file specificato. Ciò significa che non 'open'verrà emesso alcun evento. fddovrebbe bloccare; i messaggi non bloccanti fddevono essere passati a net.Socket .

Se optionsè una stringa, specifica la codifica.

Dopo, leggendo questo lungo articolo. Dovresti capire come funziona. Quindi, ecco un esempio di 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');

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

È possibile scrivere in un file con il seguente esempio di codice:

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