La scrittura di file in Node.js

Question

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

Answer 1

Ci sono un sacco di dettagli nella file system API . 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!");
}); 

Answer 2

Al momento ci sono tre modi per scrivere un file:

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

   È necessario attendere per la richiamata al fine di garantire che il buffer viene scritto su disco. Non è tamponato.

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

   Tutti i dati devono essere memorizzati nello stesso momento; non è possibile eseguire operazioni di scrittura sequenziale.

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

   Crea un WriteStream , che è conveniente perché non c'è bisogno di aspettare per un callback. Ma ancora una volta, non è tamponata.

Un WriteStream , come dice il nome, è un flusso. Un flusso per definizione “un buffer” contenente i dati che si muove in una direzione (fonte ► destinazione). Ma un flusso scrivibile non è necessariamente “tamponato”. Un flusso viene “tamponato” quando si scrive i tempi n, e al momento della n+1, il flusso invia il buffer per il kernel (perché è pieno e deve essere svuotato).

In altre parole: “Un buffer” è l'oggetto. Che sia o meno “è tamponato” è una proprietà di tale oggetto.

Se si guarda il codice, il WriteStream eredita da un oggetto Stream scrivibile. Se si presta attenzione, vedrete come si sciacquare il contenuto; non hanno alcun sistema di buffering.

Se si scrive una stringa, è convertito in un buffer, e poi inviato al livello nativo e scritti su disco. Durante la scrittura di stringhe, che non stanno riempiendo ogni tampone. Quindi, se si fa:

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

Si sta facendo:

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

Questo è il tre chiamate allo strato di I / O. Anche se sei con “buffer”, i dati non è tamponato. Un flusso tamponato avrebbe fatto:. fs.write(new Buffer ("abc")), una chiamata per lo strato di I / O

A partire da ora, a Node.js v0.12 (versione stabile ha annunciato 2015/02/06) ora supporta due funzioni: cork() uncork() . Sembra che queste funzioni finalmente permetterà di buffer / lavare le chiamate di scrittura.

Per esempio, in Java ci sono alcune classi che forniscono flussi buffered (BufferedOutputStream, BufferedWriter ...). Se si scrive tre byte, questi byte saranno memorizzati nel buffer (memoria) invece di fare una chiamata di I / O solo per tre byte. Quando il buffer è pieno il contenuto viene lavata e salvato su disco. Questo migliora le prestazioni.

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

Answer 3

È possibile, naturalmente, rendere un po 'più avanzato. Non-blocking, scrivendo pezzi e bocconi, non scrivere l'intero file in una sola 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();
});

Answer 4

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

Answer 5

scrittura sincrona

  

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

fs = require('fs');

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

Scrivi Asynchronous

  

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 <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

Da leggere l'ufficiale File System (fs) docs .

Answer 6

Mi è piaciuta Indice di ./articles/file-system .

Ha funzionato per me.

Si veda anche Come faccio scrivere 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');
});

Contenuto del helloworld.txt:

Hello World!

Aggiornamento:
Come in Linux nodo scrittura nella directory corrente, a quanto pare in alcuni altri non lo fanno, in modo da aggiungere questo commento per ogni evenienza:
L'utilizzo di questo ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); per arrivare dove il file viene scritto.

Answer 7

So che la domanda posta su "scrivere", ma in un senso più generale "accodare" potrebbe essere utile in alcuni casi, come è facile da usare in un ciclo per aggiungere del testo a un file (se il file esiste o meno) . Utilizzare un "\ n", se si desidera aggiungere linee ad esempio:

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

Answer 8

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

Ad esempio: leggere il file e scrivere 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");
                            });
                        }
                });

Answer 9

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

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

vedere i documenti qui per ulteriori informazioni

Answer 10

OK, è abbastanza semplice come Node è dotato di funzionalità per questo, si chiama fs che sta per File System e in fondo, modulo NodeJS File System ...

Quindi, prima lo richiedono nel vostro server.js file in questo modo:

var fs = require('fs');

fs ha pochi metodi per fare scrivere nel file, ma il mio modo preferito sta usando appendFile, questo aggiungerà la roba per il file e se il file non esiste, verrà creato 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!');
});

Answer 11

Si può scrivere in un file utilizzando fs modulo (file system).

Ecco un esempio di come si può 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');
    }
  });
};

Si potrebbe anche voler sbarazzarsi di questa struttura del codice di callback-dentro-callback da useing Promises le dichiarazioni e async / await. Questo renderà struttura del codice asincrono molto più piatta. Per fare che v'è un pratico util.promisify (originale) funzione potrebbe essere utilizzata. Ci permette di passare dalla callback alle promesse. Date un'occhiata a l'esempio con le funzioni fs di seguito:

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

Answer 12

Qui usiamo w + per lettura / scrittura entrambe le azioni e se il percorso del file non viene trovato l'sarebbe 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');
            })
        });
    }
});

Content significa quello che hai da scrivere sul file e la sua lunghezza, 'content.length'.

Answer 13

Ecco l'esempio di come leggere un file csv, da quello locale e scrivere file CSV da 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()

Answer 14

  

fs.createWriteStream(path[,options])

     

options può anche includere un'opzione start per consentire la scrittura dei dati in una qualche posizione oltre l'inizio del file. Modifica di un file piuttosto che sostituirlo può richiedere una modalità di flags r+ piuttosto che il w modalità predefinita. La codifica può essere uno qualsiasi di quelli accettati da Buffer .

     

Se autoClose è impostata su true (comportamento di default) su 'error' o 'finish' il descrittore di file verrà chiusa automaticamente. Se autoClose è falso, allora il descrittore di file non verrà chiuso, anche se c'è un errore. È responsabilità dell'applicazione per chiuderla e assicurarsi che non ci sono perdite descrittore di file.

     

ReadStream , se fd è specificato, WriteStream ignorerà l'argomento path e utilizzerà il descrittore di file specificato. Questo significa che nessun evento 'open' sarà emesso. fd dovrebbe essere blocco; fds non bloccanti dovrebbero essere passati a net.Socket .

     

Se options è una stringa, allora specifica la codifica.

Dopo, la lettura di questo lungo articolo. Si dovrebbe 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');

Answer 15

È possibile scrivere in un file dal 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.');        
            }        
        });        
    }        
}        

Answer 16

È possibile utilizzare easy-file-manager biblioteca

prima installare da NPM npm install easy-file-manager

di esempio per caricare e rimuovere i 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);
});

Answer 17

Provare quanto segue:

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