¿Cómo se obtiene una lista de los nombres de todos los archivos presentes en un directorio en Node.js?

979

Estoy tratando de obtener una lista de los nombres de todos los archivos presentes en un directorio usando Node.js. Quiero una salida que sea una matriz de nombres de archivo. ¿Cómo puedo hacer esto?

resolución
fuente
99
fs.readdirfunciona, pero no puede usar patrones globales de nombre de archivo como ls /tmp/*core*. Visita github.com/isaacs/node-glob . Globs incluso puede buscar en subdirectorios.
Jess
Sin readdir-recursiveembargo, compruebe el módulo de NPM si también está buscando los nombres de archivos en subdirectorios
Ethan Davis,
1
fs.readdir es una solución asíncrona simple - ejemplos aquí
drorw
¿Todavía no responde usando un iterador? Tengo 2,5 millones de archivos para escanear ... No quiero obtener una lista de 2,5 m de ruta después de 10 minutos.
Flavien Volken

Respuestas:

1342

Puedes usar el fs.readdirofs.readdirSync métodos .

fs.readdir

const testFolder = './tests/';
const fs = require('fs');

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

fs.readdirSync

const testFolder = './tests/';
const fs = require('fs');

fs.readdirSync(testFolder).forEach(file => {
  console.log(file);
});

La diferencia entre los dos métodos es que el primero es asíncrono, por lo que debe proporcionar una función de devolución de llamada que se ejecutará cuando finalice el proceso de lectura.

El segundo es síncrono, devolverá la matriz de nombre de archivo, pero detendrá cualquier ejecución posterior de su código hasta que finalice el proceso de lectura.

CMS
fuente
204204
Nota: readdirtambién muestra los nombres de directorio . Para filtrarlos, use fs.stat(path, callback(err, stats))y stats.isDirectory().
Rob W
3
Debo agregar que lo más probable es que deba ir con readdire porque no desea bloquear IO en el nodo.
DragonKnight
55
@ user3705055 a menos que esté usando gulp para leer en un directorio de archivos dependientes del orden de origen y compilarlos en un solo ejecutable.
r3wt
2
@Sancarn ¿Desea intentar analizar la salida de ls? Solo espere hasta que alguien cree algunos nombres de archivo con espacios incrustados y líneas nuevas ...
Radon Rosborough
201

En mi opinión, la forma más conveniente de hacer tales tareas es utilizar una herramienta global . Aquí hay un paquete global para node.js. Instalar con

npm install glob

Luego use comodines para unir los nombres de los archivos (ejemplo tomado del sitio web del paquete)

var glob = require("glob")

// options is optional
glob("**/*.js", options, function (er, files) {
  // files is an array of filenames.
  // If the `nonull` option is set, and nothing
  // was found, then files is ["**/*.js"]
  // er is an error object or null.
})
KFL
fuente
55
Esta fue la mejor solución para mí, ya que quería especificar el tipo de archivo más fácil que las comparaciones de cadenas. Gracias.
Pogrindis
También me gusta este solo porque el globbing es casi una habilidad fundamental en el nodo. Si solo desea recuperar los nombres de archivo, pase un cwden el objeto de opciones.
jcollum
1
¿Cómo puede obtener los resultados globfuera de sí mismo? P.ej. Quiero console.loglos resultados, pero no dentro glob()?
Lanti
13
@Lanti: El glob.sync(pattern, [options])método puede ser más fácil de usar, ya que simplemente devuelve una matriz de nombres de archivos, en lugar de usar una devolución de llamada. Más información aquí: github.com/isaacs/node-glob
Glenn Lawrence
2
Para las personas como yo que buscan una implementación global usando Promises, consulte globby por sindresorhus: github.com/sindresorhus/globby
Nacho Coloma el
180

Sin embargo, la respuesta anterior no realiza una búsqueda recursiva en el directorio. Esto es lo que hice para una búsqueda recursiva (usando el nodo-paseo : npm install walk)

var walk    = require('walk');
var files   = [];

// Walker options
var walker  = walk.walk('./test', { followLinks: false });

walker.on('file', function(root, stat, next) {
    // Add this file to the list of files
    files.push(root + '/' + stat.name);
    next();
});

