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

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?

preguntado el 28 de abril de 10 a las 03:04

fs.readdir funciona, pero no puede usar patrones globales de nombre de archivo como ls /tmp/*core*. Verificar github.com/isaacs/node-glob. Globs puede incluso buscar en subdirectorios. -

Verifique los NPM readdir-recursive sin embargo, si también está buscando los nombres de los archivos en los subdirectorios,

fs.readdir es una solución asincrónica simple - ejemplos aquí -

¿Aún no respondes con 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. -

26 Respuestas

Puede utilizar el fs.readdir or fs.readdirSync métodos. fs está incluido en el núcleo de Node.js, por lo que no es necesario instalar nada.

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 asincrónico, 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 sincrónico, devolverá la matriz de nombre de archivo, pero detendrá cualquier ejecución adicional de su código hasta que finalice el proceso de lectura.

Respondido el 30 de enero de 21 a las 20:01

Nota: readdir también muestra nombres de directorio. Para filtrar estos, use fs.stat(path, callback(err, stats)) y stats.isDirectory(). - Rob W

Debo agregar que lo más probable es que deba optar por readdire porque no desea bloquear IO en el nodo. - Caballero Dragón

@ 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

@Sancarn Quieres intentar analizar la salida de ls? Espere hasta que alguien cree algunos nombres de archivo con espacios incrustados y nuevas líneas ... - radón rosborough

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

npm install glob

Luego use comodines para hacer coincidir los nombres de archivo (ejemplo tomado del paquete sitio web)

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

Respondido el 31 de enero de 21 a las 00:01

esta fue la mejor solución para mí, ya que quería especificar el tipo de archivo más fácilmente que las comparaciones de cadenas. Gracias. - Pogrindis

Este también me gusta solo porque el globbing es casi una habilidad fundamental en node. Si solo desea recuperar los nombres de archivo, pase un cwd en el objeto de opciones. - jcollum

¿Cómo se pueden obtener los resultados de glob fuera de sí mismo? P.ej. yo quiero console.log los resultados, pero no por dentro glob()? - Lanti

@Lanti: El glob.sync(pattern, [options]) El método puede ser más fácil de usar, ya que simplemente devuelve una matriz de nombres de archivo, en lugar de usar una devolución de llamada. Más info aquí: github.com/isaacs/node-glob - glenn lorenzo

Para personas como yo que buscan una implementación global usando Promises, consulte globby de sindresorhus: github.com/sindresorhus/globby - Nacho coloma

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 caminata de nodo: 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);
});

Respondido 21 ago 14, 14:08

fs.readdirSync es mejor, alternativa nativa creada especialmente para esto. - Eraden

fs.readdirSync no ingresa a los subdirectorios, desafortunadamente, a menos que esté dispuesto a escribir su propia rutina para hacer precisamente eso, lo cual no es cierto, dado que ya existen módulos npm para resolver este mismo problema. - Rubén Tan

Aquí hay un enlace al repositorio de github walk + docs: github.com/coolaj86/node-walk - santiagoIT

OP no preguntó qué API hace una lectura recursiva. En cualquier caso, la respuesta aceptada proporciona lo que también puede servir como base para realizar una lectura recursiva. - Igwe Kalu

Esta es una función fantástica. Pregunta rápida: ¿hay una forma rápida de ignorar ciertos directorios? Quiero ignorar los directorios que comienzan con .git - j_d

Obtener archivos en todos los subdirectorios

const fs=require('fs');

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

Respondido 10 Feb 21, 18:02

Por qué if (typeof files_ === 'undefined') files_=[];? solo necesitas hacer var files_ = files_ || []; en lugar de files_ = files_ || [];. - jkutianski

Olvidaste agregar var fs = require('fs'); al inicio de getFiles. - GFoley83

Este es un método recursivo. No admite estructuras de carpetas muy profundas, lo que resultará en un desbordamiento de pila. - Mathias Lykkegaard Lorenzen

Aquí hay una solución simple que usa solo el nativo fs y path mó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 (utiliza fs.readdir en lugar de):

// 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 sincronizada):

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 la E / S. Dado que la API anterior es la misma, puede usar la versión asíncrona para garantizar el máximo rendimiento.

Sin embargo, existe una ventaja al utilizar la versión síncrona. Es más fácil ejecutar algún código tan pronto como se realiza la caminata, como en la siguiente instrucción después de la caminata. Con la versión asíncrona, necesitaría una forma adicional de saber cuándo ha terminado. Quizás crear primero un mapa de todas las rutas y luego enumerarlas. Para scripts de construcción / utilidades simples (frente a servidores web de alto rendimiento), puede usar la versión de sincronización sin causar ningún daño.

respondido 30 mar '16, 05:03

Debería reemplazar la línea en walkSync del walk(filePath, callback); a walkSync(filePath, callback); - MIDE11

Pero todavía está usando fs.statSync, que bloquea, en la versión asincrónica. ¿No debería usar fs.stat en su lugar? - Guardabosques sin sentido

Esto es realmente útil y este método es recursivo. ¡Gracias! - pequeños roy

A partir de Node v10.10.0, es posible utilizar el nuevo withFileTypes opción para fs.readdir y fs.readdirSync en combinación con el dirent.isDirectory() función para 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

Respondido el 30 de enero de 19 a las 11:01

esto es lo que la gente está buscando en 2020 - debería estar "anclado" - Valle Redchenko

Usar promesas con ES7

Uso asincrónico con mz / fs

La mz El módulo proporciona versiones promisificadas de la biblioteca de nodos centrales. 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) ... Use fs-promise. Es una envoltura delgada alrededor 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));

contestado el 30 de mayo de 16 a las 20:05

fs.walk se elimina de fs-promise ya que no es compatible con fs ( github.com/kevinbeaty/fs-promise/issues/28 ) - Adnan

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', ...]

este producto está hecho por encargo con un tiempo de producción de XNUMX a XNUMX semanas fileList es demasiado optimista. Para cualquier cosa seria, agregue un poco de manejo de errores.

Respondido el 14 de enero de 16 a las 06:01

Agregué un excludeDirs Argumento de matriz también. Lo cambia lo suficiente como para que quizás deba editarlo en su lugar (si lo desea). De lo contrario, lo agregaré en una respuesta diferente. gist.github.com/AlecTaylor/f3f221b4fb86b4375650 - AT

@AT ¡Niza! Debería publicar su propia respuesta, ya que es una extensión útil. Mantengamos este sin rasgos distintivos. - hunan rostomyan

versión no recursiva

No dice que quiere hacerlo de forma recursiva, así que supongo que solo necesita 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());

Respondido 31 Jul 19, 18:07

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

Ejemplo de estructura de directorio

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

Walk función

Los créditos van a justin maier in esta esencia

Si desea solo una matriz de los archivos que utilizan las rutas 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), []);
}

Uso

async function main() {
   console.log(await walk('animals'))
}

Salida

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

Respondido el 19 de Septiembre de 20 a las 14:09

@justmaier & a.barbieri - ¡gracias por el código y la respuesta! - KyleMit

hola si también quiero mostrar la carpeta, ¿qué debo hacer? como `[" /animals/todos.jpg "," / animales / mamíferos "" /animals/mammals/cat.jpg "," /animals/mammals/dog.jpg "," /animals/insects/bee.jpg " ]; `cualquier solución - Aakash

Hola @Aakash, intenta agregar files.unshift(dir) antes del último return de la función asincrónica. De todos modos, sería mejor si pudiera crear una nueva pregunta, ya que podría ayudar a otras personas con la misma necesidad y recibir mejores comentarios. ;-) - barbieri

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

Respondido el 27 de enero de 19 a las 10:01

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 las mil maravillas. Sin embargo, teniendo un poco de dificultad para entender cómo [...files, ...getAllFiles(name)] or [...files, name] obras. Sería muy útil una pequeña explicación :) - Md Mazedul Islam Khan

@MdMazedulIslamKhan El ... usado aquí se llama sintaxis de propagación. Lo que básicamente hace es tomar todos los objetos dentro de la matriz y 'esparcirlos' en la nueva matriz. En este caso, todas las entradas dentro del files La matriz se agrega a la devolución junto con todos los valores devueltos por la llamada recursiva. Puede consultar la sintaxis de propagación aquí: desarrollador.mozilla.org/en-US/docs/Web/JavaScript/Reference/… - T90

Carga fs:

const fs = require('fs');

Leer archivos Asincrónico:

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

Leer archivos sincronizar:

var files = fs.readdirSync('./dir');

Respondido el 13 de Septiembre de 16 a las 18:09

Consiga una sorted nombres de archivo. Puede filtrar los resultados en función de un extension como '.txt', '.jpg' y así sucesivamente.

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

Respondido 21 Feb 18, 15:02

Fuera de la caja

En caso de que quieras un objeto con la estructura de directorio fuera de la caja, le recomiendo encarecidamente que compruebe árbol-directorio.

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

Regresará:

{
  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 codigos y caja.

// 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 puedes simplemente hacer:

// another-file.js 

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

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

Respondido 13 Feb 20, 12:02

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

respondido 03 mar '14, 18:03

Adquiera el hábito de agregar punto y coma al final de sus declaraciones. De lo contrario, no puede minimizar el código. Sin embargo, gracias por la contribución asincrónica tan necesaria. - user2867288

HAHAHAHA eso no es parte de la especificación, solo una persona al azar que llama a su estilo de pelusa preferido "standardjs". Los puntos y comas 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 de JS promedio donde trabajo no es tan diligente. - user2867288

@ user2867288 Pero dado que ASI existe, podemos usarlo, ¿no? Utilizo eslint y más bonito para formatear mi código al guardar con regularidad y la inserción de punto y coma no es un problema. - Douira

Tomó el enfoque general de @ Hunan-Rostomyan, lo hizo un poco más conciso y agregó excludeDirs argumento. Sería trivial extenderme con includeDirs, solo sigue 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']));

Respondido el 15 de enero de 16 a las 00:01

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é pasa? - SalahAdDin

Solo funciona bien con '.' directorio de carpetas, con el resto de directorios no funciona. - SalahAdDin

Mis 2 centavos si alguien:

Solo quiero listar nombres de archivos (excluyendo directorios) de una subcarpeta local en su proyecto

  • ✅ Sin dependencias adicionales
  • ✅ 1 función
  • ✅ Normalizar ruta (Unix vs. Windows)
const fs = require("fs");
const path = require("path");

/**
 * @param {string} relativeName "resources/foo/goo"
 * @return {string[]}
 */
