{"id":52387,"date":"2022-07-12T08:19:45","date_gmt":"2022-07-12T07:19:45","guid":{"rendered":"https:\/\/kinsta.com\/de\/?p=52387&post_type=knowledgebase&preview_id=52387"},"modified":"2025-10-01T20:18:18","modified_gmt":"2025-10-01T19:18:18","slug":"nodejs-fs","status":"publish","type":"post","link":"https:\/\/kinsta.com\/de\/blog\/nodejs-fs\/","title":{"rendered":"Das Node.js File System Modul (FS) verstehen"},"content":{"rendered":"

JavaScript ist seit langem eine der beliebtesten Skriptsprachen, aber f\u00fcr die serverseitige Entwicklung von Backend-Anwendungen war sie lange Zeit nicht die beste Wahl. Dann kam Node.js auf, mit dem sich serverseitige, ereignisgesteuerte, leichtgewichtige Anwendungen erstellen lassen, die auf der Programmiersprache JavaScript basieren.<\/p>\n

Node.js ist eine Open-Source-JavaScript-Laufzeitumgebung<\/a>, die kostenlos heruntergeladen und auf allen g\u00e4ngigen Betriebssystemen (Windows, Mac, Linux) installiert werden kann. Node.js ist in den letzten Jahren bei App-Entwicklern immer beliebter<\/a> geworden und hat viele neue Besch\u00e4ftigungsm\u00f6glichkeiten<\/a> f\u00fcr JavaScript-Entwickler\/innen geschaffen, die eine Spezialisierung suchen.<\/p>\n\n

In diesem Artikel werden wir lernen, wie man das Dateisystem mit Node.js verwaltet. Mit den Node.js-APIs kannst du m\u00fchelos mit dem Dateisystem interagieren und viele komplexe Operationen durchf\u00fchren. Wenn du wei\u00dft, wie du damit umgehst, wird deine Produktivit\u00e4t steigen.<\/p>\n

Lass uns eintauchen!<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Voraussetzungen f\u00fcr das Verst\u00e4ndnis des Node.js-Dateisystems<\/h2>\n

Die wichtigste Voraussetzung ist die Installation von Node.js auf deinem Betriebssystem. Da Node.js keine komplexe Hardware ben\u00f6tigt, kannst du Node.js einfach herunterladen und auf deinem Computer installieren<\/a>.<\/p>\n

Um mit Node.js-Modulen wie dem Dateisystem (auch „FS“ oder „fs“ genannt) arbeiten zu k\u00f6nnen, ist es hilfreich, wenn du auch Grundkenntnisse in JavaScript<\/a> hast. Ein grundlegendes Verst\u00e4ndnis von JavaScript-Funktionen, Callback-Funktionen und Promises wird dir helfen, dieses Thema noch schneller in den Griff zu bekommen<\/a>.<\/p>\n

Node.js Dateisystem-Modul<\/h2>\n

Die Arbeit mit Dateien und Verzeichnissen geh\u00f6rt zu den Grundbed\u00fcrfnissen einer Full-Stack-Anwendung. Deine Nutzer\/innen wollen vielleicht Bilder, Lebensl\u00e4ufe oder andere Dateien auf einen Server hochladen. Gleichzeitig muss deine Anwendung vielleicht Konfigurationsdateien lesen, Dateien verschieben oder sogar ihre Berechtigungen programmatisch \u00e4ndern.<\/p>\n

Das Node.js-Dateisystemmodul deckt all diese Anforderungen ab. Es bietet mehrere APIs, um nahtlos mit den Dateisystemen zu interagieren. Die meisten APIs sind mit Optionen und Flags anpassbar. Au\u00dferdem kannst du mit ihnen sowohl synchrone als auch asynchrone Dateioperationen durchf\u00fchren.<\/p>\n

Bevor wir in das Dateisystemmodul eintauchen, werfen wir einen Blick darauf, was es mit dem Node.js-Modul auf sich hat.<\/p>\n

Node.js-Module<\/h3>\n

Node.js-Module sind eine Reihe von Funktionen, die als APIs zur Verf\u00fcgung stehen und von einem Verbraucherprogramm genutzt werden k\u00f6nnen. So gibt es zum Beispiel das Modul fs<\/code>, das mit dem Dateisystem interagiert. Ebenso nutzt ein http<\/code> Modul seine Funktionen, um einen Server zu erstellen und viele weitere Operationen auszuf\u00fchren. Node.js bietet eine Vielzahl von Modulen, die viele Low-Level-Funktionen f\u00fcr dich abstrahieren.<\/p>\n

Du kannst auch deine eigenen Module erstellen. Ab Node.js Version 14 kannst du Node.js-Module auf zwei Arten erstellen und verwenden: CommonJS (CJS) und ESM (MJS) Module. Alle Beispiele, die wir in diesem Artikel sehen werden, sind im CJS-Stil gehalten.<\/p>\n

Arbeiten mit Dateien in Node.js<\/h2>\n

Die Arbeit mit Dateien umfasst verschiedene Operationen mit Dateien und Verzeichnissen (Ordnern). Jetzt werden wir jeden dieser Vorg\u00e4nge anhand von Beispielen im Quellcode kennenlernen. Bitte \u00f6ffne deinen bevorzugten Quellcode-Editor<\/a> und probiere sie aus, w\u00e4hrend du mitliest.<\/p>\n

Importiere zun\u00e4chst das Modul fs<\/code> in deine Quelldatei, um mit den Methoden des Dateisystems arbeiten zu k\u00f6nnen. Im CJS-Stil verwenden wir die Methode require<\/code>, um eine Methode aus einem Modul zu importieren. Um also die Methoden des Moduls fs zu importieren und zu verwenden, musst du Folgendes tun:<\/p>\n

const { writeFile } = require('fs\/promises');<\/code><\/pre>\n
Beachte auch, dass wir die Methode writeFile<\/code> aus dem Paket fs\/promises<\/code> importieren. Wir wollen die promisified-Methoden verwenden, weil sie die neuesten sind und weil sie mit den async\/await-Schl\u00fcsselw\u00f6rtern und weniger Code einfach zu verwenden sind. Andere Alternativen sind die synchronen Methoden und die Callback-Funktionen, die wir sp\u00e4ter sehen werden.<\/p>\n
Wie man eine Datei erstellt und in eine Datei schreibt<\/h3>\n
Du kannst eine Datei auf drei Arten erstellen und in sie schreiben:<\/p>\n
    \n
  1. Verwendung der Methode writeFile<\/code><\/li>\n
  2. Verwendung der appendFile<\/code> Methode<\/li>\n
  3. Die Methode openFile<\/code> verwenden<\/li>\n<\/ol>\n
    Diese Methoden akzeptieren einen Dateipfad und die Daten als Inhalt, die in die Datei geschrieben werden sollen. Wenn die Datei existiert, ersetzen sie den Inhalt in der Datei. Andernfalls erstellen sie eine neue Datei mit dem Inhalt.<\/p>\n
    1. Verwendung der Methode writeFile<\/h4>\n
    Der folgende Codeschnipsel zeigt die Verwendung der Methode writeFile<\/code>. Beginne damit, eine Datei mit dem Namen createFile.js<\/strong> zu erstellen, indem du das folgende Snippet verwendest:<\/p>\n
    const { writeFile } = require('fs\/promises');\nasync function writeToFile(fileName, data) {\n  try {\n    await writeFile(fileName, data);\n    console.log(`Wrote data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to write the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Beachte, dass wir das Schl\u00fcsselwort await<\/code> verwenden, um die Methode aufzurufen, da sie ein JavaScript-Versprechen zur\u00fcckgibt. Ein erfolgreiches Versprechen erstellt\/schreibt die Datei. Wir haben einen try-catch-Block, um Fehler zu behandeln, falls das Versprechen abgelehnt wird.<\/p>\n
    Jetzt k\u00f6nnen wir die Funktion writeToFile<\/code> aufrufen:<\/p>\n
    writeToFile('friends.txt', 'Bob');<\/code><\/pre>\n
    Als N\u00e4chstes \u00f6ffnest du eine Eingabeaufforderung oder ein Terminal und f\u00fchrst das obige Programm mit folgendem Befehl aus:<\/p>\n
    node createFile.js<\/code><\/pre>\n
    Es erstellt eine neue Datei namens friends.txt<\/strong> mit einer Zeile, in der einfach steht:<\/p>\n
    Bob<\/code><\/pre>\n
    2. Verwenden der appendFile-Methode<\/h4>\n
    Wie der Name schon sagt, wird diese Methode haupts\u00e4chlich zum Anh\u00e4ngen und Bearbeiten einer Datei verwendet. Du kannst dieselbe Methode aber auch verwenden, um eine Datei zu erstellen.<\/p>\n
    Sieh dir die folgende Funktion an. Wir verwenden die Methode appendFile<\/code> mit dem Flag w<\/code>, um eine Datei zu schreiben. Das Standardflag f\u00fcr das Anh\u00e4ngen an eine Datei ist a<\/code>:<\/p>\n
    const { appendFile} = require('fs\/promises');\n\nasync function appendToFile(fileName, data) {\n  try {\n    await appendFile(fileName, data, { flag: 'w' });\n    console.log(`Appended data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to append the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Jetzt kannst du die obige Funktion wie folgt aufrufen:<\/p>\n
    appendToFile('activities.txt', 'Skiing');<\/code><\/pre>\n
    Als N\u00e4chstes kannst du den Code in der Node.js-Umgebung mit dem Befehl node ausf\u00fchren, wie wir bereits gesehen haben. Dadurch wird eine Datei namens activities.txt<\/strong> mit dem Inhalt Skiing<\/code> erstellt.<\/p>\n
    3. Die Methode open verwenden<\/h4>\n
    Die letzte Methode, die wir lernen werden, um eine Datei zu erstellen und in sie zu schreiben, ist die open<\/code> Methode. Du kannst eine Datei mit dem Flag w<\/code> (f\u00fcr „write“) \u00f6ffnen:<\/p>\n
    const { open} = require('fs\/promises');\n\nasync function openFile(fileName, data) {\n  try {\n    const file = await open(fileName, 'w');\n    await file.write(data);\n    console.log(`Opened file ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to open the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Rufe nun die Funktion openFile<\/code> mit auf:<\/p>\n
    openFile('tasks.txt', 'Do homework');<\/code><\/pre>\n
    Wenn du das Skript mit dem Befehl node ausf\u00fchrst, wird eine Datei namens tasks.txt<\/strong> mit dem urspr\u00fcnglichen Inhalt erstellt:<\/p>\n
    Do homework<\/code><\/pre>\n
    Wie man eine Datei liest<\/h3>\n
    Nachdem wir nun wissen, wie man eine Datei erstellt und in sie schreibt, wollen wir nun lernen, wie man den Inhalt einer Datei liest. Dazu verwenden wir die Methode readFile<\/code> aus dem Modul Dateisystem.<\/p>\n
    Erstelle eine Datei namens readThisFile.js<\/strong> mit dem folgenden Code:<\/p>\n
    \/\/ readThisFile.js\nconst { readFile } = require('fs\/promises');\nasync function readThisFile(filePath) {\n  try {\n    const data = await readFile(filePath);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(`Got an error trying to read the file: {error.message}`);\n }\n}<\/code><\/pre>\n
    Jetzt lesen wir alle drei Dateien, die wir erstellt haben, indem wir die Funktion readThisFile<\/code> aufrufen:<\/p>\n
    readThisFile('activities.txt');\nreadThisFile('friends.txt');\nreadThisFile('tasks.txt');<\/code><\/pre>\n
    Zum Schluss f\u00fchrst du das Skript mit dem folgenden Node-Befehl aus:<\/p>\n
    node readThisFile.js<\/code><\/pre>\n
    Du solltest die folgende Ausgabe in der Konsole sehen:<\/p>\n
    Skiing\nDo homework\nBob<\/code><\/pre>\n
    Ein Punkt, den du hier beachten solltest: Die Methode readFile<\/code> liest die Datei asynchron. Das bedeutet, dass die Reihenfolge, in der du die Datei liest, und die Reihenfolge, in der du eine Antwort in der Konsole ausgeben l\u00e4sst, nicht unbedingt \u00fcbereinstimmen. Du musst die synchrone Version der Methode readFile<\/code> verwenden, um die Reihenfolge einzuhalten. Das werden wir hier gleich sehen.<\/p>\n
    Wie man eine Datei umbenennt<\/h3>\n
    Um eine Datei umzubenennen, verwendest du die Methode rename aus dem fs-Modul. Erstellen wir eine Datei namens rename-me.txt<\/strong>. Wir werden diese Datei programmatisch umbenennen.<\/p>\n
    Erstelle eine Datei namens renameFile.js<\/strong> mit dem folgenden Code:<\/p>\n
    const { rename } = require('fs\/promises');\n\nasync function renameFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Renamed ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to rename the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Wie du vielleicht bemerkt hast, ben\u00f6tigt die Methode rename zwei Argumente. Das eine ist die Datei mit dem Quellnamen und das andere ist der Zielname.<\/p>\n
    Rufen wir nun die obige Funktion auf, um die Datei umzubenennen:<\/p>\n
    const oldName = \"rename-me.txt\";\nconst newName = \"renamed.txt\";\nrenameFile(oldName, newName);<\/code><\/pre>\n
    Wie zuvor f\u00fchrst du die Skriptdatei mit dem Befehl node aus, um die Datei umzubenennen:<\/p>\n
    node renameFile.js<\/code><\/pre>\n
    Wie man eine Datei verschiebt<\/h3>\n
    Das Verschieben einer Datei von einem Verzeichnis in ein anderes ist \u00e4hnlich wie das Umbenennen des Pfades. Wir k\u00f6nnen also auch die Methode rename<\/code> verwenden, um Dateien zu verschieben.<\/p>\n
    Legen wir zwei Ordner an, von<\/strong> und nach<\/strong>. Dann erstellen wir eine Datei namens move-me.txt <\/strong>im from-Ordner<\/strong>.<\/p>\n
    Als N\u00e4chstes schreiben wir den Code zum Verschieben der Datei move-me.txt<\/strong>. Erstelle eine Datei namens moveFile.js<\/strong> mit folgendem Codeausschnitt:<\/p>\n
    const { rename } = require('fs\/promises');\nconst { join } = require('path');\nasync function moveFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Moved ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to move the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Wie du sehen kannst, verwenden wir die Methode rename<\/code> genau wie zuvor. Aber warum m\u00fcssen wir die Methode join<\/code> aus dem Modul path<\/code> importieren (ja, der Pfad ist ein weiteres wichtiges Modul von Node.js)?<\/p>\n
    Die Methode join<\/code> wird verwendet, um mehrere angegebene Pfadsegmente zu einem Pfad zu verbinden. Wir werden sie verwenden, um den Pfad von Quell- und Zieldatei zu bilden:<\/p>\n
    const fromPath = join(__dirname, \"from\", \"move-me.txt\");\nconst destPath = join(__dirname, \"to\", \"move-me.txt\");\nmoveFile(fromPath, destPath);<\/code><\/pre>\n
    Und das war’s! Wenn du das Skript moveFile.js<\/strong> ausf\u00fchrst, wirst du sehen, dass die Datei move-me.txt<\/strong> in den Ordner to<\/strong> verschoben wurde.<\/p>\n
    Wie man eine Datei kopiert<\/h3>\n
    Wir verwenden die Methode copyFile<\/code> aus dem Modul fs<\/code>, um eine Datei von der Quelle zum Ziel zu kopieren.<\/p>\n
    Sieh dir den folgenden Codeschnipsel an:<\/p>\n
    const { copyFile } = require('fs\/promises');\nconst { join } = require('path');\nasync function copyAFile(from, to) {\n  try {\n    await copyFile(from, to);\n    console.log(`Copied ${from} to ${to}`);\n  } catch (err) {\n    console.error(`Got an error trying to copy the file: ${err.message}`);\n  }\n}<\/code><\/pre>\n
    Jetzt kannst du die obige Funktion mit aufrufen:<\/p>\n
    copyAFile('friends.txt', 'friends-copy.txt');<\/code><\/pre>\n
    Sie kopiert den Inhalt der friends.txt<\/strong> in die Datei friends-copy.txt<\/strong>.<\/p>\n
    Das ist toll, aber wie kopiert man mehrere Dateien?<\/p>\n
    Du kannst die Promise.all<\/code> API verwenden, um mehrere Versprechen parallel auszuf\u00fchren:<\/p>\n
    async function copyAll(fromDir, toDir, filePaths) {\n  return Promise.all(filePaths.map(filePath => {\n   return copyAFile(join(fromDir, filePath), join(toDir, filePath));\n  }));\n}<\/code><\/pre>\n
    Jetzt kannst du alle Dateipfade angeben, die von einem Verzeichnis in ein anderes kopiert werden sollen:<\/p>\n
    copyFiles('from', 'to', ['copyA.txt', 'copyB.txt']);<\/code><\/pre>\n
    Du kannst diesen Ansatz auch nutzen, um andere Operationen wie das Verschieben, Schreiben und Lesen von Dateien parallel durchzuf\u00fchren zu k\u00f6nnen.<\/p>\n
    Wie man eine Datei l\u00f6scht<\/h3>\n
    Wir verwenden die Methode unlink<\/code>, um eine Datei zu l\u00f6schen:<\/p>\n
    const { unlink } = require('fs\/promises');\nasync function deleteFile(filePath) {\n  try {\n    await unlink(filePath);\n    console.log(`Deleted ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Denke daran, dass du den Pfad zu der Datei angeben musst, um sie zu l\u00f6schen:<\/p>\n
    deleteFile('delete-me.txt');<\/code><\/pre>\n
    Wenn es sich bei dem Pfad um einen Symlink zu einer anderen Datei handelt, hebt die unlink-Methode den Symlink auf, aber die urspr\u00fcngliche Datei bleibt unangetastet. Wir werden sp\u00e4ter noch mehr \u00fcber Symlinks sprechen.<\/p>\n
    So \u00e4nderst du Dateiberechtigungen und -eigentum<\/h3>\n
    Es kann vorkommen, dass du die Dateiberechtigungen programmgesteuert \u00e4ndern m\u00f6chtest. Das kann sehr hilfreich sein, um eine Datei schreibgesch\u00fctzt oder vollst\u00e4ndig zug\u00e4nglich zu machen.<\/p>\n
    Wir werden die Methode chmod<\/code> verwenden, um die Berechtigung einer Datei zu \u00e4ndern:<\/p>\n
    const { chmod } = require('fs\/promises');\nasync function changePermission(filePath, permission) {\n  try {\n    await chmod(filePath, permission);\n    console.log(`Changed permission to ${permission} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change permission: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Wir k\u00f6nnen den Dateipfad und die Erlaubnis-Bitmaske \u00fcbergeben, um die Erlaubnis zu \u00e4ndern.<\/p>\n
    Hier ist der Funktionsaufruf, um die Berechtigung einer Datei auf schreibgesch\u00fctzt zu \u00e4ndern:<\/p>\n
    changePermission('permission.txt', 0o400);<\/code><\/pre>\n
    \u00c4hnlich wie die Berechtigung kannst du auch den Eigent\u00fcmer einer Datei programmatisch \u00e4ndern. Wir verwenden dazu die Methode chown<\/code>:<\/p>\n
    const { chown } = require('fs\/promises');\n\nasync function changeOwnership(filePath, userId, groupId) {\n  try {\n    await chown(filePath, userId, groupId);\n    console.log(`Changed ownership to ${userId}:${groupId} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change ownership: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Dann rufen wir die Funktion mit dem Dateipfad, der Benutzer-ID und der Gruppen-ID auf:<\/p>\n
    changeOwnership('ownership.txt', 1000, 1010);<\/code><\/pre>\n
    Wie man einen Symlink erstellt<\/h3>\n
    Der symbolische Link (auch Symlink genannt)<\/a> ist ein Konzept des Dateisystems, um einen Link zu einer Datei oder einem Ordner zu erstellen. Wir erstellen Symlinks, um Verkn\u00fcpfungen zu einer Zieldatei\/einem Zielordner im Dateisystem zu erstellen. Das Node.js-Modul filesystem<\/code> bietet die Methode symlink<\/code>, um einen symbolischen Link zu erstellen.<\/p>\n
    Um den Symlink zu erstellen, m\u00fcssen wir den Pfad der Zieldatei, den aktuellen Dateipfad und den Typ \u00fcbergeben:<\/p>\n
    const { symlink } = require('fs\/promises');\nconst { join } = require('path');\nasync function createSymlink(target, path, type) {\n  try {\n    await symlink(target, path, type);\n    console.log(`Created symlink to ${target} at ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the symlink: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Wir k\u00f6nnen die Funktion mit aufrufen:<\/p>\n
    createSymlink('join(__dirname, from, symMe.txt)', 'symToFile', 'file');<\/code><\/pre>\n
    Hier haben wir einen Symlink namens symToFile<\/code> erstellt.<\/p>\n
    Wie man \u00c4nderungen an einer Datei beobachtet<\/h3>\n
    Wusstest du, dass du die \u00c4nderungen an einer Datei beobachten kannst? Das ist eine gro\u00dfartige M\u00f6glichkeit, um \u00c4nderungen und Ereignisse zu \u00fcberwachen, besonders wenn du sie nicht erwartest. Du kannst sie aufzeichnen und f\u00fcr sp\u00e4tere \u00dcberpr\u00fcfungen aufzeichnen.<\/p>\n
    Die Methode watch<\/code> ist die beste Methode, um Dateiver\u00e4nderungen zu beobachten. Es gibt eine alternative Methode namens watchFile<\/code>, aber sie ist nicht so leistungsf\u00e4hig wie die Methode watch<\/code>.<\/p>\n
    Bisher haben wir die Methode des Dateisystemmoduls mit den Schl\u00fcsselw\u00f6rtern async\/await verwendet. In diesem Beispiel werden wir sehen, wie die Callback-Funktion verwendet wird.<\/p>\n
    Die Methode watch<\/code> nimmt den Dateipfad und eine Callback-Funktion als Argumente entgegen. Immer, wenn eine Aktivit\u00e4t in der Datei stattfindet, wird die Funktion callback<\/code> aufgerufen.<\/p>\n
    Wir k\u00f6nnen den Parameter event<\/code> nutzen, um weitere Informationen \u00fcber die Aktivit\u00e4ten zu erhalten:<\/p>\n
    const fs = require('fs');\nfunction watchAFile(file) {\n  fs.watch(file, (event, filename) => {\n    console.log(`${filename} file Changed`);\n  });\n}<\/code><\/pre>\n
    Rufe die Funktion auf, indem du einen Dateinamen an watch<\/code> \u00fcbergibst:<\/p>\n
    watchAFile('friends.txt');<\/code><\/pre>\n
    Jetzt erfassen wir automatisch alle Aktivit\u00e4ten in der Datei friends.txt<\/strong>.<\/p>\n
    Arbeiten mit Verzeichnissen (Ordnern) in Node.js<\/h2>\n
    Jetzt wollen wir rausfinden, wie wir mit Verzeichnissen oder Ordnern arbeiten k\u00f6nnen. Viele der Operationen wie Umbenennen, Verschieben und Kopieren \u00e4hneln den Operationen, die wir f\u00fcr Dateien kennen. Bestimmte Methoden und Operationen sind jedoch nur f\u00fcr Verzeichnisse anwendbar.<\/p>\n
    Wie man ein Verzeichnis erstellt<\/h3>\n
    Wir verwenden die Methode mkdir<\/code>, um ein Verzeichnis zu erstellen. Du musst den Verzeichnisnamen als Argument \u00fcbergeben:<\/p>\n
    const { mkdir } = require('fs\/promises');\nasync function createDirectory(path) {\n  try {\n    await mkdir(path);\n    console.log(`Created directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Jetzt k\u00f6nnen wir die Funktion createDirectory<\/code> mit einem Verzeichnispfad aufrufen:<\/p>\n
    createDirectory('new-directory');<\/code><\/pre>\n
    Dadurch wird ein Verzeichnis namens new-directory<\/strong> erstellt.<\/p>\n
    Wie man ein tempor\u00e4res Verzeichnis erstellt<\/h3>\n
    Tempor\u00e4re Verzeichnisse sind keine normalen Verzeichnisse. Sie haben eine besondere Bedeutung f\u00fcr das Betriebssystem. Du kannst ein tempor\u00e4res Verzeichnis mit der Methode mkdtemp()<\/code> erstellen.<\/p>\n
    Lass uns einen tempor\u00e4ren Ordner im tempor\u00e4ren Verzeichnis deines Betriebssystems erstellen. Die Informationen f\u00fcr den Speicherort des tempor\u00e4ren Verzeichnisses erhalten wir von der Methode tmpdir()<\/code> des Moduls os<\/code>:<\/p>\n
    const { mkdtemp } = require('fs\/promises');\nconst { join } = require('path');\nconst { tmpdir } = require('os');\nasync function createTemporaryDirectory(fileName) {\n  try {\n    const tempDirectory = await mkdtemp(join(tmpdir(), fileName));\n    console.log(`Created temporary directory ${tempDirectory}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the temporary directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Rufen wir nun die Funktion mit dem Verzeichnisnamen auf, um es zu erstellen:<\/p>\n
    createTemporaryDirectory('node-temp-file-');<\/code><\/pre>\n
    Beachte, dass Node.js sechs zuf\u00e4llige Zeichen am Ende des erstellten tempor\u00e4ren Ordnernamens anh\u00e4ngt, um ihn eindeutig zu halten.<\/p>\n
    Wie man ein Verzeichnis l\u00f6scht<\/h3>\n
    Du musst die Methode rmdir()<\/code> verwenden, um ein Verzeichnis zu l\u00f6schen:<\/p>\n
    const { rmdir } = require('fs\/promises');\nasync function deleteDirectory(path) {\n  try {\n    await rmdir(path);\n    console.log(`Deleted directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Als N\u00e4chstes rufst du die oben genannte Funktion auf und \u00fcbergibst den Pfad des Ordners, den du l\u00f6schen m\u00f6chtest:<\/p>\n
    deleteDirectory('new-directory-renamed');<\/code><\/pre>\n
    Synchrone vs. asynchrone APIs<\/h2>\n
    Bis jetzt haben wir viele Beispiele f\u00fcr Dateisystemmethoden gesehen, die alle asynchron verwendet werden. Es kann jedoch sein, dass du einige Vorg\u00e4nge synchron abwickeln musst.<\/p>\n
    Ein Beispiel f\u00fcr eine synchrone Operation ist das Lesen mehrerer Dateien nacheinander. Das Modul fs<\/code> verf\u00fcgt \u00fcber eine Methode namens readFileSync()<\/code>, die dies erm\u00f6glicht:<\/p>\n
    const { readFileSync } = require('fs');\nfunction readFileSynchronously(path) {\n  try {\n    const data = readFileSync(path);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(error);\n  }\n}<\/code><\/pre>\n
    Beachte, dass die Methode readFileSync()<\/code> aus dem Paket „fs\/promises“ nicht ben\u00f6tigt wird. Das liegt daran, dass die Methode nicht asynchron ist. Du kannst die obige Funktion also mit aufrufen:<\/p>\n
    readFileSynchronously('activities.txt');\nreadFileSynchronously('friends.txt');\nreadFileSynchronously('tasks.txt');<\/code><\/pre>\n
    In diesem Fall werden alle oben genannten Dateien in der Reihenfolge gelesen, in der die Funktionen aufgerufen wurden.<\/p>\n
    Das Node.js-Dateisystemmodul bietet eine synchrone Methode f\u00fcr andere Operationen wie die Leseoperation. Verwende sie mit Bedacht und nur bei Bedarf. Die asynchronen Methoden sind f\u00fcr die parallele Ausf\u00fchrung viel hilfreicher.<\/p>\n
    Umgang mit Fehlern<\/h2>\n
    Wie jeder Programmierer wei\u00df, musst du mit Fehlern rechnen und darauf vorbereitet sein, sie zu beheben<\/a>, wenn du eine Datei- oder Verzeichnisoperation ausf\u00fchrst. Was ist, wenn die Datei nicht gefunden wird oder du keine Berechtigung hast, in eine Datei zu schreiben? Es kann (und wird wahrscheinlich) viele F\u00e4lle geben, in denen du auf einen Fehler sto\u00dfen k\u00f6nntest.<\/p>\n
    Du solltest deine Methodenaufrufe immer mit einem try-catch-Block umgeben. Wenn ein Fehler auftritt, geht die Kontrolle an den catch-Block \u00fcber, wo du den Fehler \u00fcberpr\u00fcfen und behandeln kannst. Wie du vielleicht in den obigen Beispielen bemerkt hast, haben wir den try-catch-Block f\u00fcr die Behandlung von Fehlern verwendet, auf die wir gesto\u00dfen sind.<\/p>\n\n
    Zusammenfassung<\/h2>\n
    Lass uns noch einmal die wichtigsten Punkte dieses Tutorials durchgehen:<\/p>\n