walker.on('end', function() {
    console.log(files);
});
Ruben Tan
fuente
44
fs.readdirSync es una mejor alternativa nativa creada especialmente para esto.
Eraden
37
Desafortunadamente, fs.readdirSync no ingresa a los subdirectorios, a menos que esté dispuesto a escribir su propia rutina para hacer exactamente eso, lo cual no considera que ya existen módulos npm para resolver este problema.
Ruben Tan
66
Aquí hay un enlace al walk github repo + docs: github.com/coolaj86/node-walk
santiagoIT
OP no preguntó sobre qué API realiza una lectura recursiva. En cualquier caso, la respuesta aceptada proporciona lo que también puede servir como base para hacer una lectura recursiva.
Igwe Kalu
Esta es una función fantástica. Pregunta rápida: ¿hay una manera rápida de ignorar ciertos directorios? Quiero ignorar los directorios que comienzan con.git
j_d
91

Obtener archivos en todos los subdirectorios

function getFiles (dir, files_){
    files_ = files_ || [];
    var files = fs.readdirSync(dir);
    for (var i in files){
        var name = dir + '/' + files[i];
        if (fs.statSync(name).isDirectory()){
            getFiles(name, files_);
        } else {
            files_.push(name);
        }
    }
    return files_;
}

console.log(getFiles('path/to/dir'))
Tito100
fuente
44
¿Por qué if (typeof files_ === 'undefined') files_=[];? solo necesitas hacer en var files_ = files_ || [];lugar de files_ = files_ || [];.
jkutianski
44
Olvidó agregar var fs = require('fs');al inicio de getFiles.
GFoley83 01 de
Este es un método recursivo. No admite estructuras de carpetas muy profundas, lo que provocará un desbordamiento de pila.
Mathias Lykkegaard Lorenzen
63

Aquí hay una solución simple que usa solo el nativo fsy los pathmódulos:

// sync version
function walkSync(currentDirPath, callback) {
    var fs = require('fs'),
        path = require('path');
    fs.readdirSync(currentDirPath).forEach(function (name) {
        var filePath = path.join(currentDirPath, name);
        var stat = fs.statSync(filePath);
        if (stat.isFile()) {
            callback(filePath, stat);
        } else if (stat.isDirectory()) {
            walkSync(filePath, callback);
        }
    });
}

o versión asíncrona (usa en su fs.readdirlugar):

// async version with basic error handling
function walk(currentDirPath, callback) {
    var fs = require('fs'),
        path = require('path');
    fs.readdir(currentDirPath, function (err, files) {
        if (err) {
            throw new Error(err);
        }
        files.forEach(function (name) {
            var filePath = path.join(currentDirPath, name);
            var stat = fs.statSync(filePath);
            if (stat.isFile()) {
                callback(filePath, stat);
            } else if (stat.isDirectory()) {
                walk(filePath, callback);
            }
        });
    });
}

Luego solo llama (para la versión de sincronización):

walkSync('path/to/root/dir', function(filePath, stat) {
    // do something with "filePath"...
});

o versión asíncrona:

walk('path/to/root/dir', function(filePath, stat) {
    // do something with "filePath"...
});

La diferencia está en cómo se bloquea el nodo mientras se realiza el IO. Dado que la API anterior es la misma, puede usar la versión asíncrona para garantizar el máximo rendimiento.

Sin embargo, hay una ventaja de usar la versión síncrona. Es más fácil ejecutar un código tan pronto como finalice la caminata, como en la siguiente declaración después de la caminata. Con la versión asíncrona, necesitaría alguna forma adicional de saber cuándo ha terminado. Tal vez crear un mapa de todos los caminos primero, luego enumerarlos. Para los scripts de compilación / utilidad simples (en comparación con los servidores web de alto rendimiento), puede usar la versión de sincronización sin causar ningún daño.

Ali
fuente
1
Debe reemplazar la línea walkSyncde walk(filePath, callback);awalkSync(filePath, callback);
MIDE11
3
Pero todavía está usando fs.statSync, que bloquea, en versión asíncrona. ¿No deberías estar usando fs.stat en su lugar?
MindlessRanger
Esto es realmente útil, y este método es recursivo. ¡Gracias!
Little Roys
35

A partir del Nodo v10.10.0, es posible utilizar la nueva withFileTypesopción para, fs.readdiry fs.readdirSyncen combinación con la dirent.isDirectory()función, filtrar los nombres de archivo en un directorio. Eso se ve así:

fs.readdirSync('./dirpath', {withFileTypes: true})
.filter(item => !item.isDirectory())
.map(item => item.name)

La matriz devuelta tiene la forma:

['file1.txt', 'file2.txt', 'file3.txt']

Documentos para la clase fs.Dirent

