Node.js lokale Dateioperationsmethode zum Kopieren von Dateien und Verzeichnis traversal_node.js

Dateikopie
NodeJS bietet eine grundlegende Dateioperations-API, erweiterte Funktionen wie das Kopieren von Dateien sind jedoch nicht verfügbar. Daher üben wir zunächst mit dem Programm zum Kopieren von Dateien. Ähnlich wie beim Kopierbefehl muss unser Programm zwei Parameter akzeptieren können: den Quelldateipfad und den Zieldateipfad.

Kleine Dateikopie
Wir verwenden das integrierte fs-Modul von NodeJS, um dieses Programm einfach wie folgt zu implementieren.

var fs = require('fs');

function copy(src, dst) {
  fs.writeFileSync(dst, fs.readFileSync(src));
}

function main(argv) {
  copy(argv[0], argv[1]);
}

main(process.argv.slice(2));

Das obige Programm verwendet fs.readFileSync, um den Dateiinhalt aus dem Quellpfad zu lesen, und verwendet fs.writeFileSync, um den Dateiinhalt in den Zielpfad zu schreiben.

Bean-Wissen: Prozess ist eine globale Variable und Befehlszeilenparameter können über process.argv abgerufen werden. Da argv[0] fest dem absoluten Pfad des ausführbaren NodeJS-Programms entspricht und argv[1] fest dem absoluten Pfad des Hauptmoduls entspricht, beginnt der erste Befehlszeilenparameter an der Position argv[2].

Große Dateikopie
Das obige Programm hat kein Problem damit, einige kleine Dateien zu kopieren, aber diese Methode, den gesamten Dateiinhalt auf einmal in den Speicher zu lesen und ihn dann auf einmal auf die Festplatte zu schreiben, ist nicht zum Kopieren großer Dateien geeignet, und der Speicher wird es tun erschöpft sein. Bei großen Dateien können wir nur ein wenig lesen und ein wenig schreiben, bis der Kopiervorgang abgeschlossen ist. Daher muss das obige Programm wie folgt geändert werden.

var fs = require('fs');

function copy(src, dst) {
  fs.createReadStream(src).pipe(fs.createWriteStream(dst));
}

function main(argv) {
  copy(argv[0], argv[1]);
}

main(process.argv.slice(2));

Das obige Programm verwendet fs.createReadStream, um einen schreibgeschützten Datenstrom für die Quelldatei zu erstellen, und verwendet fs.createWriteStream, um einen schreibgeschützten Datenstrom für die Zieldatei zu erstellen, und verwendet die Pipe-Methode, um die beiden zu verbinden Datenströme. Was passiert, nachdem die Verbindung hergestellt wurde, ist, abstrakter ausgedrückt, dass Wasser entlang des Rohrs von einem Eimer zum anderen fließt.

Verzeichnisse durchqueren

Das Durchsuchen von Verzeichnissen ist eine häufige Anforderung beim Bearbeiten von Dateien. Wenn Sie beispielsweise ein Programm schreiben, das alle JS-Dateien in einem bestimmten Verzeichnis finden und verarbeiten muss, muss es das gesamte Verzeichnis durchlaufen.

Rekursiver Algorithmus
Rekursive Algorithmen werden im Allgemeinen beim Durchlaufen von Verzeichnissen verwendet, da es sonst schwierig wird, prägnanten Code zu schreiben. Rekursive Algorithmen ähneln der mathematischen Induktion darin, dass sie Probleme durch kontinuierliche Reduzierung ihrer Größe lösen. Das folgende Beispiel veranschaulicht diesen Ansatz.

function factorial(n) {
  if (n === 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

Die obige Funktion wird verwendet, um die Fakultät von N (N!) zu berechnen. Wie Sie sehen können, reduziert sich das Problem auf die Berechnung der Fakultät von N mal N-1, wenn N größer als 1 ist. Wenn N gleich 1 ist, erreicht das Problem seine minimale Größe und es ist keine weitere Vereinfachung erforderlich, sodass 1 direkt zurückgegeben wird.

Falle: Obwohl der mit dem rekursiven Algorithmus geschriebene Code prägnant ist, da jede Rekursion einen Funktionsaufruf generiert, muss der rekursive Algorithmus in einen Schleifenalgorithmus umgewandelt werden, um die Anzahl der Funktionsaufrufe zu reduzieren, wenn die Leistung priorisiert werden muss.

Traversal-Algorithmus
Das Verzeichnis ist eine Baumstruktur, und beim Durchlaufen wird im Allgemeinen der Durchquerungsalgorithmus der Tiefenreihenfolge verwendet. Tiefe zuerst bedeutet, dass nach Erreichen eines Knotens zuerst die untergeordneten Knoten und nicht die Nachbarknoten durchlaufen werden. Vorbestellungsdurchquerung bedeutet, dass die Durchquerung abgeschlossen ist, wenn ein Knoten zum ersten Mal erreicht wird, und nicht bei der letzten Rückkehr zu einem Knoten. Daher ist die Durchlaufreihenfolge des Baums unten: A >

     A
     / \
    B  C
    / \  \
   D  E  F

Synchronisierte Durchquerung
Nachdem wir die erforderlichen Algorithmen verstanden haben, können wir einfach die folgende Verzeichnisdurchlauffunktion implementieren.

function travel(dir, callback) {
  fs.readdirSync(dir).forEach(function (file) {
    var pathname = path.join(dir, file);

    if (fs.statSync(pathname).isDirectory()) {
      travel(pathname, callback);
    } else {
      callback(pathname);
    }
  });
}

Wie Sie sehen können, verwendet diese Funktion ein Verzeichnis als Ausgangspunkt für die Durchquerung. Wenn ein Unterverzeichnis gefunden wird, wird das Unterverzeichnis zuerst durchlaufen. Wenn eine Datei gefunden wird, wird der absolute Pfad zur Datei an die Rückruffunktion übergeben. Nachdem die Rückruffunktion den Dateipfad erhalten hat, kann sie verschiedene Beurteilungen und Prozesse vornehmen. Nehmen wir also an, wir haben das folgende Verzeichnis:

- /home/user/
  - foo/
    x.js
  - bar/
    y.js
  z.css

Beim Durchlaufen des Verzeichnisses mit dem folgenden Code erhält man folgende Eingabe.

travel('/home/user', function (pathname) {
  console.log(pathname);
});

/home/user/foo/x.js
/home/user/bar/y.js
/home/user/z.css

Asynchrone Durchquerung
Wenn beim Lesen des Verzeichnisses oder Lesens des Dateistatus die asynchrone API verwendet wird, ist die Implementierung der Verzeichnisdurchlauffunktion etwas kompliziert, aber das Prinzip ist genau das gleiche. Die asynchrone Version der Reisefunktion sieht wie folgt aus.

function travel(dir, callback, finish) {
  fs.readdir(dir, function (err, files) {
    (function next(i) {
      if (i < files.length) {
        var pathname = path.join(dir, files[i]);

        fs.stat(pathname, function (err, stats) {
          if (stats.isDirectory()) {
            travel(pathname, callback, function () {
              next(i + 1);
            });
          } else {
            callback(pathname, function () {
              next(i + 1);
            });
          }
        });
      } else {
        finish && finish();
      }
    }(0));
  });
}

Die Schreibfähigkeiten asynchroner Traversalfunktionen werden hier nicht im Detail vorgestellt. Dies wird in den folgenden Kapiteln ausführlich vorgestellt. Kurz gesagt, wir können sehen, dass die asynchrone Programmierung ziemlich kompliziert ist.