const listFileNames = (relativeName) => {
  try {
    const folderPath = path.join(process.cwd(), ...relativeName.split("/"));
    return fs
      .readdirSync(folderPath, { withFileTypes: true })
      .filter((dirent) => dirent.isFile())
      .map((dirent) => dirent.name.split(".")[0]);
  } catch (err) {
    // ...
  }
};

README.md
package.json
resources
 |-- countries
    |-- usa.yaml
    |-- japan.yaml
    |-- gb.yaml
    |-- provinces
       |-- .........


listFileNames("resources/countries") #=> ["usa", "japan", "gb"]

Respondido el 21 de Septiembre de 20 a las 09:09

Tienes el problema donde path es el nombre de tu importado require('path') pero luego vuelves a definir const path dentro de la función ... ¡Esto es realmente confuso y podría provocar errores! - mesqueeb

Esta es una solución TypeScript, opcionalmente recursiva, opcionalmente de registro de errores y asincrónica. Puede especificar una expresión regular para los nombres de archivo que desea buscar.

solía fs-extra, porque es una mejora superconjunto fácil en 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
}

Respondido 18 Abr '19, 15:04

Solo un aviso: si planea realizar operaciones en cada archivo en un directorio, intente vinilo-fs (que es usado por trago, el sistema de compilación de transmisión).

Respondido el 12 de junio de 14 a las 06:06

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

Respondido 19 Jul 19, 05:07

Recientemente construí 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, con las carpetas en primer lugar. También puede paginar los datos en caso de que no desee recuperar la carpeta completa.

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

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

Respondido 11 Abr '20, 22:04

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 / absoluta / ruta

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

El archivo md se genera en su directorio de trabajo.

Actualmente ignora las carpetas node_modules y .git.

Solucionando problemas

Si recibe el error 'node \ r: No such file or directory', el problema es que su sistema operativo usa diferentes finales de línea y mddir no puede analizarlos sin que usted establezca explícitamente el estilo de final de línea en Unix. Esto suele afectar 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.

Corrección de finales de línea

Obtenga la ruta de la carpeta npm bin con:

npm config get prefix

Cd en esa carpeta

brew instalar dos2unix

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

Esto convierte los finales de línea a Unix en lugar de Dos

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

Ejemplo de estructura de archivo de rebajas generada 'directoryList.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

Respondido 28 Oct 17, 05:10

Utiliza npm contenido de la lista módulo. Lee el contenido y subcontenido 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);
});

Respondido 23 Jul 18, 11:07

Yo suelo usar: FS-Extra.

const fileNameArray = Fse.readdir('/some/path');

Resultado:

[
  "b7c8a93c-45b3-4de8-b9b5-a0bf28fb986e.jpg",
  "daeb1c5b-809f-4434-8fd9-410140789933.jpg"
]

Respondido 07 Jul 20, 23:07

Si muchas de las opciones anteriores parecen demasiado complejas o no, lo que está buscando aquí es otro enfoque que usa node-dir: https://github.com/fshost/node-dir

npm install node-dir

Aquí hay una función simple para enumerar todos los archivos .xml que buscan en subdirectorios

import * as nDir from 'node-dir' ;

listXMLs(rootFolderPath) {
    let xmlFiles ;

    nDir.files(rootFolderPath, function(err, items) {
        xmlFiles = items.filter(i => {
            return path.extname(i) === '.xml' ;
        }) ;
        console.log(xmlFiles) ;       
    });
}

Respondido 15 Feb 21, 14:02

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

Respondido 01 Abr '14, 16:04

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.