bnp887
fuente
77
¡Hasta ahora esa es la mejor respuesta aquí!
Alex Ivasyuv
2
esto es lo que la gente está buscando en 2020: debe ser "
anclado
1
¡La mejor respuesta 2020!
Yves Lange
26

Usando promesas con ES7

Uso asincrónico con mz / fs

El mzmódulo proporciona versiones prometidas de la biblioteca del nodo central. Usarlos es simple. Primero instale la biblioteca ...

npm install mz

Entonces...

const fs = require('mz/fs');
fs.readdir('./myDir').then(listing => console.log(listing))
  .catch(err => console.error(err));

Alternativamente, puede escribirlos en funciones asincrónicas en ES7:

async function myReaddir () {
  try {
    const file = await fs.readdir('./myDir/');
  }
  catch (err) { console.error( err ) }
};

Actualización para listado recursivo

Algunos de los usuarios han especificado el deseo de ver una lista recursiva (aunque no en la pregunta) ... Uso fs-promise. Es una envoltura delgada mz.

npm install fs-promise;

entonces...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));
Evan Carroll
fuente
55
fs.walk se elimina de fs-promise ya que no es compatible con fs ( github.com/kevinbeaty/fs-promise/issues/28 )
adnan
20

Dependencias

var fs = require('fs');
var path = require('path');

Definición.

// String -> [String]
function fileList(dir) {
  return fs.readdirSync(dir).reduce(function(list, file) {
    var name = path.join(dir, file);
    var isDir = fs.statSync(name).isDirectory();
    return list.concat(isDir ? fileList(name) : [name]);
  }, []);
}

Uso.

var DIR = '/usr/local/bin';

// 1. List all files in DIR
fileList(DIR);
// => ['/usr/local/bin/babel', '/usr/local/bin/bower', ...]

// 2. List all file names in DIR
fileList(DIR).map((file) => file.split(path.sep).slice(-1)[0]);
// => ['babel', 'bower', ...]

Tenga en cuenta que fileListes demasiado optimista. Para cualquier cosa grave, agregue algún manejo de errores.

Hunan Rostomyan
fuente
1
Agregué un excludeDirsargumento de matriz también. Lo cambia lo suficiente para que tal vez deba editarlo en su lugar (si lo desea). De lo contrario, lo agregaré en una respuesta diferente. gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AL
1
@AT Nice! Debes publicar tu propia respuesta, ya que es una extensión útil. Mantengamos este sin características.
Hunan Rostomyan
19

versión no recursiva

No dices que quieres hacerlo de forma recursiva, así que supongo que solo necesitas hijos directos del directorio.

Código de muestra:

const fs = require('fs');
const path = require('path');

fs.readdirSync('your-directory-path')
  .filter((file) => fs.lstatSync(path.join(folder, file)).isFile());
Tyler Long
fuente
10

Carga fs:

const fs = require('fs');

Leer archivos asíncronos :

fs.readdir('./dir', function (err, files) {
    // "files" is an Array with files names
});

Leer archivos sincronizados :

var files = fs.readdirSync('./dir');
Eduardo Cuomo
fuente
10

si alguien todavía busca esto, hago esto:

import fs from 'fs';
import path from 'path';

const getAllFiles = dir =>
    fs.readdirSync(dir).reduce((files, file) => {
        const name = path.join(dir, file);
        const isDirectory = fs.statSync(name).isDirectory();
        return isDirectory ? [...files, ...getAllFiles(name)] : [...files, name];
    }, []);

y su trabajo es muy bueno para mi

Josh
fuente
Funcionó muy bien para mí Y es recursivo. Solo recuerde que la sintaxis de importación todavía está detrás de una bandera en Node, es posible que deba seguir el camino anterior: const fs = require ('fs');
mjsarfatti
@ Josh Funciona a la perfección. Sin embargo, tener un poco de dificultad para entender cómo funciona el [...files, ...getAllFiles(name)]o [...files, name]. Un poco de explicación sería muy útil :)
Md Mazedul Islam Khan
1
@MdMazedulIslamKhan El ...utilizado aquí se llama sintaxis de propagación. Lo que básicamente hace es tomar todos los objetos dentro de la matriz y 'distribuirlos' en la nueva matriz. En este caso, todas las entradas dentro de la filesmatriz se agregan al retorno junto con todos los valores devueltos por la llamada recursiva. Puede consultar la sintaxis extendida aquí: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90
8

Obtener sortednombres de archivos. Puede filtrar los resultados en función de un elemento específico extensioncomo '.txt', '.jpg'etc.

