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?

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.

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.
})

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);
});

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

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.

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

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

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.

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());

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');

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

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();
}

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

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()
    }

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']));

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");

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
}

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){
    })
})

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!

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

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

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);
});

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);
        }
    }
}