Node.js-Handbuch, Teil 9: Arbeiten mit dem Dateisystem

Heute, im neunten Teil der Übersetzung des Node.js-Tutorials, werden wir über das Arbeiten mit Dateien sprechen. Insbesondere werden wir über fs und Pfadmodule sprechen - über Dateideskriptoren, über Dateipfade, über das Abrufen von Informationen über Dateien, über das Lesen und Schreiben, über das Arbeiten mit Verzeichnissen.

Arbeiten mit Dateideskriptoren in Node.js.

Bevor Sie mit Dateien im Dateisystem Ihres Servers interagieren können, benötigen Sie einen Dateideskriptor.

Der Deskriptor kann mithilfe der asynchronen open() -Methode aus dem fs Modul abgerufen werden, um die Datei zu öffnen:

 const fs = require('fs') fs.open('/Users/flavio/test.txt', 'r', (err, fd) => { //fd -    }) 

Beachten Sie den zweiten Parameter r , der beim Aufrufen der Methode fs.open() verwendet wird. Dies ist ein Flag, das dem System mitteilt, dass die Datei zum Lesen geöffnet wird. Hier sind einige weitere Flags, die häufig bei der Arbeit mit dieser und einigen anderen Methoden verwendet werden:

• r+ - Öffnen Sie die Datei zum Lesen und Schreiben.
• w+ - Öffnen Sie die Datei zum Lesen und Schreiben, indem Sie den Stream-Zeiger auf den Anfang der Datei setzen. Wenn die Datei nicht vorhanden ist, wird sie erstellt.
• a - Öffnen Sie die Datei zum Schreiben, indem Sie den Stream-Zeiger auf das Ende der Datei setzen. Wenn die Datei nicht vorhanden ist, wird sie erstellt.
• a+ - Öffnen Sie die Datei zum Lesen und Schreiben, indem Sie den Stream-Zeiger auf das Ende der Datei setzen. Wenn die Datei nicht vorhanden ist, wird sie erstellt.

Dateien können mit der synchronen Methode fs.openSync() geöffnet werden, die anstelle eines Dateideskriptors im Rückruf fs.openSync() zurückgibt:

 const fs = require('fs') try { const fd = fs.openSync('/Users/flavio/test.txt', 'r') } catch (err) { console.error(err) } 

Nachdem Sie den Deskriptor mit einer der oben genannten Methoden erhalten haben, können Sie die erforderlichen Operationen damit ausführen.

Dateidaten

Jeder Datei ist ein Datensatz zugeordnet. Sie können diese Daten mit Node.js untersuchen. Dies kann insbesondere mit der stat() -Methode aus dem fs Modul erfolgen.

Diese Methode wird aufgerufen, indem der Pfad zur Datei übergeben wird. Nachdem Node.js die erforderlichen Informationen zur Datei erhalten hat, wird der an die stat() -Methode übergebene Rückruf aufgerufen. So sieht es aus:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } //      `stats` }) 

Node.js kann Dateiinformationen synchron abrufen. Bei diesem Ansatz wird der Hauptthread blockiert, bis die Eigenschaften der Datei erhalten werden:

 const fs = require('fs') try { const stats = fs.statSync ('/Users/flavio/test.txt') } catch (err) { console.error(err) } 

Informationen über die Datei fallen in die stats . Was ist diese Information? Tatsächlich bietet uns das entsprechende Objekt eine Vielzahl nützlicher Eigenschaften und Methoden:

• Mit den .isFile() und .isDirectory() können Sie herausfinden, ob es sich bei der untersuchten Datei um eine reguläre Datei oder ein Verzeichnis handelt.
• Mit der Methode .isSymbolicLink() können Sie .isSymbolicLink() , ob eine Datei ein symbolischer Link ist.
• Die Dateigröße kann mit der Eigenschaft .size .

Es gibt hier andere Methoden, aber diese werden am häufigsten verwendet. So verwenden Sie sie:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } stats.isFile() //true stats.isDirectory() //false stats.isSymbolicLink() //false stats.size //1024000 //= 1MB }) 

Dateipfade in Node.js und im Pfadmodul

Der Dateipfad ist die Adresse des Ortes im Dateisystem, an dem er sich befindet.

Unter Linux und MacOS könnte der Pfad folgendermaßen aussehen:

 /users/flavio/file.txt 

Unter Windows sehen die Pfade etwas anders aus:

 C:\users\flavio\file.txt 

Unterschiede in den Pfadaufzeichnungsformaten bei Verwendung verschiedener Betriebssysteme sollten beachtet werden, da das Betriebssystem zur Bereitstellung des Node.js-Servers verwendet wird.

Node.js verfügt über ein Standardpfadmodul, das für die Arbeit mit Dateipfaden entwickelt wurde. Bevor Sie dieses Modul in einem Programm verwenden können, muss es verbunden sein:

 const path = require('path') 

▍ Abrufen von Dateipfadinformationen

Wenn Sie einen Pfad zur Datei haben und die Funktionen des Pfadmoduls verwenden, können Sie in einer für die Wahrnehmung und weitere Verarbeitung geeigneten Form Details zu diesem Pfad herausfinden. Es sieht so aus:

 const notes = '/users/flavio/notes.txt' path.dirname(notes) // /users/flavio path.basename(notes) // notes.txt path.extname(notes) // .txt 

Hier wird in der notes der Dateipfad gespeichert. Die folgenden Methoden des Pfadmoduls wurden verwendet, um den path zu analysieren:

• dirname() - gibt das übergeordnete Verzeichnis der Datei zurück.
• basename() - gibt den Dateinamen zurück.
• extname() - gibt die Dateierweiterung zurück.

Sie können den Dateinamen ohne die Erweiterung ermitteln, indem Sie die Methode .basename() aufrufen und das zweite Argument übergeben, das die Erweiterung darstellt:

 path.basename(notes, path.extname(notes)) //notes 

▍Arbeiten mit Dateipfaden

Mit der Methode path.join() können mehrere Teile des Pfads kombiniert werden:

 const name = 'flavio' path.join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

Sie können den absoluten Pfad zur Datei basierend auf dem relativen Pfad dazu mithilfe der path.resolve() -Methode ermitteln:

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'       

In diesem Fall fügt Node.js einfach /flavio.txt zum Pfad hinzu, der zum aktuellen Arbeitsverzeichnis führt. Wenn Sie beim Aufrufen dieser Methode einen anderen Parameter übergeben, der den Pfad zum Ordner darstellt, verwendet die Methode diesen als Basis, um den absoluten Pfad zu bestimmen:

 path.resolve('tmp', 'flavio.txt') // '/Users/flavio/tmp/flavio.txt'       

Wenn der als erster Parameter übergebene Pfad mit einem Schrägstrich beginnt, bedeutet dies, dass es sich um einen absoluten Pfad handelt.

 path.resolve('/etc', 'flavio.txt') // '/etc/flavio.txt' 

Hier ist eine weitere nützliche Methode - path.normalize() . Sie können den tatsächlichen Pfad zur Datei anhand des Pfads ermitteln, der die relativen Pfadqualifizierer wie einen Punkt ( . ), Zwei Punkte ( .. ) oder zwei Schrägstriche enthält:

 path.normalize('/users/flavio/..//test.txt') // /users/test.txt 

Die Methoden resolve() und normalize() prüfen nicht, ob ein Verzeichnis vorhanden ist. Sie finden den Pfad einfach anhand der an sie übergebenen Daten.

Dateien in Node.js lesen

Der einfachste Weg, Dateien in Node.js zu lesen, besteht darin, die Methode fs.readFile() verwenden und ihr den Pfad zur Datei und den Rückruf zu übergeben, der bei der Übertragung der fs.readFile() des fs.readFile() darauf aufgerufen wird:

 fs.readFile('/Users/flavio/test.txt', (err, data) => { if (err) {   console.error(err)   return } console.log(data) }) 

Bei Bedarf können Sie die synchrone Version dieser Methode verwenden - fs.readFileSync() :

 const fs = require('fs') try { const data = fs.readFileSync('/Users/flavio/test.txt') console.log(data) } catch (err) { console.error(err) } 

Standardmäßig wird beim Lesen von Dateien die utf8 Codierung verwendet. Die Codierung kann jedoch auch unabhängig festgelegt werden, indem der entsprechende Parameter an die Methode übergeben wird.

Die fs.readFile() und fs.readFileSync() lesen den gesamten Inhalt der Datei in den Speicher. Dies bedeutet, dass die Arbeit mit großen Dateien mit diesen Methoden den Speicherverbrauch Ihrer Anwendung erheblich beeinträchtigt und deren Leistung beeinträchtigt. Wenn Sie mit solchen Dateien arbeiten müssen, verwenden Sie am besten Streams.

Schreiben von Dateien in Node.js.

In Node.js ist es am einfachsten, Dateien mit der Methode fs.writeFile() zu schreiben:

 const fs = require('fs') const content = 'Some content!' fs.writeFile('/Users/flavio/test.txt', content, (err) => { if (err) {   console.error(err)   return } //   }) 

Es gibt auch eine synchrone Version derselben Methode - fs.writeFileSync() :

 const fs = require('fs') const content = 'Some content!' try { const data = fs.writeFileSync('/Users/flavio/test.txt', content) //   } catch (err) { console.error(err) } 

Diese Methoden ersetzen standardmäßig den Inhalt vorhandener Dateien. Sie können ihr Standardverhalten mit dem entsprechenden Flag ändern:

 fs.writeFile('/Users/flavio/test.txt', content, { flag: 'a+' }, (err) => {}) 

Hier können Flags verwendet werden, die wir bereits im Abschnitt über Deskriptoren aufgeführt haben. Details zu Flags finden Sie hier .

Hängen Sie Daten an eine Datei an

Die Methode fs.appendFile() (und ihre synchrone Version fs.appendFileSync() ) wird bequem verwendet, um Daten an das Ende der Datei anzuhängen:

 const content = 'Some content!' fs.appendFile('file.log', content, (err) => { if (err) {   console.error(err)   return } //! }) 

Informationen zur Verwendung von Threads

Oben haben wir Methoden beschrieben, die beim Schreiben in eine Datei die gesamte übertragene Datenmenge schreiben. Wenn ihre synchronen Versionen verwendet werden, geben sie die Steuerung an das Programm zurück, und wenn asynchrone Versionen verwendet werden, rufen sie Rückrufe auf. Wenn dieser Zustand nicht zu Ihnen passt, ist es besser, Streams zu verwenden.

Arbeiten mit Verzeichnissen in Node.js.

Das fs Modul bietet dem Entwickler viele praktische Methoden, mit denen er mit Verzeichnissen arbeiten kann.

▍Überprüfen Sie, ob ein Ordner vorhanden ist

Um zu überprüfen, ob das Verzeichnis vorhanden ist und ob Node.js mit den entsprechenden Berechtigungen darauf zugreifen kann, können Sie die Methode fs.access() verwenden.

▍Erstellen Sie einen neuen Ordner

Um neue Ordner zu erstellen, können Sie die fs.mkdir() und fs.mkdirSync() verwenden:

 const fs = require('fs') const folderName = '/Users/flavio/test' try { if (!fs.existsSync(dir)){   fs.mkdirSync(dir) } } catch (err) { console.error(err) } 

▍Lesen Sie den Inhalt des Ordners

Um den Inhalt eines Ordners zu lesen, können Sie die fs.readdir() und fs.readdirSync() verwenden. In diesem Beispiel wird der Inhalt des Ordners gelesen, dh die Informationen darüber, welche Dateien und Unterverzeichnisse darin enthalten sind, und ihre relativen Pfade zurückgegeben:

 const fs = require('fs') const path = require('path') const folderPath = '/Users/flavio' fs.readdirSync(folderPath) 

So erhalten Sie den vollständigen Pfad zur Datei:

 fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName) } 

Die Ergebnisse können gefiltert werden, um nur die Dateien abzurufen und von der Ausgabe des Verzeichnisses auszuschließen:

 const isFile = fileName => { return fs.lstatSync(fileName).isFile() } fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName)).filter(isFile) } 

▍ Ordner umbenennen

Mit den fs.rename() und fs.renameSync() können Sie den Ordner umbenennen. Der erste Parameter ist der aktuelle Ordnerpfad, der zweite ist ein neuer:

 const fs = require('fs') fs.rename('/Users/flavio', '/Users/roger', (err) => { if (err) {   console.error(err)   return } // }) 

Sie können den Ordner mit der synchronen Methode fs.renameSync() umbenennen:

 const fs = require('fs') try { fs.renameSync('/Users/flavio', '/Users/roger') } catch (err) { console.error(err) } 

▍ Ordner löschen

Um einen Ordner zu löschen, können Sie die fs.rmdir() oder fs.rmdirSync() verwenden. Es ist zu beachten, dass das Löschen eines Ordners, in dem sich etwas befindet, etwas komplizierter ist als das Löschen eines leeren Ordners. Wenn Sie solche Ordner löschen müssen, verwenden Sie das Paket fs-extra , das sehr beliebt ist und gut unterstützt wird. Es ist ein Ersatz für das fs Modul und erweitert seine Funktionen.

Die Methode remove() aus dem Paket fs-extra kann Ordner löschen, die bereits etwas enthalten.

Sie können dieses Modul wie folgt installieren:

 npm install fs-extra 

Hier ist ein Beispiel für seine Verwendung:

 const fs = require('fs-extra') const folder = '/Users/flavio' fs.remove(folder, err => { console.error(err) }) 

Seine Methoden können in Form von Versprechungen angewendet werden:

 fs.remove(folder).then(() => { // }).catch(err => { console.error(err) }) 

Das Konstrukt async / await ist ebenfalls akzeptabel:

 async function removeFolder(folder) { try {   await fs.remove(folder)   // } catch (err) {   console.error(err) } } const folder = '/Users/flavio' removeFolder(folder) 

Fs-Modul

Oben sind wir bereits auf einige Methoden des fs Moduls fs , die bei der Arbeit mit dem Dateisystem verwendet werden. In der Tat enthält es viele weitere nützliche Dinge. Denken Sie daran, dass es nicht installiert werden muss, um es im Programm zu verwenden. Es reicht aus, es anzuschließen:

 const fs = require('fs') 

Danach haben Sie Zugriff auf seine Methoden, von denen wir Folgendes notieren, von denen einige Sie bereits kennen:

• fs.access() : Überprüft das Vorhandensein einer Datei und die Möglichkeit, basierend auf Berechtigungen darauf zuzugreifen.
• fs.appendFile() : fs.appendFile() Daten an eine Datei an. Wenn die Datei nicht vorhanden ist, wird sie erstellt.
• fs.chmod() : fs.chmod() Berechtigungen für eine bestimmte Datei. Ähnliche Methoden: fs.lchmod() , fs.fchmod() .
• fs.chown() : fs.chown() den Eigentümer und die Gruppe für die angegebene Datei. Ähnliche Methoden: fs.fchown() , fs.lchown() .
• fs.close() : Schließt den Dateideskriptor.
• fs.copyFile() : fs.copyFile() die Datei.
• fs.createReadStream() : fs.createReadStream() einen Stream zum Lesen einer Datei.
• fs.createWriteStream() : fs.createWriteStream() einen fs.createWriteStream() .
• fs.link() : fs.link() einen neuen festen Link zur Datei.
• fs.mkdir() : fs.mkdir() ein neues Verzeichnis.
• fs.mkdtemp() : fs.mkdtemp() ein temporäres Verzeichnis.
• fs.open() : fs.open() eine Datei.
• fs.readdir() : Liest den Inhalt eines Verzeichnisses.
• fs.readFile() : Liest den Inhalt einer Datei. Ähnliche Methode: fs.read() .
• fs.readlink() : Liest den Wert eines symbolischen Links.
• fs.realpath() : fs.realpath() den relativen Dateipfad auf, der mit Zeichen erstellt wurde . und .. , auf dem vollen Weg.
• fs.rename() : fs.rename() eine Datei oder einen Ordner um.
• fs.rmdir() : fs.rmdir() den Ordner.
• fs.stat() : fs.stat() zurück. Ähnliche Methoden: fs.fstat() , fs.lstat() .
• fs.symlink() : fs.symlink() einen neuen symbolischen Link zur Datei.
• fs.truncate() : fs.truncate() die Datei auf die angegebene Länge ab. Ähnliche Methode: fs.ftruncate() .
• fs.unlink() : fs.unlink() eine Datei oder einen symbolischen Link.
• fs.unwatchFile() : fs.unwatchFile() die Überwachung von Dateiänderungen.
• fs.utimes() : fs.utimes() den Zeitstempel einer Datei. Ähnliche Methode: fs.futimes() .
• fs.watchFile() : Aktiviert die Überwachung von Dateiänderungen. Ähnliche Methode: fs.watch() .
• fs.writeFile() : Schreibt Daten in eine Datei. Ähnliche Methode: fs.write() .

Ein interessantes Merkmal des fs Moduls ist die Tatsache, dass alle seine Methoden standardmäßig asynchron sind, es gibt jedoch auch synchrone Versionen davon, deren Namen durch Hinzufügen des Wortes Sync zu den Namen asynchroner Methoden erhalten werden.

Zum Beispiel:

• fs.rename()
• fs.renameSync()
• fs.write()
• fs.writeSync()

Die Verwendung synchroner Methoden hat schwerwiegende Auswirkungen auf die Funktionsweise des Programms.

Node.js 10 bietet experimentelle Unterstützung für diese auf Versprechen basierenden APIs.

Entdecken Sie die Methode fs.rename() . Hier ist eine asynchrone Version dieser Methode mit Rückrufen:

 const fs = require('fs') fs.rename('before.json', 'after.json', (err) => { if (err) {   return console.error(err) } // }) 

Bei Verwendung der synchronen Version wird das try/catch Konstrukt verwendet, um Fehler zu behandeln:

 const fs = require('fs') try { fs.renameSync('before.json', 'after.json') // } catch (err) { console.error(err) } 

Der Hauptunterschied zwischen diesen Optionen für die Verwendung dieser Methode besteht darin, dass im zweiten Fall das Skript blockiert wird, bis der Dateivorgang abgeschlossen ist.

Pfadmodul

Das Pfadmodul, über das wir auch einige seiner Funktionen gesprochen haben, enthält viele nützliche Tools, mit denen Sie mit dem Dateisystem interagieren können. Wie bereits erwähnt, müssen Sie es nicht installieren, da es Teil von Node.js ist. Um es zu verwenden, reicht es aus, es anzuschließen:

 const path = require('path') 

Die path.sep Eigenschaft dieses Moduls enthält das Zeichen, das zum Trennen von path.sep verwendet wird ( \ unter Windows und / unter Linux und macOS), und die path.delimiter Eigenschaft gibt das Zeichen an, das zum Trennen mehrerer Pfade verwendet wird ( ; unter Windows und : unter Linux) und macOS).

Betrachten und veranschaulichen wir einige Methoden des Pfadmoduls.

▍path.basename ()

Gibt das letzte Fragment des Pfads zurück. Durch Übergeben des zweiten Parameters an diese Methode können Sie die Dateierweiterung entfernen.

 require('path').basename('/test/something') //something require('path').basename('/test/something.txt') //something.txt require('path').basename('/test/something.txt', '.txt') //something 

▍path.dirname ()

Gibt den Teil des Pfads zurück, der den Verzeichnisnamen darstellt:

 require('path').dirname('/test/something') // /test require('path').dirname('/test/something/file.txt') // /test/something 

▍path.extname ()

Gibt den Teil des Pfads zurück, der die Dateierweiterung darstellt:

 require('path').extname('/test/something') // '' require('path').extname('/test/something/file.txt') // '.txt' 

▍path.isAbsolute ()

Gibt true zurück, wenn der Pfad absolut ist:

 require('path').isAbsolute('/test/something') // true require('path').isAbsolute('./test/something') // false 

▍path.join ()

Verbindet mehrere Teile des Pfades:

 const name = 'flavio' require('path').join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

▍path.normalize ()

Der Versuch, den realen Pfad basierend auf dem Pfad herauszufinden, der die Zeichen enthält, die zum Erstellen relativer Pfade wie verwendet werden . , .. und // :

 require('path').normalize('/users/flavio/..//test.txt') ///users/test.txt 

▍path.parse ()

Konvertiert einen Pfad in ein Objekt, dessen Eigenschaften einzelne Teile des Pfads darstellen:

• root : das Stammverzeichnis.
• dir : Dateipfad ab dem Stammverzeichnis
• base : Dateiname und Erweiterung.
• name : Dateiname.
• ext : Dateierweiterung.

Hier ist ein Beispiel mit dieser Methode:

 require('path').parse('/users/test.txt') 

Als Ergebnis seiner Arbeit erhält man folgendes Objekt:

 { root: '/', dir: '/users', base: 'test.txt', ext: '.txt', name: 'test' } 

▍path.relative ()

Nimmt als Argumente zwei Möglichkeiten. Gibt den relativen Pfad vom ersten zum zweiten Pfad basierend auf dem aktuellen Arbeitsverzeichnis zurück:

 require('path').relative('/Users/flavio', '/Users/flavio/test.txt') //'test.txt' require('path').relative('/Users/flavio', '/Users/flavio/something/test.txt') //'something/test.txt' 

▍path.resolve ()

Findet den absoluten Pfad basierend auf dem relativen Pfad, der an ihn übergeben wurde:

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'      . 

Zusammenfassung

Heute haben wir uns die Node.js fs und path Module angesehen, die für die Arbeit mit dem Dateisystem verwendet werden. Im nächsten Teil dieser Reihe, an dem sie endet, werden wir die Betriebssysteme, events und http Module diskutieren und über die Arbeit mit Streams und Datenbankverwaltungssystemen in Node.js sprechen.

Liebe Leser! Welche npm-Pakete verwenden Sie, wenn Sie mit dem Dateisystem in Node.js arbeiten?