import * as fs from 'fs';
import * as Path from 'path';

function getFilenames(path, extension) {
    return fs
        .readdirSync(path)
        .filter(
            item =>
                fs.statSync(Path.join(path, item)).isFile() &&
                (extension === undefined || Path.extname(item) === extension)
        )
        .sort();
}
Yas
fuente
6

Supongo por su pregunta que no desea nombres de directorios, solo archivos.

Ejemplo:

animals
├── all.jpg
├── mammals
   └── cat.jpg
   └── dog.jpg
└── insects
    └── bee.jpg

Si solo desea una matriz de rutas de archivos, use return_object: false:

const fs = require('fs').promises;
const path = require('path');

async function walk(dir) {
    let files = await fs.readdir(dir);
    files = await Promise.all(files.map(async file => {
        const filePath = path.join(dir, file);
        const stats = await fs.stat(filePath);
        if (stats.isDirectory()) return walk(filePath);
        else if(stats.isFile()) return filePath;
    }));

    return files.reduce((all, folderContents) => all.concat(folderContents), []);
}

console.log(walk('animals'))

devoluciones:

[
  "/animals/all.jpg",
  "/animals/mammals/cat.jpg",
  "/animals/mammals/dog.jpg",
  "/animals/insects/bee.jpg"
];

Los créditos van a https://gist.github.com/lovasoa/8691344#gistcomment-2927279

a.barbieri
fuente
5

Aquí hay una versión recursiva asincrónica.

    function ( path, callback){
     // the callback gets ( err, files) where files is an array of file names
     if( typeof callback !== 'function' ) return
     var
      result = []
      , files = [ path.replace( /\/\s*$/, '' ) ]
     function traverseFiles (){
      if( files.length ) {
       var name = files.shift()
       fs.stat(name, function( err, stats){
        if( err ){
         if( err.errno == 34 ) traverseFiles()
    // in case there's broken symbolic links or a bad path
    // skip file instead of sending error
         else callback(err)
        }
        else if ( stats.isDirectory() ) fs.readdir( name, function( err, files2 ){
         if( err ) callback(err)
         else {
          files = files2
           .map( function( file ){ return name + '/' + file } )
           .concat( files )
          traverseFiles()
         }
        })
        else{
         result.push(name)
         traverseFiles()
        }
       })
      }
      else callback( null, result )
     }
     traverseFiles()
    }
Oggy Transfluxitor Jones
fuente
44
Acostúmbrese a agregar punto y coma al final de sus declaraciones. No puede minificar el código de otra manera. Sin embargo, gracias por la tan necesaria contribución asíncrona.
user2867288
2
HAHAHAHA, eso no es parte de la especificación, solo una persona aleatoria que llama a su estilo de revestimiento preferido "standardjs". Los punto y coma son una buena práctica especialmente en Javascript para mantener la claridad del código. De lo contrario, usted y su equipo deben memorizar las reglas de inserción automática de punto y coma , y sé que al menos el desarrollador promedio de JS donde trabajo no es tan diligente.
usuario2867288
@ user2867288 Pero dado que ASI existe, podemos usarlo, ¿no? Utilizo eslint y más bonito para formatear mi código en guardar regularmente y la inserción de punto y coma no es un problema.
Douira
5

Tomó el enfoque general de @ Hunan-Rostomyan, lo hizo un excludeDirsargumento un poco más conciso y agregado . Sería trivial extenderlo includeDirs, solo siga el mismo patrón:

import * as fs from 'fs';
import * as path from 'path';

function fileList(dir, excludeDirs?) {
    return fs.readdirSync(dir).reduce(function (list, file) {
        const name = path.join(dir, file);
        if (fs.statSync(name).isDirectory()) {
            if (excludeDirs && excludeDirs.length) {
                excludeDirs = excludeDirs.map(d => path.normalize(d));
                const idx = name.indexOf(path.sep);
                const directory = name.slice(0, idx === -1 ? name.length : idx);
                if (excludeDirs.indexOf(directory) !== -1)
                    return list;
            }
            return list.concat(fileList(name, excludeDirs));
        }
        return list.concat([name]);
    }, []);
}

Ejemplo de uso:

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));
A
fuente
Tengo una carpeta principal: scss, y dentro de ella otra carpeta: temas, pero la lista final me da todos los directorios, no solo directorios sin excluir directorie, ¿qué sucede?
SalahAdDin
Solo funciona bien con '.' directorio de carpetas, con el resto de directorios no funciona.
SalahAdDin
5

Fuera de la caja

En caso de que desee un objeto con la estructura de directorios lista para usar, le recomiendo que revise el árbol de directorios .

Digamos que tienes esta estructura:

photos
   june
   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg
const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

Volveremos:

{
  path: "photos",
  name: "photos",
  size: 600,
  type: "directory",
  children: [
    {
      path: "photos/june",
      name: "june",
      size: 400,
      type: "directory",
      children: [
        {
          path: "photos/june/windsurf.jpg",
          name: "windsurf.jpg",
          size: 400,
          type: "file",
          extension: ".jpg"
        }
      ]
    },
    {
      path: "photos/january",
      name: "january",
      size: 200,
      type: "directory",
      children: [
        {
          path: "photos/january/ski.png",
          name: "ski.png",
          size: 100,
          type: "file",
          extension: ".png"
        },
        {
          path: "photos/january/snowboard.jpg",
          name: "snowboard.jpg",
          size: 100,
          type: "file",
          extension: ".jpg"
        }
      ]
    }
  ]
}

Objeto personalizado

De lo contrario, si desea crear un objeto de árbol de directorio con su configuración personalizada, eche un vistazo al siguiente fragmento. Un ejemplo en vivo es visible en este código y cuadro .

// my-script.js
const fs = require("fs");
const path = require("path");

const isDirectory = filePath => fs.statSync(filePath).isDirectory();
const isFile = filePath => fs.statSync(filePath).isFile();

const getDirectoryDetails = filePath => {
  const dirs = fs.readdirSync(filePath);
  return {
    dirs: dirs.filter(name => isDirectory(path.join(filePath, name))),
    files: dirs.filter(name => isFile(path.join(filePath, name)))
  };
};

const getFilesRecursively = (parentPath, currentFolder) => {
  const currentFolderPath = path.join(parentPath, currentFolder);
  let currentDirectoryDetails = getDirectoryDetails(currentFolderPath);

  const final = {
    current_dir: currentFolder,
    dirs: currentDirectoryDetails.dirs.map(dir =>
      getFilesRecursively(currentFolderPath, dir)
    ),
    files: currentDirectoryDetails.files
  };

  return final;
};

const getAllFiles = relativePath => {
  const fullPath = path.join(__dirname, relativePath);
  const parentDirectoryPath = path.dirname(fullPath);
  const leafDirectory = path.basename(fullPath);

  const allFiles = getFilesRecursively(parentDirectoryPath, leafDirectory);
  return allFiles;
};

module.exports = { getAllFiles };

Entonces simplemente puedes hacer:

// another-file.js 

const { getAllFiles } = require("path/to/my-script");

const allFiles = getAllFiles("/path/to/my-directory");
Mahesh
fuente
3

Este es un TypeScript, opcionalmente recursivo, opcionalmente registro de errores y solución asíncrona. Puede especificar una expresión regular para los nombres de archivo que desea encontrar.

Solía fs-extra, porque es una mejora fácil de super set fs.

import * as FsExtra from 'fs-extra'

/**
 * Finds files in the folder that match filePattern, optionally passing back errors .
 * If folderDepth isn't specified, only the first level is searched. Otherwise anything up
 * to Infinity is supported.
 *
 * @static
 * @param {string} folder The folder to start in.
 * @param {string} [filePattern='.*'] A regular expression of the files you want to find.
 * @param {(Error[] | undefined)} [errors=undefined]
 * @param {number} [folderDepth=0]
 * @returns {Promise<string[]>}
 * @memberof FileHelper
 */
public static async findFiles(
    folder: string,
    filePattern: string = '.*',
    errors: Error[] | undefined = undefined,
    folderDepth: number = 0
): Promise<string[]> {
    const results: string[] = []

    // Get all files from the folder
    let items = await FsExtra.readdir(folder).catch(error => {
        if (errors) {
            errors.push(error) // Save errors if we wish (e.g. folder perms issues)
        }

        return results
    })

    // Go through to the required depth and no further
    folderDepth = folderDepth - 1

    // Loop through the results, possibly recurse
    for (const item of items) {
        try {
            const fullPath = Path.join(folder, item)

            if (
                FsExtra.statSync(fullPath).isDirectory() &&
                folderDepth > -1)
            ) {
                // Its a folder, recursively get the child folders' files
                results.push(
                    ...(await FileHelper.findFiles(fullPath, filePattern, errors, folderDepth))
                )
            } else {
                // Filter by the file name pattern, if there is one
                if (filePattern === '.*' || item.search(new RegExp(filePattern, 'i')) > -1) {
                    results.push(fullPath)
                }
            }
        } catch (error) {
            if (errors) {
                errors.push(error) // Save errors if we wish
            }
        }
    }

    return results
}
Paul F. Wood
fuente
1

