it-swarm.com.de

Dateien in Node.js schreiben

Ich habe versucht, in Node.js eine Methode zum Schreiben in eine Datei zu finden, jedoch ohne Erfolg. Wie kann ich das machen?

1311
Gjorgji

Das Dateisystem API enthält viele Details. Der häufigste Weg 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!");
}); 
2061
Brian McKenna

Derzeit gibt es drei Möglichkeiten, eine Datei zu schreiben:

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

    Sie müssen auf 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 gleichzeitig gespeichert werden. Sie können keine sequentiellen Schreibvorgänge ausführen.

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

    Erstellt ein WriteStream , was praktisch ist, weil Sie nicht auf einen Rückruf warten müssen. Aber es ist nicht gepuffert.

Ein WriteStream ist, wie der Name sagt, ein Stream. Ein Stream nach Definition ist ein „Puffer“, der Daten enthält, die sich in eine Richtung bewegen (Quellziel). Ein beschreibbarer Stream ist jedoch nicht unbedingt "gepuffert". Ein Stream wird "gepuffert", wenn Sie n-mal schreiben, und zum Zeitpunkt n+1 sendet der Stream den Puffer an den Kernel (weil er voll ist und geleert werden muss).

Mit anderen Worten: "Ein Puffer" ist das Objekt. Ob es "gepuffert" ist oder nicht, ist eine Eigenschaft dieses Objekts.

Wenn Sie sich den Code anschauen, erbt die Variable WriteStream von einem beschreibbaren Objekt Stream. Wenn Sie aufpassen, sehen Sie, wie sie den Inhalt leeren. Sie haben kein Puffersystem.

Wenn Sie einen String schreiben, wird er in einen Puffer konvertiert und dann an die native Ebene gesendet und auf die Festplatte geschrieben. Beim Schreiben von Strings füllen sie keinen Puffer auf. Also, wenn Sie es tun:

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

Sie gehen:

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

Das sind drei Aufrufe an die E/A-Schicht. Obwohl Sie "Puffer" verwenden, werden die Daten nicht gepuffert. Ein gepufferter Stream würde Folgendes tun: fs.write(new Buffer ("abc")), ein Aufruf an die E/A-Schicht.

Ab sofort werden in Node.js v0.12 (stabile Version 02.06.2015 angekündigt) zwei Funktionen unterstützt: cork() und uncork() . Es scheint, dass diese Funktionen es Ihnen schließlich ermöglichen, die Schreibaufrufe zu puffern/zu leeren.

In Java gibt es beispielsweise einige Klassen, die gepufferte Streams bereitstellen (BufferedOutputStream, BufferedWriter...). Wenn Sie drei Bytes schreiben, werden diese Bytes im Puffer (Speicher) gespeichert, anstatt einen E/A-Aufruf nur für drei Bytes durchzuführen. Wenn der Puffer voll ist, wird der Inhalt gelöscht und auf der Festplatte gespeichert. Dies verbessert die Leistung.

Ich entdecke nichts, erinnere mich nur daran, wie ein Zugriff auf die Festplatte erfolgen sollte.

474
Gabriel Llamas

Sie können es natürlich etwas fortgeschrittener machen. Nicht blockieren, Schreiben von Bits und Stücken, nicht das Schreiben der gesamten Datei auf einmal:

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

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

Es hat für mich funktioniert.

Siehe auch Wie schreibe ich 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');
});

Inhalt von helloworld.txt:

Hello World!

Aktualisieren:
Wie im Linux-Knoten in das aktuelle Verzeichnis geschrieben wird, scheint es in einigen anderen nicht der Fall zu sein. Daher füge ich diesen Kommentar für alle Fälle hinzu:
Verwenden Sie diese ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);, um zu ermitteln, wo die Datei geschrieben wird.

26
Sérgio

Synchrones Schreiben

fs.writeFileSync (Datei, Daten [ Optionen])

fs = require('fs');

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

Asynchrones Schreiben

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

Woher

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

Lesen Sie das offizielle Dateisystem (fs) docs .

21
Moriarty

Ich kenne die Frage nach "Schreiben", aber in einem allgemeineren Sinn kann "Anfügen" in einigen Fällen nützlich sein, da es in einer Schleife einfach ist, Text in eine Datei einzufügen (unabhängig davon, ob die Datei vorhanden ist oder nicht). Verwenden Sie ein "\ n", wenn Sie Zeilen hinzufügen möchten, zB:

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

Zum Beispiel: Datei lesen und in eine andere Datei schreiben:

  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

Hier verwenden wir w + zum Lesen/Schreiben beider Aktionen. Wenn der Dateipfad nicht gefunden wird, wird er automatisch erstellt.

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

Inhalt bedeutet, was Sie in die Datei schreiben müssen und deren Länge "content.length".

4
Gunjan Patel

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

Hier ist ein Beispiel, 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');
    }
  });
};

Möglicherweise möchten Sie auch diese Callback-Inside-Callback-Codestruktur mithilfe der Anweisungen Promises und async/await loswerden. Dadurch wird die asynchrone Codestruktur viel flacher. Dafür kann eine praktische util.promisify (original) - Funktion verwendet werden. Dadurch können wir von Rückrufen zu Versprechen wechseln. Sehen Sie sich das Beispiel mit den folgenden fs-Funktionen an:

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

Hier ist das Beispiel, wie man eine Datei csv von local liest und eine csv-Datei in local schreibt.

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

fs.createWriteStream(path[,options])

options kann auch die Option start enthalten, um das Schreiben von Daten an einer Position nach dem Dateianfang zu ermöglichen. Das Ändern einer Datei anstelle des Ersetzens kann einen flags -Modus von r+ Anstelle des Standardmodus w erfordern. Die Kodierung kann eine beliebige sein, die von Puffer akzeptiert wird.

Wenn autoClose für 'error' Oder 'finish' Auf true (Standardverhalten) gesetzt ist, wird der Dateideskriptor automatisch geschlossen. Wenn autoClose false ist, wird der Dateideskriptor auch dann nicht geschlossen, wenn ein Fehler vorliegt. Es liegt in der Verantwortung der Anwendung, diese zu schließen und sicherzustellen, dass keine Dateideskriptoren verloren gehen.

Wie ReadStream ignoriert WriteStream bei Angabe von fd das Argument path und verwendet den angegebenen Dateideskriptor. Dies bedeutet, dass kein 'open' - Ereignis ausgegeben wird. fd sollte blockieren; Nicht blockierende fds sollten an net.Socket übergeben werden.

Wenn options eine Zeichenfolge ist, gibt sie die Codierung an.

Lesen Sie anschließend diesen langen Artikel. Sie sollten verstehen, wie es funktioniert. 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');
2
user9258013

Sie können die Bibliothek easy-file-manager verwenden.

erstinstallation 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);
});
2
Christoper

Sie können mit dem folgenden Codebeispiel in eine 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.');        
            }        
        });        
    }        
}        
2
Mudassir

Die Antworten sind datiert und eine neuere Möglichkeit, dies zu tun, ist:

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

siehe doco hier für mehr Infos

1
TrevTheDev

OK, es ist ziemlich einfach, da Node über eine eingebaute Funktionalität verfügt, die fs heißt. Diese steht für File System und im Grunde genommen NodeJS File System-Modul ...

So müssen Sie es zuerst in Ihrer server.js -Datei wie folgt eingeben:

var fs = require('fs');

fs hat nur wenige Methoden, um in eine Datei zu schreiben, aber meine bevorzugte Methode ist appendFile. Dies hängt die Dateien an die Datei an. Wenn die Datei nicht vorhanden ist, wird eine erstellt, der Code könnte wie folgt aussehen:

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

Versuche Folgendes:

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