Schreiben von Dateien in Node.js

Question

Ich habe versucht, einen Weg zu finden, um eine Datei zu schreiben, wenn Node.js verwenden, aber ohne Erfolg. Wie kann ich das tun?

Answer 1

Es gibt eine Menge von Details in dem Dateisystem-API . Die gängigste Methode ist:

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

Zur Zeit gibt es drei Möglichkeiten, um eine Datei zu schreiben:

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

   Sie müssen für den Rückruf warten, um sicherzustellen, dass der Puffer auf die Festplatte geschrieben wird. Es ist nicht gepuffert.

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

   Alle Daten müssen zur gleichen Zeit gespeichert werden; Sie können nicht sequentielles Schreiben durchführen.

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

   Erzeugt ein WriteStream , die bequem, weil ist Sie nicht für einen Rückruf warten müssen. Aber auch hier ist es nicht gepuffert.

WriteStream , wie der Name schon sagt, ist ein Strom. Ein Strom ist per Definition „ein Puffer“ enthält Daten, die in eine Richtung bewegt (Quelle ► Ziel). Aber ein beschreibbarer Strom ist nicht unbedingt „gepuffert“. Ein Strom wird „gepuffert“, wenn Sie schreiben n mal, und zum Zeitpunkt n+1 sendet der Strom den Puffer an den Kernel (weil es voll und muss geleert werden).

Mit anderen Worten: „Ein Puffer“ ist das Objekt. Unabhängig davon, ob es „gepuffert“ ist eine Eigenschaft des Objekts.

Wenn Sie den Code anschauen, die WriteStream erbt von einem beschreibbaren Stream Objekt. Wenn Sie darauf achten, werden Sie sehen, wie sie den Inhalt spülen; sie haben kein Puffersystem.

Wenn Sie einen String schreiben, wird es in einen Puffer umgewandelt und dann auf die native Schicht gesendet und auf die Festplatte geschrieben. Wenn Strings zu schreiben, sie füllen keinen Puffer auf. Also, wenn Sie tun:

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

Sie tun:

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

Das ist, drei Anrufe an die I / O-Schicht. Obwohl Sie mit „Puffer“ sind, werden die Daten nicht gepuffert. Ein gepufferte Strom tun würde:. fs.write(new Buffer ("abc")), einen Aufruf an die I / O-Schicht

Ab sofort in Node.js v0.12 (stabile Version 2015.02.06 angekündigt) unterstützt nun zwei Funktionen: cork() und uncork() . Es scheint, dass diese Funktionen schließlich Ihnen erlaubt, die Schreib Anrufe zu puffern / spülen.

Zum Beispiel in Java gibt es einige Klassen, die gepufferte Ströme liefern (BufferedOutputStream, BufferedWriter ...). Wenn Sie drei Bytes schreiben, werden diese Bytes in dem Puffer (Speicher) gespeichert werden, anstatt einen I / O-Aufruf zu tun, nur für drei Bytes. Wenn der Puffer voll ist, wird der Inhalt gespült und auf Festplatte gespeichert. Dies verbessert die Leistung.

Ich bin nicht alles zu entdecken, nur die Erinnerung, wie ein Plattenzugriff getan werden sollte.

Answer 3

Sie können natürlich machen es ein wenig weiter fortgeschritten. Non-Blocking, Bits und Stücke zu schreiben, nicht die gesamte Datei auf einmal zu schreiben:

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

Synchrone schreiben

  

fs.writeFileSync (Datei, Daten [Optionen])

fs = require('fs');

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

Asynchronous Write

  

fs.writeFile (Datei, Daten [Optionen], Rückruf)

fs = require('fs');

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

Wo

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

Worth die offical File System (fs) zu lesen docs .

Answer 6

Ich mochte Index von ./articles/file-system .

Es funktionierte für mich.

Siehe auch Wie ich tun schreiben von Dateien 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');
});

Der Inhalt helloworld.txt:

Hello World!

Update:
Wie in Linux-Knoten Schreib in aktuellem Verzeichnis, so scheint es in einigen anderen nicht, so füge ich diesen Kommentar für alle Fälle:
Mit dieser ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); zu erhalten, wo die Datei geschrieben wird.

Answer 7

Ich weiß, die Frage zu „schreiben“, fragte aber in einem allgemeineren Sinne „append“ in einigen Fällen sinnvoll sein könnte, da es einfach in einer Schleife verwendet wird Text in eine Datei hinzufügen (ob die Datei vorhanden ist oder nicht) . Verwenden Sie ein „\ n“, wenn Sie Zeilen zB hinzufügen:

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

Zum Beispiel: Lese-Datei und Schreiben in einer anderen Datei:

  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

Die Antworten vorgesehen sind veraltet und eine neuere Art und Weise, dies zu tun ist:

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

siehe Dokumente hier für weitere Informationen

Answer 10

OK, es ist ganz einfach als Knoten für diese Funktionalität bereits eingebaut hat, es fs genannt, die für steht File System und im Grunde, NodeJS File System-Modul ...

So erfordert es zunächst in der server.js Datei wie folgt:

var fs = require('fs');

fs paar Methoden hat Schreiben auf Datei zu tun, aber meine bevorzugte Art und Weise ist appendFile verwenden, dies das Zeug in die Datei anhängen wird, und wenn die Datei nicht existiert, wird man schaffen, könnte der Code wie folgt:

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

Answer 11

Sie können in eine Datei schreiben mit fs (Dateisystem) Modul.

Hier ist ein Beispiel dafür, wie Sie es tun können:

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

Sie mögen vielleicht auch die Befreiung von dieser Rückruf-inside-Callback-Code-Struktur erhalten, indem useing Promises und async / await Aussagen. Dies wird asynchrone Code-Struktur wesentlich flacher machen. Dafür, dass es ein handliches util.promisify (original) Funktion kann genutzt werden. Es erlaubt uns, von Rückrufen Versprechen zu wechseln. Werfen Sie einen Blick auf das Beispiel mit fs Funktionen unter:

// 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

Hier verwenden wir w + für Schreib- / beiden Aktionen schreiben und wenn der Dateipfad der nicht gefunden wird, wäre es automatisch erstellt werden.

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 Mittel, was Sie in die Datei schreiben und seine Länge haben, ‚content.length‘.

Answer 13

Hier ist die Probe, wie CSV-Datei aus lokaler und Schreib csv-Datei lokal zu lesen.

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 kann auch eine start Option enthalten, damit Daten an einer bestimmten Position über den Anfang der Datei zu schreiben. Ändern eher eine Datei als Ersatz kann ein flags Modus von r+ erfordern, anstatt den Standardmodus w. Die Codierung kann jeder einer von denen angenommen von Buffer .

     

Wenn autoClose auf true (Standardverhalten) eingestellt ist auf 'error' oder 'finish' der Dateideskriptor wird automatisch geschlossen. Wenn autoClose falsch ist, dann wird der Dateideskriptor nicht geschlossen ist, wird, selbst wenn ein Fehler ist. Es liegt in der Verantwortung der Anwendung zu schließen und stellen Sie sicher, es gibt keine Dateideskriptors Leck.

     

Wie Readstream , wenn fd angegeben wird, net.Socket .

     

Wenn options ein String ist, dann gibt es die Codierung.

Nach dem, dem Lesen dieses langen Artikel. Sie sollten verstehen, wie es funktioniert. So, hier ist ein Beispiel für 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

Sie können durch das folgende Codebeispiel in einer Datei schreiben:

  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

Sie können mit Bibliothek easy-file-manager

installieren Sie zuerst von npm npm install easy-file-manager

Beispiel zum Hochladen und Entfernen von Dateien

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

Versuchen Sie Folgendes:

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