Node.js: Lesen und Schreiben von Dateien in Node.js

In diesem Tutorial wird erläutert, wie Sie mithilfe der Node.js-Bibliotheken auf das Dateisystem zugreifen und Dateien lesen/schreiben. In diesem Tutorial wird ein Modul namens fs für die Interaktion mit dem Dateisystem erläutert.

Ich habe verschiedene Node.js-Artikel geschrieben, die sich mit den Themen „Planen von Aufgaben in Node.js mithilfe von Cron Package, ExpressJS und Bootstrap-Entwicklung sowie Node.js- und MongoDB CRUD-Operationen“ befassen. Erfahren Sie außerdem, wie Sie die Node.js-Anwendung packen und bereitstellen.

Node.js stellt ein Modul namens bereit fs für die Interaktion mit dem Dateisystem. Dazu gehört nicht nur das Lesen/Schreiben in eine Datei, sondern auch weitere Dinge wie das Verknüpfen von Dateien, Berechtigungen für Dateien und Verzeichnisse, das Überwachen von Dateien, Verzeichnissen auf Änderungen und andere. Die Dateioperationen von Node.js bieten noch viel mehr. Hier erkläre ich nur Lese- und Schreib-APIs.

In diesem Beitrag zeige ich Ihnen, wie Sie damit in Node.js sowohl synchron als auch asynchron aus Dateien lesen und in Dateien schreiben können fs Modul. Die Datei-API definiert jede Methode sowohl in der synchronen als auch in der asynchronen Version. Sie können entweder den synchronen Aufruf oder den asynchronen Aufruf verwenden, um Dateien zu lesen, zu schreiben und zu entfernen.

Ich gehe davon aus, dass Sie ausreichend Kontakt zu Node.js haben, um die Pakete einzurichten und zu importieren. Daher würde ich mich in diesem Tutorial nur auf die Erläuterung der Node.js-Dateioperationen konzentrieren.

Node.js-Dateioperationen

NodeJS-Dateioperationen

Es gibt verschiedene Möglichkeiten, die Datei zu lesen. In diesem Beitrag werde ich zwei Möglichkeiten zeigen:

  • Verwenden der readFile-API.
  • unter Verwendung der ReadStream-API

Datei asynchron lesen – readFile API

Dieses Beispiel hilft Ihnen, eine Datei asynchron mit der Methode readFile() zu lesen.

//Filename:  node-read-async.js
var fs = require('fs');
var readSource="C:/input.txt";

/** Using the readFile API - Asynchronous */
fs.readFile(readSource, "utf8", function(err, data){
  if ( err ){ throw err;}
  console.log("Reading file asynchronously");
  console.log(data);
});

Führen Sie den obigen Code aus, indem Sie Folgendes ausführen: node node-read-async.js

Die Ausgabe, die wir erhalten:

G:\node\node-file-io>node node-read-async.js
Reading file asynchronously
As an asynchronous event driven framework, Node.js is designed to build scalable network applications. In the following "hello world" example, many connections can be handled concurrently. Upon each connection the callback is fired, but if there is no work to be done Node is sleeping.

Datei synchron lesen – readFileSync API

//Filename: node-read-sync.js
var fs = require('fs');
var readSource="C:/input.txt";

/** Using the readFile API - Asynchronous */
console.log("Reading file synchronously");
var fileData = fs.readFileSync(readSource, "utf8");
console.log(fileData);

Wenn wir das oben Gesagte ausführen, erhalten wir:

G:\node\node-file-io>node node-read-sync.js
Reading file synchronously
As an asynchronous event driven framework, Node.js is designed to build scalable network applications. In the following "hello world" example, many connections can be handled concurrently. Upon each connection the callback is fired, but if there is no work to be done Node is sleeping.

Datei lesen – ReadStream-API

var fs = require('fs');
var readSource="C:/input.txt";

/** Reading file using ReadStream API */
//Creating a stream out of the file
var readStreamObject = fs.createReadStream(readSource, { flags: 'r',
  encoding:"utf8",
  fd: null,
  mode: 0666,
  autoClose: true
});