Esto funcionará y almacenará el resultado en el archivo test.txt que estará presente en el mismo directorio

  fs.readdirSync(__dirname).forEach(file => {
    fs.appendFileSync("test.txt", file+"\n", function(err){
    })
})
Rama
fuente
1

Recientemente he creado una herramienta para esto que hace exactamente esto ... Obtiene un directorio de forma asincrónica y devuelve una lista de elementos. Puede obtener directorios, archivos o ambos, siendo las carpetas las primeras. También puede paginar los datos en caso de que no desee recuperar toda la carpeta.

https://www.npmjs.com/package/fs-browser

Este es el enlace, ¡espero que ayude a alguien!

stefantigro
fuente
0

Solo un aviso: si está planeando realizar operaciones en cada archivo en un directorio, pruebe vinyl-fs (que es utilizado por gulp , el sistema de compilación de transmisión).

XåpplI'-I0llwlg'I -
fuente
0

Hice un módulo de nodo para automatizar esta tarea: mddir

Uso

nodo mddir "../relative/path/"

Para instalar: npm install mddir -g

Para generar rebajas para el directorio actual: mddir

Para generar para cualquier ruta absoluta: mddir / absolute / path

Para generar una ruta relativa: mddir ~ / Documentos / lo que sea.

El archivo md se genera en su directorio de trabajo.

Actualmente ignora los módulos node_modules y .git.

Solución de problemas

Si recibe el error 'nodo \ r: No existe tal archivo o directorio', el problema es que su sistema operativo utiliza diferentes finales de línea y mddir no puede analizarlos sin que configure explícitamente el estilo de final de línea en Unix. Esto generalmente afecta a Windows, pero también a algunas versiones de Linux. La configuración de los finales de línea al estilo Unix debe realizarse dentro de la carpeta bin global mddir npm.

Fijación de terminaciones de línea

Obtenga la ruta de la carpeta bin de npm con:

npm config get prefix

Cd en esa carpeta

instalar brew dos2unix

dos2unix lib / node_modules / mddir / src / mddir.js

Esto convierte las terminaciones de línea a Unix en lugar de Dos

Luego, ejecute normalmente con: node mddir "../relative/path/".

Ejemplo de estructura de archivo de reducción generada 'directorioLista.md'

    |-- .bowerrc
    |-- .jshintrc
    |-- .jshintrc2
    |-- Gruntfile.js
    |-- README.md
    |-- bower.json
    |-- karma.conf.js
    |-- package.json
    |-- app
        |-- app.js
        |-- db.js
        |-- directoryList.md
        |-- index.html
        |-- mddir.js
        |-- routing.js
        |-- server.js
        |-- _api
            |-- api.groups.js
            |-- api.posts.js
            |-- api.users.js
            |-- api.widgets.js
        |-- _components
            |-- directives
                |-- directives.module.js
                |-- vendor
                    |-- directive.draganddrop.js
            |-- helpers
                |-- helpers.module.js
                |-- proprietary
                    |-- factory.actionDispatcher.js
            |-- services
                |-- services.cardTemplates.js
                |-- services.cards.js
                |-- services.groups.js
                |-- services.posts.js
                |-- services.users.js
                |-- services.widgets.js
        |-- _mocks
            |-- mocks.groups.js
            |-- mocks.posts.js
            |-- mocks.users.js
            |-- mocks.widgets.js
John Byrne
fuente
0

Utilice el módulo de npm lista de contenidos . Lee los contenidos y sub-contenidos del directorio dado y devuelve la lista de rutas de archivos y carpetas.

const list = require('list-contents');

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});
Paweł
fuente
-1
function getFilesRecursiveSync(dir, fileList, optionalFilterFunction) {
    if (!fileList) {
        grunt.log.error("Variable 'fileList' is undefined or NULL.");
        return;
    }
    var files = fs.readdirSync(dir);
    for (var i in files) {
        if (!files.hasOwnProperty(i)) continue;
        var name = dir + '/' + files[i];
        if (fs.statSync(name).isDirectory()) {
            getFilesRecursiveSync(name, fileList, optionalFilterFunction);
        } else {
            if (optionalFilterFunction && optionalFilterFunction(name) !== true)
                continue;
            fileList.push(name);
        }
    }
}
Francois
fuente