web-dev-qa-db-fra.com

Obtenir tous les fichiers récursivement dans les répertoires NodejS

J'ai un petit problème avec ma fonction. Je voudrais obtenir tous les fichiers dans de nombreux répertoires. Actuellement, je peux récupérer les fichiers du fichier passé en paramètres. Je voudrais récupérer les fichiers html de chaque dossier dans le dossier passé en paramètre. Je vais expliquer si je mets en paramètre "test" je récupère les fichiers dans "test" mais je voudrais récupérer "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();
                });
            }

Le résultat: [1,2,3]

merci !

node.jsfsgetfiles
7
user6285277

Il semble que le paquet glob npm pourrait vous aider. Voici un exemple d'utilisation:

Hiérarchie des fichiers:

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

Code JS:

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

qui affiche:

[ 'test/one.html',
  'test/test-nested',
  'test/test-nested/two.html' ]
16
Paul Mougel

J'avais besoin de quelque chose de similaire dans une application Electron: obtenir tous les sous-dossiers d'un dossier de base donné, en utilisant TypeScript, et voici ce qui suit:

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

Cela remplira filesCollection avec tous les fichiers du répertoire et de ses sous-répertoires (c’est récursif). Vous avez la possibilité d'omettre certains noms de répertoires dans le répertoire DirectoriesToSkip .

1
vvn050

Voilà le mien. Comme toutes les bonnes réponses, il est difficile de comprendre:

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

Vous pouvez également écrire votre propre code comme ci-dessous pour parcourir le répertoire comme indiqué ci-dessous:

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

Vous pouvez vérifier plus d'informations à ce sujet ici: http://www.codingdefined.com/2014/09/how-to-navigate-through-directories-in.html

0
CodingDefined

J'ai fait le mien avec TypeScript fonctionne bien assez facile à comprendre

    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