Arbeiten mit dem Dateisystem in Deno

Dieser Artikel wird in Deno eintauchen und ein Befehlszeilen -Tool zum Suchen nach Text in Dateien und Ordnern erstellen. Wir werden verschiedene API -Methoden verwenden, die von Deno bereitgestellt werden, um das Dateisystem zu lesen und zu schreiben.

Im vorherigen Artikel haben wir ein Befehlszeilen-Tool mit Deno erstellt, um Anfragen an APIs von Drittanbietern zu stellen. In diesem Artikel werden wir vorübergehend Netzwerkoperationen ignorieren und ein Tool erstellen, mit dem Sie in Dateien und Ordnern im aktuellen Verzeichnis nach Text suchen können - Tools wie Grep.

Hinweis: Die Tools, die wir erstellen, sind nicht so optimiert und effizient wie Grep, und wir wollen es nicht ersetzen! Der Zweck des Erstellens eines solchen Tools besteht darin, mit der Dateisystem -API von Deno vertraut zu sein.

Schlüsselpunkte

Die Dateisystem-API von Deno hilft bei der Erstellung von Befehlszeilen-Tools für die Suche nach Text in Dateien und Verzeichnissen, ähnlich wie bei Grep-Tools, jedoch nicht so optimiert.
Verwenden von Yargs in Deno können Entwickler Benutzeroberflächen für Befehlszeilenanwendungen erstellen und Textsuche in bestimmten Verzeichnissen ermöglichen.
Deno bietet integrierte Funktionen wie
• zum Auflisten von Dateien und Deno.readDir zum Lesen von Dateiinhalten und vereinfacht somit die Interaktion des Dateisystems ohne zusätzliche Importe. Deno.readTextFile
Sie können das Pfadmodul von DENO verwenden, um Dateipfade effizient zu verwalten, die Funktionen wie
• enthält, um Dateipfade zu verbinden. path.join
Deno -Skripte erfordern explizite Berechtigungsflags wie
• oder –allow-read, um Dateisystemvorgänge durchzuführen, was die Sicherheit durch Steuern von Skriptfunktionen verbessert. –allow-write
Entwickler können
• verwenden, um Deno -Skripte in separate ausführbare Produkte zu kompilieren und die Verteilung und Ausführung zu vereinfachen, indem die erforderlichen Berechtigungen eingekapselt werden. deno compile

Installation Deno

wir gehen davon aus, dass Sie Deno auf Ihrer lokalen Maschine laufen lassen. Sie können die Deno -Website oder den vorherigen Artikel finden, um detailliertere Installationsanweisungen und Informationen zum Hinzufügen von Deno -Support zu Ihrem Editor hinzuzufügen.

Zum Zeitpunkt des Schreibens ist die neueste stabile Version von Deno 1.10.2, die Version, die ich in diesem Artikel verwende.

Als Referenz finden Sie den vollständigen Code für diesen Artikel auf GitHub.

Setzen Sie neue Befehle mit Yargs

Wie im vorherigen Beitrag werden wir Yargs verwenden, um Schnittstellen zu erstellen, mit denen Benutzer unsere Tools ausführen können. Erstellen wir index.ts und füllen Sie es mit Folgendem aus:

<code class="language-typescript">import yargs from "https://deno.land/x/yargs@v17.0.1-deno/deno.ts";

interface Yargs<argvreturntype></argvreturntype> {
  describe: (param: string, description: string) => Yargs<argvreturntype>;
</argvreturntype>  demandOption: (required: string[]) => Yargs<argvreturntype>;
</argvreturntype>  argv: ArgvReturnType;
}

interface UserArguments {
  text: string;
}

const userArguments: UserArguments =
  (yargs(Deno.args) as unknown as Yargs<userarguments>)
</userarguments>    .describe("text", "the text to search for within the current directory")
    .demandOption(["text"])
    .argv;

console.log(userArguments);
</code>

Es gibt hier viel darauf hinzuweisen:

• Wir installieren Yargs, indem wir auf den Pfad im Deno -Repository hinweisen. Ich verwende die genaue Versionsnummer explizit, um sicherzustellen, dass wir diese Version immer erhalten, damit wir keine neuesten Versionen verwenden, wenn das Skript ausgeführt wird.
• Zum Zeitpunkt des Schreibens hat Deno TypyScript keine gute Erfahrung mit Yargs gemacht. Deshalb habe ich meine eigene Schnittstelle erstellt und sie verwendet, um eine Art Sicherheit zu gewährleisten.
• userArgumente enthält alle Eingaben, die wir vom Benutzer anfordern. Derzeit bitten wir nur nach Texteingaben, aber in Zukunft können wir sie erweitern, um eine Liste von Dateien zur Suche anzugeben, anstatt das aktuelle Verzeichnis zu übernehmen.

Wir können es mit demo run index.ts ausführen und unsere Yargs -Ausgabe sehen:

<code class="language-typescript">import yargs from "https://deno.land/x/yargs@v17.0.1-deno/deno.ts";

interface Yargs<argvreturntype></argvreturntype> {
  describe: (param: string, description: string) => Yargs<argvreturntype>;
</argvreturntype>  demandOption: (required: string[]) => Yargs<argvreturntype>;
</argvreturntype>  argv: ArgvReturnType;
}

interface UserArguments {
  text: string;
}

const userArguments: UserArguments =
  (yargs(Deno.args) as unknown as Yargs<userarguments>)
</userarguments>    .describe("text", "the text to search for within the current directory")
    .demandOption(["text"])
    .argv;

console.log(userArguments);
</code>

Es ist Zeit, mit der Implementierung zu beginnen!

Listen Sie die Datei

auf

Bevor wir in einer bestimmten Datei nach Text suchen, müssen wir ein Verzeichnis und eine Liste von Dateien generieren, nach denen gesucht werden soll. Deno stellt Deno.readdir zur Verfügung, das Teil der "eingebauten" Bibliothek ist, was bedeutet, dass Sie sie nicht importieren müssen. Es ist im globalen Namespace erhältlich.

deno.readdir ist asynchron und gibt eine Liste von Dateien und Ordnern im aktuellen Verzeichnis zurück. Es gibt diese Elemente als Asynciterator zurück, was bedeutet, dass wir für die Wartezeit verwenden müssen, um das Ergebnis zu erhalten:

<code class="language-bash">$ deno run index.ts
Check file:///home/jack/git/deno-file-search/index.ts
Options:
  --help     Show help                                                 [boolean]
  --version  Show version number                                       [boolean]
  --text     the text to search for within the current directory      [required]

Missing required argument: text</code>

In diesem Code wird jedes Ergebnis aus dem aktuellen Arbeitsverzeichnis (bereitgestellt von Deno.cwd ()) gelesen und aufgezeichnet. Wenn Sie jedoch versuchen, das Skript jetzt auszuführen, erhalten Sie einen Fehler:

<code class="language-typescript">for await (const fileOrFolder of Deno.readDir(Deno.cwd())) {
  console.log(fileOrFolder);
}
</code>

Denken Sie daran, dass Deno verlangt, dass alle Skripte ausdrücklich Berechtigungen erhalten, um aus dem Dateisystem zu lesen. In unserem Fall ermöglicht das Flag --allow-read unseren Code aus:

<code class="language-bash">$ deno run index.ts --text='foo'
error: Uncaught PermissionDenied: Requires read access to <cwd>, run again with the --allow-read flag
</cwd>for await (const fileOrFolder of Deno.readDir(Deno.cwd())) {
                                                   ^
    at deno:core/core.js:86:46
    at unwrapOpResult (deno:core/core.js:106:13)
    at Object.opSync (deno:core/core.js:120:12)
    at Object.cwd (deno:runtime/js/30_fs.js:57:17)
    at file:///home/jack/git/deno-file-search/index.ts:19:52</code>

In diesem Fall führe ich das Skript im Verzeichnis des Build -Tools aus, sodass der TS -Quellcode, das .git -Repository und den Ordner .vScode. Lassen Sie uns einige Funktionen schreiben, um diese Struktur rekursiv zu navigieren, da wir alle Dateien im Verzeichnis finden müssen, nicht nur in den obersten Dateien. Zusätzlich können wir einige gemeinsame Ignores hinzufügen. Ich glaube nicht, dass jemand möchte, dass das Skript den gesamten .git -Ordner durchsucht!

Im folgenden Code erstellen wir die GetFilesList -Funktion, die ein Verzeichnis aufnimmt und alle Dateien in diesem Verzeichnis zurückgibt. Wenn ein Verzeichnis auftritt

<code class="language-bash">~/$ deno run --allow-read index.ts --text='foo'
{ name: ".git", isFile: false, isDirectory: true, isSymlink: false }
{ name: ".vscode", isFile: false, isDirectory: true, isSymlink: false }
{ name: "index.ts", isFile: true, isDirectory: false, isSymlink: false }
</code>

Dann können wir es so verwenden:

<code class="language-typescript">const IGNORED_DIRECTORIES = new Set([".git"]);

async function getFilesList(
  directory: string,
): Promise<string> {
  const foundFiles: string[] = [];
  for await (const fileOrFolder of Deno.readDir(directory)) {
    if (fileOrFolder.isDirectory) {
      if (IGNORED_DIRECTORIES.has(fileOrFolder.name)) {
        // Skip this folder, it's in the ignore list.
        continue;
      }
      // If it's not ignored, recurse and search this folder for files.
      const nestedFiles = await getFilesList(
        path.join(directory, fileOrFolder.name),
      );
      foundFiles.push(...nestedFiles);
    } else {
      // We found a file, so store it.
      foundFiles.push(path.join(directory, fileOrFolder.name));
    }
  }
  return foundFiles;
}
</string></code>

wir erhalten auch eine Ausgabe, die gut aussieht:

<code class="language-typescript">const files = await getFilesList(Deno.cwd());
console.log(files);
</code>

Verwenden des Pfadmoduls

Wir können jetzt Dateipfade mit Vorlagenzeichenfolgen wie folgt kombinieren:

<code class="language-bash">$ deno run --allow-read index.ts --text='foo'
[
  "/home/jack/git/deno-file-search/.vscode/settings.json",
  "/home/jack/git/deno-file-search/index.ts"
]
</code>

Aber das wäre besser mit dem Pfadmodul von Deno. Dieses Modul ist eines der Module, die die Deno -Angebote als Teil seiner Standardbibliothek (sehr ähnlich wie das Pfadmodul) anbietet, und wenn Sie das Pfadmodul des Knotens verwendet haben, sieht der Code sehr ähnlich aus. Zum Zeitpunkt des Schreibens beträgt die neueste Standardbibliotheksversion von Deno 0,97.0, das Pfadmodul aus der Datei mod.ts:

<code class="language-typescript">import yargs from "https://deno.land/x/yargs@v17.0.1-deno/deno.ts";

interface Yargs<argvreturntype></argvreturntype> {
  describe: (param: string, description: string) => Yargs<argvreturntype>;
</argvreturntype>  demandOption: (required: string[]) => Yargs<argvreturntype>;
</argvreturntype>  argv: ArgvReturnType;
}

interface UserArguments {
  text: string;
}

const userArguments: UserArguments =
  (yargs(Deno.args) as unknown as Yargs<userarguments>)
</userarguments>    .describe("text", "the text to search for within the current directory")
    .demandOption(["text"])
    .argv;

console.log(userArguments);
</code>

mod.ts ist immer der Einstiegspunkt beim Importieren von Deno -Standardmodulen. Die Dokumentation für dieses Modul befindet sich auf der Deno -Website und listet Path.Join auf, das mehrere Pfade aufnimmt und sich ihnen in einen Pfad verbindet. Lassen Sie uns die Funktionen importieren und verwenden, anstatt sie manuell zu kombinieren:

... (Der Rest des Codes wird hier weggelassen, da er mit dem Originaltext wiederholt wird und in der vorherigen Ausgabe geändert und optimiert wurde.)

... (Der Rest des Codes wird weggelassen, weil er sich vom Original wiederholt und in der vorherigen Ausgabe bereits modifiziert und optimiert wurde.)

:::::::::::::::::3 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: : ::::::::::::::::::::::3

Das obige ist der detaillierte Inhalt vonArbeiten mit dem Dateisystem in Deno. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!