Travailler avec le système de fichiers dans Deno

Cet article plongera dans Deno et créera un outil de ligne de commande pour rechercher du texte dans les fichiers et les dossiers. Nous utiliserons diverses méthodes API fournies par Deno pour lire et écrire au système de fichiers.

Dans l'article précédent, nous avons construit un outil de ligne de commande à l'aide de DENO pour faire des demandes aux API tierces. Dans cet article, nous ignorerons temporairement les opérations réseau et créerons un outil qui vous permet de rechercher du texte dans des fichiers et des dossiers dans le répertoire actuel - des outils comme Grep.

Remarque: Les outils que nous construisons ne sont pas aussi optimisés et efficaces que Grep, et nous ne visons pas à le remplacer! Le but de construire un tel outil est de se familiariser avec l'API du système de fichiers de Deno.

points clés

• L'API du système de fichiers de Deno aide à créer des outils de ligne de commande pour rechercher du texte dans des fichiers et des répertoires, similaires aux outils GREP, mais pas aussi optimisés.
• À l'aide de Yargs dans Deno, les développeurs peuvent créer des interfaces utilisateur pour les applications de ligne de commande, permettant des recherches de texte dans des répertoires spécifiés.
• Deno fournit des fonctions intégrées telles que Deno.readDir pour la liste des fichiers et Deno.readTextFile pour la lecture du contenu des fichiers, simplifiant ainsi l'interaction du système de fichiers sans importations supplémentaires.
• Vous pouvez utiliser le module de chemin de NEO pour gérer efficacement les chemins de fichier, qui inclut des fonctions telles que path.join pour connecter les chemins de fichier.
• Les scripts Deno nécessitent des indicateurs d'autorisation explicites, tels que –allow-read ou –allow-write pour effectuer des opérations de système de fichiers, ce qui améliore la sécurité en contrôlant les fonctions de script.
• Les développeurs peuvent utiliser deno compile pour compiler les scripts de NEno en exécutables séparés, simplifiant la distribution et l'exécution en encapsulant les autorisations nécessaires.

Installation Deno

Nous supposons que le Deno fonctionne sur votre machine locale. Vous pouvez consulter le site Web de Deno ou l'article précédent pour des instructions d'installation plus détaillées et des informations sur la façon d'ajouter la prise en charge de Deno à votre éditeur.

Au moment de la rédaction, la dernière version stable de Deno est 1.10.2, qui est la version que j'utilise dans cet article.

Pour référence, vous pouvez trouver le code complet de cet article sur GitHub.

Définissez de nouvelles commandes avec yargs

Comme dans le post précédent, nous utiliserons Yargs pour créer des interfaces que les utilisateurs peuvent utiliser pour exécuter nos outils. Créons index.ts et remplissons-le avec les éléments suivants:

<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>

Il y a beaucoup à souligner ici:

• Nous installons les yargs en pointant le chemin du chemin du référentiel NENO. J'utilise explicitement le numéro de version exacte pour m'assurer que nous obtenons toujours cette version afin que nous n'utilisons aucune dernière versions lorsque le script est en cours d'exécution.
• Au moment de la rédaction, Deno TypeScript n'a pas eu une bonne expérience avec Yargs, j'ai donc créé ma propre interface et je l'ai utilisée pour offrir une certaine sécurité.
• UserArguments contient toutes les entrées que nous demanderons à l'utilisateur. Actuellement, nous demandons seulement une entrée de texte, mais à l'avenir, nous pouvons l'étendre pour fournir une liste de fichiers à rechercher, plutôt que de supposer le répertoire actuel.

Nous pouvons l'exécuter avec Deno Run index.ts et voir notre sortie Yargs:

<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>

Il est temps de commencer à l'implémenter!

Énumérez le fichier

Avant de commencer à rechercher du texte dans un fichier donné, nous devons générer un répertoire et une liste de fichiers à rechercher. Deno fournit deno.readdir, qui fait partie de la bibliothèque "intégrée", ce qui signifie que vous n'avez pas à l'importer. Il est disponible dans l'espace de noms global.

deno.readdir est asynchrone et renvoie une liste de fichiers et de dossiers dans le répertoire actuel. Il renvoie ces éléments en tant qu'asynciterator, ce qui signifie que nous devons utiliser pour attendre ... de Loop pour obtenir le résultat:

<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>

Ce code lira et enregistrera chaque résultat du répertoire de travail actuel (fourni par deno.cwd ()). Cependant, si vous essayez d'exécuter le script maintenant, vous recevrez une erreur:

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

N'oubliez pas que Deno exige que tous les scripts obtiennent explicitement des autorisations à lire à partir du système de fichiers. Dans notre cas, l'indicateur --allow-read permettra à notre code d'exécuter:

<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>

Dans ce cas, j'exécute le script dans le répertoire de l'outil de construction, il trouve donc le code source TS, le référentiel .git et le dossier .vscode. Commençons à écrire certaines fonctions pour naviguer récursivement cette structure, car nous devons trouver tous les fichiers du répertoire, pas seulement les fichiers de niveau supérieur. De plus, nous pouvons ajouter des ignores communs. Je ne pense pas que quiconque voudrait que le script recherche le dossier .git entier!

Dans le code suivant, nous créons la fonction GetFilesList, qui prend un répertoire et renvoie tous les fichiers dans ce répertoire. Si un répertoire est rencontré, il s'appellera récursivement pour trouver des fichiers imbriqués et renvoyer le résultat:

<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>

Ensuite, nous pouvons l'utiliser comme ceci:

<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>

Nous obtenons également une sortie qui a l'air bien:

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

en utilisant le module de chemin

Nous pouvons maintenant combiner des chemins de fichier à l'aide de chaînes de modèle comme suit:

<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>

mais ce serait mieux avec le module de chemin de Deno. Ce module est l'un des modules que Deno propose dans le cadre de sa bibliothèque standard (très similaire à Node en utilisant son module de chemin), et si vous avez utilisé le module de chemin de Node, le code semble très similaire. Au moment de la rédaction du moment de la rédaction, la dernière version de la bibliothèque standard fournie par Deno est de 0,97.0, nous importons le module Path du fichier 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 est toujours le point d'entrée lors de l'importation des modules standard de Deno. La documentation de ce module est située sur le site Web de Deno et répertorie Path.join, qui empruntera plusieurs chemins et les rejoindra dans un seul chemin. Importons et utilisons les fonctions au lieu de les combiner manuellement:

... (Le reste du code est omis ici car il est répété avec le texte d'origine et a été modifié et optimisé dans la sortie précédente.)

... (Le reste du code est omis car il est répétitif de l'original et a déjà été modifié et optimisé dans la sortie précédente.)

::::::::::::::: : :::::::::::::::::::::::::::::::::::- : :::::::::::::::::::::::::::::::::::- : ::::::::::::::

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!