Node.js Dateisystem(FS)

Node.js FS

Node FS is an in-built module in Node.js that helps you handle and operate files.

NodeJs FS file operations

Using Node FS, you can perform the following operations on files:

• Datei lesen

• Create or overwrite file

• Update file

• Datei löschen

• Rename file

Node.js provides a set of file operation APIs similar to UNIX (POSIX) standards. The syntax for importing the file system module (fs) in Node is as shown below:

var fs = require("fs")

Asynchronous and synchronous

The methods in the Node.js file system (fs module) module have both asynchronous and synchronous versions, for example, the function to read the content of a file has an asynchronous fs.readFile() and a synchronous fs.readFileSync().

The last parameter of the asynchronous method function is the callback function, which contains the error information (error).

It is recommended to use asynchronous methods, as they are more efficient, faster, and non-blocking compared to synchronous methods.

Callback-Funktion, keine Parameter.

Create a file named input.txt with the following content:

Adresse der Basisanleitung: de.oldtoolbag.com
File read example

Create a file named file.js with the following code:

Nun erstellen wir die Datei file.js mit folgendem Code:
//　Asynchronous read
fs.readFile('input.txt', function(err, data) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Asynchronous read: ")　+　data.toString());
});
//　Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: ")　+　data.toString());
console.log("Program execution completed.");

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Synchronous read: Basic tutorial website address: de.oldtoolbag.com
File read example
Program execution completed.
Asynchronous read: Basic tutorial website address: de.oldtoolbag.com
File read example

Next, let's take a specific look at the Node.js file system methods.

Open file

Verzeichnis löschen

The syntax format for opening a file in asynchronous mode is as follows:

fs.open(path, flags[, mode], callback)

fs.rmdir(path, callback)

Parameter

• Anweisungen zur Verwendung der Parameter wie folgt: - The path of the file.

• flags - The behavior of opening a file. Specific values are detailed below.

• mode - Set file mode (permissions), the default permission for file creation is 0666(可读，可写)。

• Dateipfad. - 回调函数，带有两个参数如：callback(err, fd)。

flags 参数可以是以下值：

Callback-Funktion, keine Parameter.

接下来我们创建 file.js 文件，并打开 input.txt 文件进行读写，代码如下所示：

