node: Mostrar archivos en un directorio

    Introducción

    Trabajar con archivos es una tarea común con cualquier lenguaje de programación. La manipulación de archivos requiere que conozcamos su ubicación. Una de las formas más fundamentales de interactuar con los archivos es enumerar los archivos en un directorio.

    En este artículo, usaremos Node.js y el módulo fs incorporado, así como el módulo de árbol de directorios de NPM para enumerar todos los archivos de un directorio.

    Leeremos un directorio files, ubicado en el mismo lugar nuestro app.js el archivo está en:

    09/10/2020  01:27 PM               332 app.js
    09/10/2020  01:24 PM    <DIR>          files
    

    El directorio contiene:

    files
    │   anotherDirectory
    │   └── fileInDirectory.txt
    └── textFile.txt
    └── anotherTextFile.txt
    

    árbol-directorio

    directory-tree es un módulo de NPM útil que se encarga de esta tarea por nosotros y formatea la salida de manera agradable. Primero, instalémoslo:

    $ npm install directory-tree
    

    Ahora, importémoslo a nuestro script y proporcionémosle la ubicación de nuestro directorio:

    const dirTree = require("directory-tree");
    
    const tree = dirTree('./files/');
    console.log(tree);
    

    los tree constante ahora contiene la información a la que nos gustaría acceder. Este código da como resultado:

    {
      path: './files/',
      name: 'files',
      children: [
        {
          path: 'files\anotherDirectory',
          name: 'anotherDirectory',
          children: [Array],
          size: 8,
          type: 'directory'
        },
        {
          path: 'files\anotherTextFile.txt',
          name: 'anotherTextFile.txt',
          size: 2218,
          extension: '.txt',
          type: 'file'
        },
        {
          path: 'files\textFile.txt',
          name: 'textFile.txt',
          size: 7,
          extension: '.txt',
          type: 'file'
        }
      ],
      size: 2233,
      type: 'directory'
    }
    

    También podemos especificar las extensiones por las que nos gustaría filtrar, usando el dirTree() función:

    const tree = dirTree('./files/', {extensions:/.js$/});
    console.log(tree);
    

    Esto devolvería un resultado vacío ya que no hay archivos JS en el files directorio.

    fs.readdir ()

    La forma más sencilla de leer archivos de un directorio sin módulos externos es con la ayuda del readdir() función. Es asincrónico y devuelve una matriz que contiene nombres de archivo en el directorio que ha especificado.

    Sigamos adelante y enumeremos los archivos del files directorio:

    const directory = './files/';
    const fs = require('fs');
    
    fs.readdir(directory, (err, files) => {
        files.forEach(file => {
            console.log(file);
        });
    });
    

    Aquí, hemos especificado el directory constante, apuntando al files carpeta, después de lo cual, hemos importado el fs módulo.

    Entonces, hemos proporcionado el directory al readdir() función y registró su nombre a través de una devolución de llamada. Esto resulta en:

    anotherDirectory
    anotherTextFile.txt
    textFile.txt
    textFile.txt - Shortcut.lnk
    

    Nota: los readdir() La función también lee directorios, pero sin una indicación de si es un directorio o un archivo. En este caso, un archivo sin extensión tiene el mismo aspecto que un directorio.

    Sin embargo, podemos usar el fs.lstatSync() función para ayudarnos con esto:

    const directory = './files/';
    const path = require('path');
    const fs = require('fs');
    
    fs.readdir(directory, (err, files) => {
      files.forEach(file => {
        if (fs.lstatSync(path.resolve(directory, file)).isDirectory()) {
          console.log('Directory: ' + file);
        } else {
          console.log('File: ' + file);
        }
      });
    });
    

    Utilizando isDirectory(), hemos comprobado si lo que encontramos en la ruta dada es un directorio o un archivo. Esto ahora resulta en:

    Directory: anotherDirectory
    File: anotherTextFile.txt
    File: file
    File: textFile.txt
    

    fs.readdirSync ()

    los readdirSync() La función es prácticamente la misma que la readdir() función, pero lee de forma sincrónica, en lugar de asincrónica.

    Funciona de la misma manera que el enfoque anterior: solo maneja la operación de forma sincrónica:

    const directory = './files/';
    const path = require('path');
    const fs = require('fs');
    
    fs.readdirSync(directory).forEach(file => {
      if (fs.lstatSync(path.resolve(directory, file)).isDirectory()) {
        console.log('Directory: ' + file);
      } else {
        console.log('File: ' + file);
      }
    });
    

    Aquí, hemos hecho lo mismo que hemos hecho antes. Comprobando archivos y directorios, cambiando ligeramente el flujo según los resultados. Este código se imprime:

    Directory: anotherDirectory
    File: anotherTextFile.txt
    File: file
    File: textFile.txt
    

    Conclusión

    En este artículo, hemos repasado algunas formas de listar archivos en un directorio en Node.js. Comenzamos con directory-tree, un paquete de NPM creado para este propósito, después de lo cual usamos el paquete integrado fs módulo y su readdir() y readdirSync() funciones para listar los archivos.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *