Node.js-Dateisystem

Das Dateisystemmodul von Node.js (fs-Modul) bietet eine umfangreiche API zum Lesen, Schreiben und Löschen von Dateien sowie zum Ausführen anderer Dateisystemvorgänge.

Das fs-Modul unterstützt sowohl synchrone als auch asynchrone Methoden, sodass Entwickler je nach Bedarf den geeigneten Ansatz für Dateioperationen wählen können.

Das fs-Modul importieren

Zuerst müssen Sie das fs-Modul importieren:

var fs = require("fs")

Asynchron und synchron

Methoden im Node.js-Dateisystem (fs-Modul) haben sowohl asynchrone als auch synchrone Versionen. Zum Beispiel umfassen Funktionen zum Lesen von Dateiinhalten das asynchrone fs.readFile() und das synchrone fs.readFileSync().

Bei asynchronen Methoden ist der letzte Parameter eine Callback-Funktion, und der erste Parameter der Callback-Funktion enthält die Fehlerinformationen (error).

Es wird empfohlen, asynchrone Methoden zu verwenden. Im Vergleich zu synchronen Methoden bieten asynchrone Methoden eine bessere Leistung, höhere Geschwindigkeit und keine Blockierung.

Beispiel

Erstellen Sie eine example.txt-Datei mit folgendem Inhalt:

Example官网地址：www.example.com
文件读取实例

Erstellen Sie eine file.js-Datei mit folgendem Code:

Beispiel

var fs = require("fs");

// Asynchrones Lesen
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchrones Lesen: " + data.toString());
});

// Synchrones Lesen
var data = fs.readFileSync('example.txt');
console.log("Synchrones Lesen: " + data.toString());

console.log("Programmausführung abgeschlossen.");

Die Ausgabe des obigen Codes lautet:

$ node file.js 
同步读取: Example官网地址：www.example.com
文件读取实例

程序执行完毕。
异步读取: Example官网地址：www.example.com
文件读取实例

Datei schreiben

Asynchrones Schreiben in eine Datei:

fs.writeFile('example.txt', 'Hello, World!', (err) => {
    if (err) {
        console.error('Error writing file:', err);
        return;
    }
    console.log('File written successfully');
});

Synchrones Schreiben in eine Datei:

try {
    fs.writeFileSync('example.txt', 'Hello, World!');
    console.log('File written successfully');
} catch (err) {
    console.error('Error writing file:', err);
}

Inhalt an Datei anhängen

Asynchrones Anhängen:

fs.appendFile('example.txt', '\nAppending some text', (err) => {
    if (err) {
        console.error('Error appending to file:', err);
        return;
    }
    console.log('Text appended successfully');
});

Synchrones Anhängen:

try {
    fs.appendFileSync('example.txt', '\nAppending some text');
    console.log('Text appended successfully');
} catch (err) {
    console.error('Error appending to file:', err);
}

Datei löschen

Asynchrones Löschen von Dateien:

fs.unlink('example.txt', (err) => {
    if (err) {
        console.error('Error deleting file:', err);
        return;
    }
    console.log('File deleted successfully');
});

Synchrones Löschen von Dateien:

try {
    fs.unlinkSync('example.txt');
    console.log('File deleted successfully');
} catch (err) {
    console.error('Error deleting file:', err);
}

Verzeichnis erstellen

Asynchrones Erstellen von Verzeichnissen:

fs.mkdir('new_directory', (err) => {
    if (err) {
        console.error('Error creating directory:', err);
        return;
    }
    console.log('Directory created successfully');
});

Synchrones Erstellen von Verzeichnissen:

try {
    fs.mkdirSync('new_directory');
    console.log('Directory created successfully');
} catch (err) {
    console.error('Error creating directory:', err);
}

Verzeichnisinhalte lesen

Asynchrones Lesen von Verzeichnisinhalten:

fs.readdir('new_directory', (err, files) => {
    if (err) {
        console.error('Error reading directory:', err);
        return;
    }
    console.log('Directory contents:', files);
});