Nun erstellen wir die Datei file.js mit folgendem Code:
//　异步打开文件
console.log("Vorbereitung zur Datei-Öffnung!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　console.log("Datei wurde erfolgreich geöffnet!");　　　　　
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Datei öffnen!
Datei wurde erfolgreich geöffnet!

获取文件信息

Verzeichnis löschen

以下为通过异步模式获取文件信息的语法格式：

fs.stat(path,　callback)

fs.rmdir(path, callback)

Parameter

• Anweisungen zur Verwendung der Parameter wie folgt: - path

• Dateipfad. - 回调函数，带有两个参数如：(err, stats), stats 是 fs.Stats 对象。

fs.stat(path)执行后，会将stats类的实例返回给其回调函数。可以通过stats类中的提供方法判断文件的相关属性。例如判断是否为文件：

var　fs　=　require('fs');
fs.stat('/Users/liuht/code/itbilu/demo/fs.js',　function　(err,　stats)　{
　　　　console.log(stats.isFile());　　　　　　　　　//true
)

stats类中的方法有：

Callback-Funktion, keine Parameter.

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
console.log("Vorbereitung zur Datei-Öffnung!");
fs.stat('input.txt', function(err, stats) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log(stats);
　　　console.log("Dateiinformationen erfolgreich gelesen!");
　　　
　　　//　Dateityp überprüfen
　　　console.log("Ist eine Datei (isFile) ? ")　+　stats.isFile());
　　　console.log("Ist ein Verzeichnis (isDirectory) ? ")　+　stats.isDirectory());　　　　
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Datei öffnen!
{ dev:　16777220 ,
　　mode:　33188,
　　nlink:　1,
　　uid:　501,
　　gid:　20 ,
　　rdev: 0 ,
　　blksize:　4096,
　　ino:　40333161,
　　size:　61,
　　blocks:　8,
　　atime: Mon Sep 07　2015　17:43:55　GMT+0800 (CST),
　　mtime: Mon Sep 07　2015　17:22:35　GMT+0800 (CST),
　　ctime: Mon Sep 07　2015　17:22:35　GMT+0800 (CST)}
Dateiinformationen erfolgreich gelesen!
Ist eine Datei (isFile) ? true
Ist ein Verzeichnis (isDirectory) ? false

Datei schreiben

Verzeichnis löschen

Nachfolgend ist das Syntaxformat für das Schreiben von Dateien im asynchronen Modus:

fs.writeFile(file, data[, options], callback)

writeFile öffnet Datei direkt standardmäßig w Modus, daher wird der Inhalt, den diese Methode schreibt, bei vorhandener Datei den alten Dateiinhalt überschreiben.

fs.rmdir(path, callback)

Parameter

• file - Dateiname oder Dateideskriptor.

• data - Zu schreibende Daten in die Datei, können String (Zeichenfolge) oder Buffer (Puffer) Objekt sein.

• options - Dieser Parameter ist ein Objekt, das {encoding, mode, flag} enthält. Die Standardkodierung ist utf8, Modus ist 0666 ，flag ist 'w'

• Dateipfad. - Rückruffunktion, die nur den Fehlerinformation parameter (err) enthält und bei einem Schreibfehler zurückgegeben wird.

Callback-Funktion, keine Parameter.

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
console.log("Datei schreiben vorbereiten");
fs.writeFile('input.txt', 'Ich schreibe durch fs.writeFile Inhalt in die Datei', function(err) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Datenbeschreibung erfolgreich!");
　　　console.log("--------Ich bin eine Trennlinie-------------")
　　　console.log("Lesen Sie die geschriebenen Daten!");
　　　fs.readFile('input.txt', function(err, data) {
　　　　　　if (err) {
　　　　　　　　　return console.error(err);
　　　　　　}
　　　　　　console.log("Asynchrone Lektüre von Dateidaten: ",　+　data.toString());
　　　});
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Vorbereitung zur Datenbeschreibung!
Datenbeschreibnung erfolgreich!
--------Ich bin eine Trennlinie-------------
Lesen Sie die geschriebenen Daten!
Asynchrone Lektüre von Dateidaten: Ich habe den Inhalt der Datei durch fs.writeFile geschrieben

Datei lesen

Verzeichnis löschen

Nachfolgend ist das Syntaxformat der Dateilektüre in asynchronem Modus aufgeführt:

fs.read(fd, buffer, offset, length, position, callback)

Diese Methode verwendet Dateibezeichner, um Dateien zu lesen.

fs.rmdir(path, callback)

Parameter

• fd - Dateibezeichner, der durch die Methode fs.open() zurückgegeben wird.

• buffer - Puffer, in den Daten geschrieben werden.

• offset - Schreibversatz im Puffer.

• length - Anzahl der Bytes, die aus der Datei gelesen werden sollen.

• position - Startposition der Dateilektüre, wenn der Wert von position null ist, wird von der aktuellen Position des Dateipointers gelesen.

• Dateipfad. - Rückruffunktion, drei Parameter err, bytesRead, buffer, err als Fehlerinformationen, bytesRead als gelesene Byteszahl, buffer als Pufferobjekt.

Callback-Funktion, keine Parameter.

Der Inhalt der Datei input.txt ist:

Adresse der Basisanleitung: de.oldtoolbag.com

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
var buf = new Buffer.alloc(1024);
console.log("Vorbereitung zur Öffnung einer vorhandenen Datei!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Datei wurde erfolgreich geöffnet!");
　　　console.log("Vorbereitung zur Dateilektüre:");
　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}
　　　　　　console.log(bytes　+　" Bytes wurden gelesen");
　　　　　　
　　　　　　//　Nur die gelesenen Bytes ausgeben
　　　　　　if (bytes > 0) {
　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　}
　　　});
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Vorbereitung zur Öffnung einer vorhandenen Datei!
Datei wurde erfolgreich geöffnet!
Vorbereitung zur Dateilektüre:
42　　Bytes wurden gelesen
Adresse der Basisanleitung: de.oldtoolbag.com

