Nodo: Listar archivos en un directorio

En este tutorial, aprenderemos cómo listar archivos en un directorio usando Node.js. Usaremos el árbol de directorios del paquete NPM para esto, así como el módulo fs incorporado.

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 integrado, así como el módulo directory-tree de NPM para enumerar todos los archivos de un directorio.

Leeremos un directorio, files, ubicado en el mismo lugar en el que se encuentra nuestro archivo app.js:

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

El directorio contiene:

1
2
3
4
5
files
   anotherDirectory
   └── fileInDirectory.txt
└── textFile.txt
└── anotherTextFile.txt

árbol de directorios

directory-tree es un práctico módulo NPM que se encarga de esta tarea por nosotros y formatea la salida muy bien. Primero, vamos a instalarlo:

1
$ npm install directory-tree

Ahora, importémoslo en nuestro script y proporcionemos la ubicación de nuestro directorio:

1
2
3
4
const dirTree = require("directory-tree");

const tree = dirTree('./files/');
console.log(tree);

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
{
  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 en función de las cuales nos gustaría filtrar, usando la función dirTree():

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

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

fs.readdir()

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

Avancemos y enumeremos los archivos del directorio files:

1
2
3
4
5
6
7
8
const directory = './files/';
const fs = require('fs');

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

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

Luego, proporcionamos el directorio a la función readdir() y registramos su nombre a través de una devolución de llamada. Esto resulta en:

1
2
3
4
anotherDirectory
anotherTextFile.txt
textFile.txt
textFile.txt - Shortcut.lnk

Nota: La función readdir() también lee directorios, pero sin indicar 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 la función fs.lstatSync() para ayudarnos con esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
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);
    }
  });
});

Usando isDirectory(), hemos verificado si lo que estamos encontrando en la ruta dada es un directorio o un archivo. Esto ahora resulta en:

1
2
3
4
Directory: anotherDirectory
File: anotherTextFile.txt
File: file
File: textFile.txt

fs.readdirSync()

La función readdirSync() es prácticamente la misma que la función readdir(), pero se 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:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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. Comprobación de archivos y directorios, cambiando el flujo ligeramente en función de los resultados. Este código imprime:

1
2
3
4
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 NPM creado para este propósito, después de lo cual hemos usó el módulo integrado fs y sus funciones readdir() y readdirSync() para listar los archivos.