Synchrones Lesen von Verzeichnisinhalten:

try {
    const files = fs.readdirSync('new_directory');
    console.log('Directory contents:', files);
} catch (err) {
    console.error('Error reading directory:', err);
}

Prüfen, ob Datei oder Verzeichnis existiert

Asynchrone Prüfung:

fs.access('example.txt', fs.constants.F_OK, (err) => {
    if (err) {
        console.log('File does not exist');
    } else {
        console.log('File exists');
    }
});

Synchrone Prüfung:

try {
    fs.accessSync('example.txt', fs.constants.F_OK);
    console.log('File exists');
} catch (err) {
    console.log('File does not exist');
}

Erweiterte Nutzung

1. Dateistreams

Dateistreams können verwendet werden, um große Dateien effizient zu lesen und zu schreiben, ohne die gesamte Datei auf einmal in den Speicher zu laden.

Dateistream lesen:

const fs = require('fs');

const readableStream = fs.createReadStream('large_file.txt', 'utf8');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk);
});

readableStream.on('end', () => {
    console.log('No more data.');
});

Dateistream schreiben:

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.write('Hello, ');
writableStream.write('World!\n');

writableStream.end();

writableStream.on('finish', () => {
    console.log('All writes are now complete.');
});

2. Dateisystemstatistiken

Sie könnenfs.statoderfs.lstatverwenden, um Statistiken für eine Datei oder ein Verzeichnis abzurufen.

Statistiken asynchron abrufen:

fs.stat('example.txt', (err, stats) => {
    if (err) {
        console.error('Error getting stats:', err);
        return;
    }
    console.log('Is file?', stats.isFile());
    console.log('Is directory?', stats.isDirectory());
    console.log('Size:', stats.size);
});

Statistiken synchron abrufen:

try {
    const stats = fs.statSync('example.txt');
    console.log('Is file?', stats.isFile());
    console.log('Is directory?', stats.isDirectory());
    console.log('Size:', stats.size);
} catch (err) {
    console.error('Error getting stats:', err);
}

Als Nächstes schauen wir uns die Dateisystemmethoden von Node.js genauer an.

Datei öffnen

Syntax

Die folgende Syntax dient zum Öffnen einer Datei im asynchronen Modus:

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

Parameters

Die Parameter werden wie folgt beschrieben:

path- path: Der Pfad der Datei.
flags- flags: Das Verhalten beim Öffnen der Datei. Siehe unten für bestimmte Werte.
mode- mode: Legt den Dateimodus (Berechtigungen) fest. Die Standardberechtigung für die Dateierstellung ist 0666 (lesbar und schreibbar).
callback- callback: Die Callback-Funktion mit zwei Parametern wie: callback(err, fd).

Der Parameter flags kann die folgenden Werte haben:

Flag	Beschreibung
r	Öffnet die Datei im Nur-Lese-Modus. Die Datei muss vorhanden sein. Wenn die Datei nicht vorhanden ist, wird eine Ausnahme ausgelöst.
r+	Öffnet die Datei im Lese-/Schreibmodus. Die Datei muss vorhanden sein.
rs	Öffnet die Datei synchron im Nur-Lese-Modus. Dies ist eine blockierende Operation, kann jedoch auf einigen Betriebssystemen eine bessere Stabilität bieten.
rs+	Öffnet die Datei synchron im Lese-/Schreibmodus. Dies ist eine blockierende Operation, kann aber auf einigen Betriebssystemen bessere Stabilität bieten.
w	Öffnet die Datei im Nur-Schreibmodus. Wenn die Datei nicht existiert, wird sie erstellt; wenn die Datei existiert, wird sie abgeschnitten.
wx	Ähnlich wie 'w', schlägt aber fehl, wenn der Pfad existiert.
w+	Öffnet die Datei im Lese-/Schreibmodus. Wenn die Datei nicht existiert, wird sie erstellt; wenn die Datei existiert, wird sie abgeschnitten.
wx+	Ähnlich wie 'w+', schlägt aber fehl, wenn der Pfad existiert.
a	Öffnet die Datei im Anhängemodus. Wenn die Datei nicht existiert, wird sie erstellt.
ax	Ähnlich wie 'a', schlägt aber fehl, wenn der Pfad existiert.
a+	Öffnet die Datei im Lese- und Anhängemodus. Wenn die Datei nicht existiert, wird sie erstellt.
ax+	Ähnlich wie 'a+', schlägt aber fehl, wenn der Pfad existiert.

Beispiel

Als Nächstes erstellen wir eine Datei file.js und öffnen input.txt zum Lesen und Schreiben. Der Code lautet wie folgt:

var fs = require("fs");

// 异步打开文件
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
  console.log("文件打开成功！");     
});

Die Ausgabe des obigen Codes lautet:

$ node file.js 
准备打开文件！
文件打开成功！

Dateiinformationen abrufen

Syntax

Das Folgende ist die Syntax zum Abrufen von Dateiinformationen im asynchronen Modus:

fs.stat(path, callback)

Parameters

Die Parameter werden wie folgt beschrieben:

path- path: Der Dateipfad.
callback- callback: Die Callback-Funktion mit zwei Parametern, wie zum Beispiel: (err, stats),statsstats ist ein fs.Stats-Objekt.

Nachdem fs.stat(path) ausgeführt wurde, wird eine Instanz der Klasse Stats an ihre Callback-Funktion zurückgegeben. Sie können die von der Klasse Stats bereitgestellten Methoden verwenden, um Dateiattribute zu bestimmen. Zum Beispiel, um zu prüfen, ob es sich um eine Datei handelt:

var fs = require('fs');

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

Die Methoden in der Klasse Stats sind:

Methode	Beschreibung
stats.isFile()	Gibt true zurück, wenn es sich um eine Datei handelt, andernfalls false.
stats.isDirectory()	Gibt true zurück, wenn es sich um ein Verzeichnis handelt, andernfalls false.
stats.isBlockDevice()	Gibt true zurück, wenn es ein Blockgerät ist, andernfalls false.
stats.isCharacterDevice()	Gibt true zurück, wenn es ein Zeichengerät ist, andernfalls false.
stats.isSymbolicLink()	Gibt true zurück, wenn es ein symbolischer Link ist, andernfalls false.
stats.isFIFO()	Gibt true zurück, wenn es ein FIFO ist, andernfalls false. FIFO ist ein spezieller Typ einer Befehlspipe unter UNIX.
stats.isSocket()	Gibt true zurück, wenn es ein Socket ist, andernfalls false.

Beispiel

Als Nächstes erstellen wir eine Datei file.js. Der Code lautet wie folgt:

var fs = require("fs");

console.log("准备打开文件！");
fs.stat('input.txt', function (err, stats) {
   if (err) {
       return console.error(err);
   }
   console.log(stats);
   console.log("读取文件信息成功！");
   
   // 检测文件类型
   console.log("是否为文件(isFile) ? " + stats.isFile());
   console.log("是否为目录(isDirectory) ? " + stats.isDirectory());    
});

Die Ausgabe des obigen Codes lautet:

$ node file.js 
准备打开文件！
{ 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) }
读取文件信息成功！
是否为文件(isFile) ? true
是否为目录(isDirectory) ? false

Datei schreiben

Syntax

Das Folgende ist die Syntax zum Schreiben in eine Datei im asynchronen Modus:

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

writeFile öffnet die Datei direkt mit dem Standard-Flag vonwmode, wenn die Datei also existiert, überschreibt der von dieser Methode geschriebene Inhalt den alten Dateiinhalt.

Parameters

Die Parameter werden wie folgt beschrieben:

file- file: Der Dateiname oder Dateideskriptor.
data- data: Die in die Datei zu schreibenden Daten, die ein String- oder ein Buffer-Objekt sein können.
options- options: Dieser Parameter ist ein Objekt, das {encoding, mode, flag} enthält. Die Standardkodierung ist utf8, mode ist 0666 und flag ist 'w'.
callback- callback: Die Callback-Funktion enthält nur den Fehlerparameter (err), der bei einem Schreibfehler zurückgegeben wird.

Beispiel

Als Nächstes erstellen wir eine Datei file.js. Der Code lautet wie folgt:

var fs = require("fs");

console.log("准备写入文件");
fs.writeFile('input.txt', '我是通 过fs.writeFile 写入文件的内容',  function(err) {
   if (err) {
       return console.error(err);
   }
   console.log("数据写入成功！");
   console.log("--------我是分割线-------------")
   console.log("读取写入的数据！");
   fs.readFile('input.txt', function (err, data) {
      if (err) {
         return console.error(err);
      }
      console.log("异步读取文件数据: " + data.toString());
   });
});

Die Ausgabe des obigen Codes lautet:

$ node file.js 
准备写入文件
数据写入成功！
--------我是分割线-------------
读取写入的数据！
异步读取文件数据: 我是通 过fs.writeFile 写入文件的内容

Datei lesen

Syntax

Das Folgende ist die Syntax zum Lesen von Dateien im asynchronen Modus:

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

Diese Methode verwendet einen Dateideskriptor, um die Datei zu lesen.

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

fd- Der von der Methode fs.open() zurückgegebene Dateideskriptor.
buffer- Der Puffer, in den die Daten geschrieben werden.
offset- Der Schreiboffset im Puffer.
length- Die Anzahl der Bytes, die aus der Datei gelesen werden sollen.
position- Die Startposition zum Lesen der Datei. Wenn der Wert von position null ist, beginnt das Lesen an der aktuellen Position des Dateizeigers.
callback- Callback-Funktion mit drei Parametern err, bytesRead, buffer. err ist die Fehlermeldung, bytesRead gibt die Anzahl der gelesenen Bytes an, und buffer ist das Buffer-Objekt.

Beispiel

Der Inhalt der Datei input.txt ist:

Example官网地址：www.example.com

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");
var buf = new Buffer.alloc(1024);

console.log("准备打开已存在的文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("准备读取文件：");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + "  字节被读取");
      
      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
准备打开已存在的文件！
文件打开成功！
准备读取文件：
42  字节被读取
Example官网地址：www.example.com

Datei schließen

Syntax

Das Folgende ist die Syntax zum Schließen einer Datei im asynchronen Modus:

fs.close(fd, callback)

Diese Methode verwendet einen Dateideskriptor, um die Datei zu lesen.

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

fd- Der von der Methode fs.open() zurückgegebene Dateideskriptor.
callback- Callback-Funktion ohne Parameter.

Beispiel

Der Inhalt der Datei input.txt ist:

Example官网地址：www.example.com

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");
var buf = new Buffer.alloc(1024);

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("准备读取文件！");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }

      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }

      // 关闭文件
      fs.close(fd, function(err){
         if (err){
            console.log(err);
         } 
         console.log("文件关闭成功");
      });
   });
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
准备打开文件！
文件打开成功！
准备读取文件！
Example官网地址：www.example.com
文件关闭成功

Datei kürzen

Syntax

Das Folgende ist die Syntax zum Kürzen einer Datei im asynchronen Modus:

fs.ftruncate(fd, len, callback)

Diese Methode verwendet einen Dateideskriptor, um die Datei zu lesen.

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

fd- Der von der Methode fs.open() zurückgegebene Dateideskriptor.
len- Die Länge, auf die der Dateiinhalt gekürzt wird.
callback- Callback-Funktion ohne Parameter.

Beispiel

Der Inhalt der Datei input.txt ist:

site:www.example.com

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");
var buf = new Buffer.alloc(1024);

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   console.log("截取10字节内的文件内容，超出部分将被去除。");
   
   // 截取文件
   fs.ftruncate(fd, 10, function(err){
      if (err){
         console.log(err);
      } 
      console.log("文件截取成功。");
      console.log("读取相同的文件"); 
      fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
         if (err){
            console.log(err);
         }

         // 仅输出读取的字节
         if(bytes > 0){
            console.log(buf.slice(0, bytes).toString());
         }

         // 关闭文件
         fs.close(fd, function(err){
            if (err){
               console.log(err);
            } 
            console.log("文件关闭成功！");
         });
      });
   });
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
准备打开文件！
文件打开成功！
截取10字节内的文件内容，超出部分将被去除。
文件截取成功。
读取相同的文件
site:www.r
文件关闭成功

Datei löschen

Syntax

Das Folgende ist die Syntax zum Löschen einer Datei:

fs.unlink(path, callback)

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

path- Dateipfad.
callback- Callback-Funktion ohne Parameter.

Beispiel

Der Inhalt der Datei input.txt ist:

site:www.example.com

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");

console.log("准备删除文件！");
fs.unlink('input.txt', function(err) {
   if (err) {
       return console.error(err);
   }
   console.log("文件删除成功！");
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
准备删除文件！
文件删除成功！

Überprüfen Sie dann die Datei input.txt erneut und stellen Sie fest, dass sie nicht mehr existiert.

Verzeichnis erstellen

Syntax

Das Folgende ist die Syntax zum Erstellen eines Verzeichnisses:

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

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

path- Dateipfad.
Der Parameter options kann Folgendes sein:
- recursive – Ob das Verzeichnis rekursiv erstellt werden soll, standardmäßig false.
- mode– Legt die Verzeichnisberechtigungen fest, standardmäßig 0777.
callback- Callback-Funktion ohne Parameter.

Beispiel

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");
// tmp 目录必须存在
console.log("创建目录 /tmp/test/");
fs.mkdir("/tmp/test/",function(err){
   if (err) {
       return console.error(err);
   }
   console.log("目录创建成功。");
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
创建目录 /tmp/test/
目录创建成功。

Sie können den Parameter recursive: true hinzufügen, unabhängig davon, ob die zu erstellenden Verzeichnisse /tmp und /tmp/a bereits existieren:

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

Verzeichnis lesen

Syntax

Das Folgende ist die Syntax zum Lesen eines Verzeichnisses:

fs.readdir(path, callback)

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

path- Dateipfad.
callback– Callback-Funktion, die zwei Parameter hat: err, files. err ist die Fehlermeldung, und files ist eine Array-Liste der Dateien im Verzeichnis.

Beispiel

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");

console.log("查看 /tmp 目录");
fs.readdir("/tmp/",function(err, files){
   if (err) {
       return console.error(err);
   }
   files.forEach( function (file){
       console.log( file );
   });
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
查看 /tmp 目录
input.out
output.out
test
test.txt

Verzeichnis löschen

Syntax

Das Folgende ist die Syntax zum Löschen eines Verzeichnisses:

fs.rmdir(path, callback)

Parameters

Die Anweisungen zur Verwendung der Parameter lauten wie folgt:

path- Dateipfad.
callback- Callback-Funktion ohne Parameter.

Beispiel

Als Nächstes erstellen wir die Datei file.js mit folgendem Code:

var fs = require("fs");
// 执行前创建一个空的 /tmp/test 目录
console.log("准备删除目录 /tmp/test");
fs.rmdir("/tmp/test",function(err){
   if (err) {
       return console.error(err);
   }
   console.log("读取 /tmp 目录");
   fs.readdir("/tmp/",function(err, files){
      if (err) {
          return console.error(err);
      }
      files.forEach( function (file){
          console.log( file );
      });
   });
});

Das Ausführungsergebnis des obigen Codes ist wie folgt:

$ node file.js 
准备删除目录 /tmp/test
读取 /tmp 目录
……

Referenzhandbuch für Dateimodul-Methoden

Das Folgende ist eine Liste der Methoden für das Node.js-Dateimodul:

Laufende Nummer	Methode & Beschreibung
1	fs.rename(oldPath, newPath, callback) Asynchrones rename(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
2	fs.ftruncate(fd, len, callback) Asynchrones ftruncate(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
3	fs.ftruncateSync(fd, len) Synchrones ftruncate()
4	fs.truncate(path, len, callback) Asynchrones truncate(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
5	fs.truncateSync(path, len) Synchrones truncate()
6	fs.chown(path, uid, gid, callback) Asynchrones chown(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
7	fs.chownSync(path, uid, gid) Synchrones chown()
8	fs.fchown(fd, uid, gid, callback) Asynchrones fchown(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
9	fs.fchownSync(fd, uid, gid) Synchrones fchown()
10	fs.lchown(path, uid, gid, callback) Asynchrones lchown(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
11	fs.lchownSync(path, uid, gid) Synchrones lchown()
12	fs.chmod(path, mode, callback) Asynchrones chmod(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
13	fs.chmodSync(path, mode) Synchrones chmod().
14	fs.fchmod(fd, mode, callback) Asynchrones fchmod(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
15	fs.fchmodSync(fd, mode) Synchrones fchmod().
16	fs.lchmod(path, mode, callback) Asynchrones lchmod(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen. Nur unter Mac OS X verfügbar.
17	fs.lchmodSync(path, mode) Synchrones lchmod().
18	fs.stat(path, callback) Asynchrones stat(). Die Callback-Funktion hat zwei Parameter err, stats. stats ist ein fs.Stats-Objekt.
19	fs.lstat(path, callback) Asynchrones lstat(). Callback-Funktion hat zwei Parameter err, stats. stats ist ein fs.Stats-Objekt.
20	fs.fstat(fd, callback) Asynchrones fstat(). Callback-Funktion hat zwei Parameter err, stats. stats ist ein fs.Stats-Objekt.
21	fs.statSync(path) Synchrones stat(). Gibt eine Instanz von fs.Stats zurück.
22	fs.lstatSync(path) Synchrones lstat(). Gibt eine Instanz von fs.Stats zurück.
23	fs.fstatSync(fd) Synchrones fstat(). Gibt eine Instanz von fs.Stats zurück.
24	fs.link(srcpath, dstpath, callback) Asynchrones link(). Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
25	fs.linkSync(srcpath, dstpath) Synchrones link().
26	fs.symlink(srcpath, dstpath[, type], callback) Asynchrones symlink(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen. Der Parameter type kann auf 'dir', 'file' oder 'junction' gesetzt werden (Standard ist 'file').
27	fs.symlinkSync(srcpath, dstpath[, type]) Synchrones symlink().
28	fs.readlink(path, callback) Asynchrones readlink(). Die Callback-Funktion hat zwei Parameter err, linkString.
29	fs.realpath(path[, cache], callback) Asynchrones realpath(). Die Callback-Funktion hat zwei Parameter err, resolvedPath.
30	fs.realpathSync(path[, cache]) Synchrones realpath(). Gibt den absoluten Pfad zurück.
31	fs.unlink(path, callback) Asynchrones unlink(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
32	fs.unlinkSync(path) Synchrones unlink().
33	fs.rmdir(path, callback) Asynchrones rmdir(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
34	fs.rmdirSync(path) Synchrones rmdir().
35	fs.mkdir(path[, mode], callback) Asynchrones mkdir(2). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen. Die Zugriffsberechtigung ist standardmäßig 0777.
36	fs.mkdirSync(path[, mode]) Synchrones mkdir().
37	fs.readdir(path, callback) Asynchrones readdir(3). Liest den Inhalt eines Verzeichnisses.
38	fs.readdirSync(path) Synchrone readdir(). Gibt eine Array-Liste von Dateien zurück.
39	fs.close(fd, callback) Asynchrones close(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
40	fs.closeSync(fd) Synchrone close().
41	fs.open(path, flags[, mode], callback) Öffnet eine Datei asynchron.
42	fs.openSync(path, flags[, mode]) Synchrone Version von fs.open().
43	fs.utimes(path, atime, mtime, callback)
44	fs.utimesSync(path, atime, mtime) Ändern Sie die Dateizeitstempel der Datei, die durch den angegebenen Dateipfad spezifiziert wird.
45	fs.futimes(fd, atime, mtime, callback)
46	fs.futimesSync(fd, atime, mtime) Ändern Sie die Dateizeitstempel der durch den Dateideskriptor angegebenen Datei.
47	fs.fsync(fd, callback) Asynchrones fsync. Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.
48	fs.fsyncSync(fd) Synchrones fsync.
49	fs.write(fd, buffer, offset, length[, position], callback) Schreiben Sie den Pufferinhalt in die durch den Dateideskriptor angegebene Datei.
50	fs.write(fd, data[, position[, encoding]], callback) Schreibe Dateiinhalt über den Dateideskriptor fd.
51	fs.writeSync(fd, buffer, offset, length[, position]) Synchrone Version von fs.write().
52	fs.writeSync(fd, data[, position[, encoding]]) Synchrone Version von fs.write().
53	fs.read(fd, buffer, offset, length, position, callback) Lies Dateiinhalt über den Dateideskriptor fd.
54	fs.readSync(fd, buffer, offset, length, position) Synchrone Version von fs.read.
55	fs.readFile(filename[, options], callback) Dateiinhalte asynchron lesen.
56	fs.readFileSync(filename[, options])
57	fs.writeFile(filename, data[, options], callback) Dateiinhalte asynchron schreiben.
58	fs.writeFileSync(filename, data[, options]) Synchrone Version von fs.writeFile.
59	fs.appendFile(filename, data[, options], callback) Dateiinhalte asynchron anhängen.
60	fs.appendFileSync(filename, data[, options]) Die synchrone Version von fs.appendFile.
61	fs.watchFile(filename[, options], listener) Dateiänderungen überwachen.
62	fs.unwatchFile(filename[, listener]) Beendet die Überwachung von filename auf Änderungen.
63	fs.watch(filename[, options][, listener]) Überwacht Änderungen an filename, wobei es sich um eine Datei oder ein Verzeichnis handeln kann. Gibt ein fs.FSWatcher-Objekt zurück.
64	fs.exists(path, callback) Überprüft, ob der angegebene Pfad existiert.
65	fs.existsSync(path) Synchrone Version von fs.exists.
66	fs.access(path[, mode], callback) Prüft die Benutzerberechtigungen für den angegebenen Pfad.
67	fs.accessSync(path[, mode]) Synchrone Version von fs.access.
68	fs.createReadStream(path[, options]) Gibt ein ReadStream-Objekt zurück.
69	fs.createWriteStream(path[, options]) Gibt ein WriteStream-Objekt zurück.
70	fs.symlink(srcpath, dstpath[, type], callback) Asynchrones symlink(). Die Callback-Funktion hat keine Parameter, kann aber eine Ausnahme auslösen.

Weitere Informationen finden Sie in der Beschreibung des Dateimoduls auf der offiziellen Website:Dateisystem。

Weitere Erweiterungen

Node.js Anwendung

Node.js-Dateisystem

Das fs-Modul importieren

Asynchron und synchron

Beispiel

Beispiel

Datei schreiben

Inhalt an Datei anhängen

Datei löschen

Verzeichnis erstellen

Verzeichnisinhalte lesen

Prüfen, ob Datei oder Verzeichnis existiert

Erweiterte Nutzung

Datei öffnen

Syntax

Parameters

Beispiel

Dateiinformationen abrufen

Syntax

Parameters

Beispiel

Datei schreiben

Syntax

Parameters

Beispiel

Datei lesen

Syntax

Parameters

Beispiel

Datei schließen

Syntax

Parameters

Beispiel

Datei kürzen

Syntax

Parameters

Beispiel

Datei löschen

Syntax

Parameters

Beispiel

Verzeichnis erstellen

Syntax

Parameters

Beispiel

Verzeichnis lesen

Syntax

Parameters

Beispiel

Verzeichnis löschen

Syntax

Parameters

Beispiel

Referenzhandbuch für Dateimodul-Methoden