Ich habe versucht, in Node.js eine Methode zum Schreiben in eine Datei zu finden, jedoch ohne Erfolg. Wie kann ich das machen?
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!");
});
Derzeit gibt es drei Möglichkeiten, eine Datei zu schreiben:
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.
fs.writeFile(filename, data, [encoding], callback)
Alle Daten müssen gleichzeitig gespeichert werden. Sie können keine sequentiellen Schreibvorgänge ausführen.
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.
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();
});
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');
})
});
});
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.
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 .
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");
}
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");
});
}
});
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".
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);
}
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()
fs.createWriteStream(path[,options])
options
kann auch die Optionstart
enthalten, um das Schreiben von Daten an einer Position nach dem Dateianfang zu ermöglichen. Das Ändern einer Datei anstelle des Ersetzens kann einenflags
-Modus vonr+
Anstelle des Standardmodusw
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. WennautoClose
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 Argumentpath
und verwendet den angegebenen Dateideskriptor. Dies bedeutet, dass kein'open'
- Ereignis ausgegeben wird.fd
sollte blockieren; Nicht blockierendefd
s 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');
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);
});
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.');
}
});
}
}
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')
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!');
});
Versuche Folgendes:
fs.readFile(`${__dirname}/fileName`, 'utf-8',(err, contents) => {
if (err) throw Error(err){
console.log(contents)
}
});