Datei schließen

Verzeichnis löschen

Nachfolgend ist das Syntaxformat der Dateischließung in asynchronem Modus aufgeführt:

fs.close(fd, callback)

Diese Methode verwendet Dateibezeichner, um Dateien zu lesen.

fs.rmdir(path, callback)

Parameter

• fd - Dateibezeichner, der durch die Methode fs.open() zurückgegeben wird.

• Dateipfad. - callback

Callback-Funktion, keine Parameter.

Der Inhalt der Datei input.txt ist:

Adresse der Basisanleitung: de.oldtoolbag.com

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
var buf = new Buffer.alloc(1024);
console.log("Vorbereitung zur Datei-Öffnung!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Datei wurde erfolgreich geöffnet!");
　　　console.log("Vorbereitung zur Dateilektüre!");
　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}
　　　　　　//　Nur die gelesenen Bytes ausgeben
　　　　　　if (bytes > 0) {
　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　}
　　　　　　//　Datei schließen
　　　　　　fs.close(fd, function(err) {
　　　　　　　　　if (err) {
　　　　　　　　　　　　console.log(err);
　　　　　　　　　}　
　　　　　　　　　console.log("Datei wurde erfolgreich geschlossen");
　　　　　　});
　　　});
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Datei öffnen!
Datei wurde erfolgreich geöffnet!
Vorbereitung zur Dateilektüre!
Adresse der Basisanleitung: de.oldtoolbag.com
Datei wurde erfolgreich geschlossen

Datei abschneiden

Verzeichnis löschen

Nachfolgend ist das Syntaxformat der Sektionsauswahl in asynchroner Modus aufgeführt:

fs.ftruncate(fd, len, callback)

Diese Methode verwendet Dateibezeichner, um Dateien zu lesen.

fs.rmdir(path, callback)

Parameter

• fd - Dateibezeichner, der durch die Methode fs.open() zurückgegeben wird.

• len - Länge des ausgeschnittenen Dateiinhalts.

• Dateipfad. - callback

Callback-Funktion, keine Parameter.

Der Inhalt der Datei input.txt ist:

site:de.oldtoolbag.com

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
var buf = new Buffer.alloc(1024);
console.log("Vorbereitung zur Datei-Öffnung!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Datei wurde erfolgreich geöffnet!");
　　　console.log("Abschneiden"}}10Inhalt der Datei innerhalb der Bytes, der überschüssige Teil wird entfernt.");
　　　
　　　//　Datei abschneiden
　　　fs.ftruncate(fd,　10, function(err) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}　
　　　　　　console.log("Datei wurde erfolgreich abgeschnitten.");
　　　　　　console.log("Lesen Sie denselben Datei");　
　　　　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　　　　if (err) {
　　　　　　　　　　　　console.log(err);
　　　　　　　　　}
　　　　　　　　　//　Nur die gelesenen Bytes ausgeben
　　　　　　　　　if (bytes > 0) {
　　　　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　　　　}
　　　　　　　　　//　Datei schließen
　　　　　　　　　fs.close(fd, function(err) {
　　　　　　　　　　　　if (err) {
　　　　　　　　　　　　　　　console.log(err);
　　　　　　　　　　　　}　
　　　　　　　　　　　　console.log("Datei wurde erfolgreich geschlossen!");
　　　　　　　　　});
　　　　　　});
　　　});
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Datei öffnen!
Datei wurde erfolgreich geöffnet!
Abschneiden10Inhalt der Datei innerhalb der Bytes, der überschüssige Teil wird entfernt.
Datei wurde erfolgreich abgeschnitten.
Lesen Sie denselben Datei
site:www.r
Datei wurde erfolgreich geschlossen

Datei löschen

Verzeichnis löschen

Hier ist das Syntaxformat zur Löschung einer Datei:

fs.unlink(path, callback)

fs.rmdir(path, callback)

Parameter

• Anweisungen zur Verwendung der Parameter wie folgt: - path

• Dateipfad. - callback

Callback-Funktion, keine Parameter.

Der Inhalt der Datei input.txt ist:

site:de.oldtoolbag.com

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
console.log("Datei löschen!");
fs.unlink('input.txt', function(err) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Datei wurde erfolgreich gelöscht!");
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Datei löschen!
Datei wurde erfolgreich gelöscht!

Betrachten Sie dann die Datei input.txt, und Sie finden, dass sie nicht mehr existiert.

Verzeichnis erstellen

Verzeichnis löschen

Hier ist das Syntaxformat zur Erstellung eines Verzeichnisses:

fs.mkdir(path[, options], callback)

fs.rmdir(path, callback)

Parameter

• Anweisungen zur Verwendung der Parameter wie folgt: - path

• Der options-Parameter kann sein:

• recursive - Verzeichnis mit rekursiver Erstellung erstellen, Standard ist false.

• mode - Verzeichnisrechte festlegen, Standard ist 0777。

• Dateipfad. - callback

Callback-Funktion, keine Parameter.

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
//　tmp-Verzeichnis muss existieren
console.log("Verzeichnis erstellen　/tmp/test/");
fs.mkdir("/tmp/test/"
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Verzeichnis wurde erfolgreich erstellt.");
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Verzeichnis erstellen　/tmp/test/
Verzeichnis wurde erfolgreich erstellt.

Sie können den Parameter recursive: true hinzufügen, egal ob das erstellte Verzeichnis 　/tmp und /tmp/a Existenz:

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
　　if　(err)　throw　err;
});

if (err) throw err;

Verzeichnis löschen

Verzeichnis lesen

Nachstehend ist das Syntaxformat zur Lesung eines Verzeichnisses:

fs.rmdir(path, callback)

Parameter

• Anweisungen zur Verwendung der Parameter wie folgt: - path

• Dateipfad. - fs.readdir(path, callback)

Callback-Funktion, keine Parameter.

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
Callback-Funktion, die zwei Parameter enthält: err, files, err ist die Fehlermeldung, files ist die Liste der Dateien im Verzeichnis.　/tmp-Verzeichnis");
fs.readdir("/tmp/",function(err, files){
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　files.forEach(function(file){
　　　　　　　console.log(file);
　　　});
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
console.log("Anzeigen",　/tmp-Verzeichnis
Anzeigen
input.out
test
output.out

test.txt

Verzeichnis löschen

Syntax

Nachstehend ist das Syntaxformat zur Löschung eines Verzeichnisses:

fs.rmdir(path, callback)

Parameter

• Anweisungen zur Verwendung der Parameter wie folgt: - path

• Dateipfad. - callback

Callback-Funktion, keine Parameter.

Beispiel

Nun erstellen wir die Datei file.js mit folgendem Code:
//　var fs = require("fs");　/tmp/Vor der Ausführung wird ein leeres
test-Verzeichnis　/tmp/console.log("Verzeichnis zum Löschen vorbereiten", function(err){
test");/tmp/fs.rmdir("
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Lesen", function(err){　/tmp-Verzeichnis");
　　　fs.readdir("/tmp/",function(err, files){
　　　　　　if (err) {
　　　　　　　　　　return console.error(err);
　　　　　　}
　　　　　　files.forEach(function(file){
　　　　　　　　　　console.log(file);
　　　　　　});
　　　});
});

Das Ergebnis des Ausführens des obigen Codes ist wie folgt:

$ node file.js　
Verzeichnis zum Löschen vorbereiten　/tmp/test
Lesen　/tmp-Verzeichnis
……

Handbuch für Dateimodulmethoden

Nachstehend finden Sie eine Liste der gleichen Methoden im Node.js-Dateimodul:

更多内容，请查看官网文件模块描述：文件系统。