J'essaie d'obtenir une liste des noms de tous les fichiers présents dans un répertoire en utilisant Node.js. Je veux une sortie qui est un tableau de noms de fichiers. Comment puis-je faire ceci?

Vous pouvez utiliser les méthodes fs.readdirou fs.readdirSync.

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 différence entre les deux méthodes est que la première est asynchrone, vous devez donc fournir une fonction de rappel qui sera exécutée à la fin du processus de lecture.

Le second est synchrone, il renverra le tableau des noms de fichiers, mais il arrêtera toute autre exécution de votre code jusqu'à la fin du processus de lecture.

OMI, la façon la plus pratique d'effectuer de telles tâches est d'utiliser un outil global . Voici un package glob pour node.js. Installer avec

npm install glob

Ensuite, utilisez un caractère générique pour faire correspondre les noms de fichiers (exemple tiré du site Web du package)

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

La réponse ci-dessus n'effectue cependant pas de recherche récursive dans le répertoire. Voici ce que je l'ai fait pour une recherche récursive ( en utilisant le noeud de marche : 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);
});

Obtenez des fichiers dans tous les sous-répertoires

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

Voici une solution simple utilisant uniquement les modules natifs fset path:

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

ou version asynchrone (utilise à la fs.readdirplace):

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

Ensuite, vous appelez simplement (pour la version de synchronisation):

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

ou version asynchrone:

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

La différence réside dans la façon dont le nœud se bloque lors de l'exécution des E / S. Étant donné que l'API ci-dessus est la même, vous pouvez simplement utiliser la version asynchrone pour garantir des performances maximales.

Cependant, il existe un avantage à utiliser la version synchrone. Il est plus facile d'exécuter du code dès que la marche est terminée, comme dans l'instruction suivante après la marche. Avec la version asynchrone, vous auriez besoin d'un moyen supplémentaire de savoir quand vous avez terminé. Peut-être en créant d'abord une carte de tous les chemins, puis en les énumérant. Pour les scripts de construction / utilisation simples (par rapport aux serveurs Web hautes performances), vous pouvez utiliser la version de synchronisation sans causer de dommages.

Depuis Node v10.10.0, il est possible d'utiliser la nouvelle withFileTypesoption pourfs.readdir et fs.readdirSyncen combinaison avec la dirent.isDirectory()fonction de filtrage des noms de fichiers dans un répertoire. Cela ressemble à ceci:

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

Le tableau retourné est sous la forme:

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

Documents pour la classe fs.Dirent

Utilisation de promesses avec ES7

Utilisation asynchrone avec mz / fs

Le mzmodule fournit des versions promises de la bibliothèque de nœuds principaux. Leur utilisation est simple. Installez d'abord la bibliothèque ...

npm install mz

Alors...

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

Vous pouvez également les écrire dans des fonctions asynchrones dans ES7:

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

Mise à jour de la liste récursive

Certains utilisateurs ont indiqué leur souhait de voir une liste récursive (mais pas dans la question) ... Utiliser fs-promise. C'est un mince emballage autour mz.

npm install fs-promise;

puis...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));

Dépendances.

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

Définition.

// 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]);
  }, []);
}

Usage.

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

Veuillez noter que fileListc'est beaucoup trop optimiste. Pour tout problème grave, ajoutez une gestion des erreurs.

version non récursive

Vous ne dites pas que vous voulez le faire récursivement donc je suppose que vous n'avez besoin que des enfants directs du répertoire.

Exemple de code:

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

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

Charge fs:

const fs = require('fs');

Lire des fichiers asynchrones :

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

Lire la synchronisation des fichiers :

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

si quelqu'un cherche toujours ceci, je fais ceci:

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];
    }, []);

et son travail est très bon pour moi

Obtenez des sortednoms de fichiers. Vous pouvez filtrer les résultats en fonction d'un élément spécifique extensiontel que '.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();
}

Je suppose de votre question que vous ne voulez pas de noms de répertoires, juste des fichiers.

Exemple:

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

Si vous voulez juste un tableau des chemins de fichiers, utilisez 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'))

Retour:

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

Les crédits vont à https://gist.github.com/lovasoa/8691344#gistcomment-2927279

Voici une version récursive asynchrone.

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

A adopté l'approche générale de @ Hunan-Rostomyan, en a fait un petit excludeDirsargument plus concis et ajouté . Il serait trivial d'étendre avec includeDirs, suivez simplement le même modèle:

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]);
    }, []);
}

Exemple d'utilisation:

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));

Hors de la boîte

Dans le cas où vous souhaitez un objet avec la structure de répertoire prête à l'emploi, je vous recommande fortement de vérifier arborescence .

Disons que vous avez cette structure:

photos
│   june
│   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg

const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

Reviendra:

{
  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"
        }
      ]
    }
  ]
}

Objet personnalisé

Sinon, si vous souhaitez créer un objet d'arborescence de répertoires avec vos paramètres personnalisés, consultez l'extrait de code suivant. Un exemple en direct est visible sur ce codeandbox .

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

Ensuite, vous pouvez simplement faire:

// another-file.js 

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

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

Il s'agit d'une solution TypeScript, éventuellement récursive, optionnellement de journalisation des erreurs et asynchrone. Vous pouvez spécifier une expression régulière pour les noms de fichiers que vous souhaitez rechercher.

J'ai utilisé fs-extra, car c'est une super amélioration facile sur 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
}

Cela fonctionnera et stockera le résultat dans le fichier test.txt qui sera présent dans le même répertoire

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

J'ai récemment construit un outil pour cela qui fait juste cela ... Il récupère un répertoire de manière asynchrone et retourne une liste d'éléments. Vous pouvez obtenir des répertoires, des fichiers ou les deux, les dossiers étant les premiers. Vous pouvez également paginer les données dans le cas où vous ne souhaitez pas récupérer l'intégralité du dossier.

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

Ceci est le lien, j'espère qu'il aide quelqu'un!

Attention: si vous prévoyez d'effectuer des opérations sur chaque fichier d'un répertoire, essayez vinyl-fs (qui est utilisé par gulp , le système de génération de streaming).

J'ai fait un module de noeud pour automatiser cette tâche: mddir

Usage

noeud mddir "../relative/path/"

Pour installer: npm install mddir -g

Pour générer une démarque pour le répertoire actuel: mddir

Pour générer pour tout chemin absolu: mddir / absolu / chemin

Pour générer un chemin relatif: mddir ~ / Documents / que ce soit.

Le fichier md est généré dans votre répertoire de travail.

Ignore actuellement les modules node_modules et .git.

Dépannage

Si vous recevez l'erreur «nœud \ r: aucun fichier ou répertoire», le problème est que votre système d'exploitation utilise différentes fins de ligne et mddir ne peut pas les analyser sans que vous définissiez explicitement le style de fin de ligne sur Unix. Cela affecte généralement Windows, mais aussi certaines versions de Linux. La définition des fins de ligne sur le style Unix doit être effectuée dans le dossier bin global mddir npm.

Correction des fins de ligne

Obtenez le chemin du dossier bin npm avec:

npm config get prefix

Cd dans ce dossier

installer brew dos2unix

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

Cela convertit les fins de ligne en Unix au lieu de Dos

Exécutez ensuite normalement avec: node mddir "../relative/path/".

Exemple de structure de fichier de démarque générée '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

Utilisez le module npm list-contents . Il lit le contenu et le sous-contenu du répertoire donné et renvoie la liste des chemins des fichiers et des dossiers.

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