Tengo un pequeño problema con mi función. Me gustaría obtener todos los archivos en muchos directorios. Actualmente, puedo recuperar los archivos en el archivo pasado en parámetros. Me gustaría recuperar los archivos html de cada carpeta en la carpeta pasada como parámetro. Explicaré si pongo el parámetro "test". Recupero los archivos en "test" pero me gustaría recuperar "test / 1 / *. Html", "test / 2 / . / . html ":

var srcpath2 = path.join('.', 'diapo', result);
function getDirectories(srcpath2) {
                return fs.readdirSync(srcpath2).filter(function (file) {
                    return fs.statSync(path.join(srcpath2, file)).isDirectory();
                });
            }

El resultado: [1,2,3]

¡Gracias!

21
user6285277 4 ene. 2017 a las 14:22

7 respuestas

La mejor respuesta

Parece que el glob paquete npm te ayudaría. Aquí hay un ejemplo de cómo usarlo:

Jerarquía de archivos:

test
├── one.html
└── test-nested
    └── two.html

Código JS:

var getDirectories = function (src, callback) {
  glob(src + '/**/*', callback);
};
getDirectories('test', function (err, res) {
  if (err) {
    console.log('Error', err);
  } else {
    console.log(res);
  }
});

Que muestra:

[ 'test/one.html',
  'test/test-nested',
  'test/test-nested/two.html' ]
42
Paul Mougel 4 ene. 2017 a las 11:32

Aquí está el mío. Como todas las buenas respuestas, es difícil de entender:

const isDirectory = path => statSync(path).isDirectory();
const getDirectories = path =>
    readdirSync(path).map(name => join(path, name)).filter(isDirectory);

const isFile = path => statSync(path).isFile();  
const getFiles = path =>
    readdirSync(path).map(name => join(path, name)).filter(isFile);

const getFilesRecursively = (path) => {
    let dirs = getDirectories(path);
    let files = dirs
        .map(dir => getFilesRecursively(dir)) // go through each directory
        .reduce((a,b) => a.concat(b), []);    // map returns a 2d array (array of file arrays) so flatten
    return files.concat(getFiles(path));
};
7
user875234 26 nov. 2017 a las 02:45

Necesitaba algo similar, en una aplicación Electron: obtener todas las subcarpetas en una carpeta base dada, usando TypeScript, y se me ocurrió esto:

import { readdirSync, statSync, existsSync } from "fs";
import * as path from "path";

// recursive synchronous "walk" through a folder structure, with the given base path
getAllSubFolders = (baseFolder, folderList = []) => {

    let folders:string[] = readdirSync(baseFolder).filter(file => statSync(path.join(baseFolder, file)).isDirectory());
    folders.forEach(folder => {
        folderList.push(path.join(baseFolder,folder));
        this.getAllSubFolders(path.join(baseFolder,folder), folderList);
    });
}
3
Ben 7 nov. 2017 a las 15:09
const fs = require('fs');
const path = require('path');
var filesCollection = [];
const directoriesToSkip = ['bower_components', 'node_modules', 'www', 'platforms'];

function readDirectorySynchronously(directory) {
    var currentDirectorypath = path.join(__dirname + directory);

    var currentDirectory = fs.readdirSync(currentDirectorypath, 'utf8');

    currentDirectory.forEach(file => {
        var fileShouldBeSkipped = directoriesToSkip.indexOf(file) > -1;
        var pathOfCurrentItem = path.join(__dirname + directory + '/' + file);
        if (!fileShouldBeSkipped && fs.statSync(pathOfCurrentItem).isFile()) {
            filesCollection.push(pathOfCurrentItem);
        }
        else if (!fileShouldBeSkipped) {
            var directorypath = path.join(directory + '\\' + file);
            readDirectorySynchronously(directorypath);
        }
    });
}

readDirectorySynchronously('');

Esto llenará filesCollection con todos los archivos en el directorio y sus subdirectorios (es recursivo). Tiene la opción de omitir algunos nombres de directorio en la matriz directoriosToSkip .

3
vvn050 19 mar. 2018 a las 13:35

Empaquetado en la biblioteca: https://www.npmjs.com/package/node-recursive-directory

https://github.com/vvmspace/node-recursive-directory

Lista de archivos:

const getFiles = require('node-resursive-directory');

(async () => {
    const files = await getFiles('/home');
    console.log(files);
})()

Lista de archivos con datos analizados:

const getFiles = require('node-resursive-directory');
 
(async () => {
    const files = await getFiles('/home', true); // add true
    console.log(files);
})()

Obtendrás algo así:

  [
      ...,
      {
        fullpath: '/home/vvm/Downloads/images/Some/Some Image.jpg',
        filepath: '/home/vvm/Downloads/images/Some/',
        filename: 'Some Image.jpg',
        dirname: 'Some'
    },
  ]
2
Vladimir Myagdeev 25 jun. 2020 a las 10:24

Hice el mío con mecanografiado funciona bastante fácil de entender

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

    export const getAllSubFolders = (
      baseFolder: string,
      folderList: string[] = []
    ) => {
      const folders: string[] = fs
        .readdirSync(baseFolder)
        .filter(file => fs.statSync(path.join(baseFolder, file)).isDirectory());
      folders.forEach(folder => {
        folderList.push(path.join(baseFolder, folder));
        getAllSubFolders(path.join(baseFolder, folder), folderList);
      });
      return folderList;
    };
    export const getFilesInFolder = (rootPath: string) => {
      return fs
        .readdirSync(rootPath)
        .filter(
          filePath => !fs.statSync(path.join(rootPath, filePath)).isDirectory()
        )
        .map(filePath => path.normalize(path.join(rootPath, filePath)));
    };
    export const getFilesRecursively = (rootPath: string) => {
      const subFolders: string[] = getAllSubFolders(rootPath);
      const allFiles: string[][] = subFolders.map(folder =>
        getFilesInFolder(folder)
      );
      return [].concat.apply([], allFiles);
    };
0
Chris Sprance 3 nov. 2018 a las 17:11

También puede escribir su propio código como el siguiente para recorrer el directorio como se muestra a continuación:

var fs = require('fs');
function traverseDirectory(dirname, callback) {
  var directory = [];
  fs.readdir(dirname, function(err, list) {
    dirname = fs.realpathSync(dirname);
    if (err) {
      return callback(err);
    }
    var listlength = list.length;
    list.forEach(function(file) {
      file = dirname + '\\' + file;
      fs.stat(file, function(err, stat) {
        directory.push(file);
 if (stat && stat.isDirectory()) {
          traverseDirectory(file, function(err, parsed) {
     directory = directory.concat(parsed);
     if (!--listlength) {
       callback(null, directory);
     }
   });
 } else {
     if (!--listlength) {
       callback(null, directory);
     }
          }
      });
    });
  });
}
traverseDirectory(__dirname, function(err, result) {
  if (err) {
    console.log(err);
  }
  console.log(result);
});

Puede consultar más información al respecto aquí: http : //www.codingdefined.com/2014/09/how-to-navigate-through-directories-in.html

1
CodingDefined 5 ene. 2017 a las 11:13