//Setting up event handlers on the stream object
//readable - this event is fired when data can be read from stream
readStreamObject.on('readable', function(){
  console.log("*** Reading from file using ReadStream");
});
//data - this event is fired when data is available to be read from stream
readStreamObject.on('data', function(data){
  console.log(data);
});

//end - this event is fired when there is no more data available to be read from stream
readStreamObject.on('end', function(){
  console.log("*** Completed Reading from file using ReadStream");
});

Wenn wir den obigen Code wie unten gezeigt ausführen, erhalten wir:

G:\node\node-file-io>node node-read-readstream.js
As an asynchronous event driven framework, Node.js is designed to build scalable network applications. In the following "hello world" example, many connections can be handled concurrently. Upon each connection the callback is fired, but if there is no work to be done Node is sleeping.
*** Reading from file using ReadStream
*** Completed Reading from file using ReadStream

Oben ist Ihnen vielleicht aufgefallen, dass die Ereignisbehandlung nicht in Ordnung ist, d. h. man würde zuerst die Meldung „*** Lesen aus Datei mit ReadStream“, dann den Inhalt der Datei und schließlich „*** Lesen aus Datei mit ReadStream abgeschlossen“ erwarten “. Aufgrund der asynchronen Natur der API ist die Reihenfolge jedoch nicht garantiert.

Asynchron in Datei schreiben – writeFile-API

var fs = require('fs');
var writeSource="C:/Users/Mohamed/Documents/node-write-demo.txt";

fs.writeFile(writeSource, "Writing to a file from node.js", {"encoding":'utf8'}, function(err){
  if ( err ) { throw err; }
  console.log("*** File written successfully");
  //Now reading the same file to confirm data written
  fs.readFile(writeSource, "utf8", function(err, data){
    if ( err ){ throw err;}
    console.log("*** Reading just written file");
    console.log(data);
  });

});

Wenn wir das obige Skript ausführen, erhalten wir:

G:\node\node-file-io>node node-write-async.js
*** File written successfully
*** Reading just written file
Writing to a file from node.js

Synchron in Datei schreiben – writeFileSync-API

var fs = require('fs');
var writeSource="C:/Users/Mohamed/Documents/node-write-sync-demo.txt";

fs.writeFileSync(writeSource, "Writing to a file synchronously from node.js", {"encoding":'utf8'});

console.log("*** File written successfully");

//Now reading the same file to confirm data written
fs.readFile(writeSource, "utf8", function(err, data){
  if ( err ){ throw err;}
  console.log("*** Reading just written file");
  console.log(data);
});

Wenn wir das obige Skript ausführen, erhalten wir:

G:\node\node-file-io>node node-write-sync.js
*** File written successfully
*** Reading just written file
Writing to a file synchronously from node.js

In Datei schreiben – WriteStream-API

var fs = require('fs');
var writeSource="C:/Users/Mohamed/Documents/node-write-stream-demo.txt";
//Create a stream with the required path
var writeStreamObject = fs.createWriteStream(writeSource);

//write to the stream using the API
writeStreamObject.write("Writing to a file using WriteStream", "utf8");

//Now read the same file to verify that the contents have been successfully written
fs.readFile(writeSource, "utf8", function(err, data){
  if ( err ){ throw err;}
  console.log("*** Reading the recently written file");
  console.log(data);
});

Wenn wir das obige Skript ausführen, erhalten wir:


G:\node\node-file-io>node node-write-writestream.js
*** Reading the recently written file
Writing to a file using WriteStream

Zusammenfassung

In diesem Tutorial wurde erklärt, wie man Dateien mit dem fs-Paket in Node.js liest und schreibt. Für jeden Vorgang sind zwei Arten von Methoden definiert (Lesen, Schreiben und Entfernen), synchrone und asynchrone. Damit habe ich verschiedene Möglichkeiten aufgezeigt, wie wir Dateien in Node.js lesen und schreiben können. Wenn Sie Fragen haben, schreiben Sie diese bitte in den Kommentarbereich.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen