Eine kurze Analyse gängiger Module im Knoten: Pfadmodul und FS-Modul

So starten Sie schnell mit VUE3.0: Rufen Sie das Lernpfadmodul auf

.

Das Pfadmodul dient der Verarbeitung von Pfaden und Dateien und bietet viele Methoden.

path.resolve

besteht darin, den Pfad und den Dateinamen zu verketten.

const basePath = '/user/why'
const filename = 'abc.txt'

Dann wird jemand String-Splicing zum Spleißen verwenden.

const filePath = basePath + '/' + Dateiname
console.log(filePath);

Obwohl ein solches Ergebnis kein Problem darstellt, kann das Windows-System unter Berücksichtigung verschiedener Systeme oder \ oder / als Pfadtrennzeichen verwenden, während die Unix-Betriebssysteme von Mac OS und Linux / als verwenden das Pfadtrennzeichen.

Um das obige Problem zu lösen, können wir path.resolve verwenden, um Pfade zu verbinden.

const path = require('path')

const basePath = '/user/why'
const Dateiname = 'abc.txt'

const filePath = path.resolve(basePath, Dateiname)

console.log(filePath);

Informationen aus dem Pfad abrufen

• Dirname: Den übergeordneten Ordner der Datei abrufen
• Basisname: Den Dateinamen abrufen
• extname: Die Dateierweiterung abrufen

const path = require('path')

const filePath = '/User/haha/abc.txt'

console.log(path.dirname(filePath));
console.log(path.basename(filePath));
console.log(path.extname(filePath));

Pfadspleißen

Wenn wir mehrere Pfade verbinden möchten, verschiedene Betriebssysteme jedoch möglicherweise unterschiedliche Trennzeichen verwenden, können wir die Funktion path.join verwenden.

const path = require('path')

const basepath = '/Benutzer/haha'
const Dateiname = 'abc.txt'

const filePath = path.join(Basispfad, Dateiname)
console.log(filePath);

Eine Datei und einen Ordner verbinden

Wenn wir eine Datei und einen Ordner verbinden möchten, können wir path.resolve verwenden.

const basepath = 'Benutzer/haha'
const Dateiname = 'abc.txt'

Path.resolve und path.join können auch zum Zusammenfügen von Pfaden verwendet werden. Was ist also der Unterschied?

const basepath = '../User/haha'
const filename = './abc.txt'
const othername = './haha.js'

const filePath1 = path.join(Basispfad, Dateiname, anderer Name)
console.log(filePath1);

const filePath2 = path.resolve(basepath, filename, othername)
console.log(filePath2);

Wir können den Unterschied sehen.

des fs-Moduls

nodejs bieten drei Betriebsmethoden:

• Synchrone Dateioperation: Der Code wird blockiert und führt

• die asynchrone Rückruffunktion nicht weiter aus. Dateioperation: Der Code wird nicht blockiert und es muss eine Rückruffunktion ausgeführt werden Wenn das Ergebnis übergeben wird, führt die Rückruffunktion

• eine asynchrone Promise-Operationsdatei aus: Der Aufruf von Methodenoperationen über fs.promises gibt ein Promise zurück, das dann verarbeitet werden kann.

Dateistatus (Informationen) lesen

Methode 1 Synchronbetrieb: fs.statSync

const fs = require('fs')

const filepath = './abc.txt'
const info = fs.statSync(filepath)
console.log('Code, der später ausgeführt werden muss');
console.log(info);

Methode 2 asynchroner Vorgang

fs.stat(filepath, (err, info) => {
  if(err) {
    console.log(err);
    zurückkehren
  }
  console.log(info);
  console.log(info.isFile()); // Bestimmen Sie, ob es sich um eine Datei handelt console.log(info.isDirectory()); // Bestimmen Sie, ob es sich um einen Ordner handelt})
console.log('Code, der später ausgeführt werden muss');

Methode drei: Versprechen

fs.promises.stat(filepath).then(info => {
  console.log(info);
}).catch(err => {
  console.log(err);
})

console.log('Code, der anschließend ausgeführt werden soll');

Der Dateideskriptorknoten

weist allen geöffneten Dateien einen numerischen Dateideskriptor zu. Alle Dateisystemvorgänge verwenden diese Dateideskriptoren, um jede einzelne Datei zu identifizieren und zu verfolgen.

Die Methode fs.open() wird verwendet, um einen neuen Dateideskriptor fd zuzuweisen. Nach der Zuweisung kann der Dateideskriptor zum Lesen von Daten aus der Datei, zum Schreiben von Daten in die Datei oder zum Anfordern von Informationen über die Datei verwendet werden.

const fs = require('fs')

fs.open('./abc.txt', (err, fd) => {
  if(err) {
    console.log(err);
    zurückkehren
  }

  // Dateiinformationen über Dateideskriptoren abrufen fs.fstat(fd, (err, info) => {
    console.log(info);
  })
})

Lesen und Schreiben von Dateien

fs.readFile(path[, Optionen], Callback): Lesen Sie den Dateiinhalt.

fs.writeFile(path[, Optionen], Callback): Schreiben Sie den Inhalt in die Datei.

Optionsparameter:

Flag: geschriebener Modus

Kodierung: Zeichenkodierungsdatei

schreiben

fs.writeFile('./abc.txt', content, {flag: "a"}, err => {
  console.log(err);
})

Datei lesen

fs.readFile('./abc.txt', (err, data) => {
  console.log(data);
})

Wenn die Codierung nicht ausgefüllt ist, wird der Ergebnispuffer (binär) zurückgegeben.

fs.readFile('./abc.txt', {encoding: 'utf-8'}, (err, data) => {
  console.log(data);
})

Erstellen Sie einen Ordner.

Verwenden Sie fs.mkdir() oder fs.mkdirSync, um einen neuen Ordner zu erstellen.

const fs = require('fs')

//Ordner erstellen const dirname = './haha'
if(!fs.existsSync(dirname)) {
  fs.mkdir(dirname, (err) => {
    console.log(err);
  })
}

Holen Sie sich den Inhalt des Ordners

fs.readdir

fs.readdir(dirname, (err, files) => {
  console.log(Dateien);
})

Rufen Sie alle Dateien im Ordner ab. Zu diesem Zeitpunkt ist das Verzeichnis wie in der folgenden Abbildung dargestellt.

const fs = require('fs')
const path = require('path')
const dirname = './haha'

Funktion getFiles(Verzeichnisname) {
  fs.readdir(dirname, {withFileTypes: true}, (err, files) => {
    // console.log(files);
    for(let Datei von Dateien) {
      // Bestimmen Sie, ob es sich um einen Ordner handelt if(file.isDirectory()) {
        const filepath = path.resolve(dirname, file.name)
        getFiles(Dateipfad)
      } anders {
        console.log(file.name);
      }
    }
  })
}

getFiles(dirname)

rename

Sie können fs.rename verwenden, um den Ordner umzubenennen.

fs.rename('./haha', './xixi', err => {
  console.log(err);
})