Comment obtenir une liste des noms de tous les fichiers présents dans un répertoire dans Node.js?


979

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?


9
fs.readdirfonctionne, mais ne peut pas utiliser des modèles glob de nom de fichier comme ls /tmp/*core*. Consultez github.com/isaacs/node-glob . Les globes peuvent même rechercher dans des sous-répertoires.
Jess

Vérifiez le readdir-recursivemodule de NPM si vous recherchez également les noms des fichiers dans les sous-répertoires
Ethan Davis


1
fs.readdir est une solution asynchrone simple - exemples ici
drorw

Vous ne répondez toujours pas à l'aide d'un itérateur? J'ai 2,5 millions de fichiers à analyser… Je ne veux pas obtenir une liste de 2,5 m de chemin après 10 minutes.
Flavien Volken

Réponses:


1342

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.


204
Remarque: readdiraffiche également les noms de répertoire . Pour les filtrer, utilisez fs.stat(path, callback(err, stats))et stats.isDirectory().
Rob W

3
Je dois ajouter que vous devriez probablement utiliser readdire parce que vous ne voulez pas bloquer les E / S dans le nœud.
DragonKnight

5
@ user3705055, sauf si vous utilisez gulp pour lire dans un répertoire de fichiers dépendants de l'ordre source et les compiler en un seul exécutable.
r3wt


2
@Sancarn Vous voulez essayer d'analyser la sortie de ls? Attendez juste que quelqu'un crée des noms de fichiers avec des espaces intégrés et des nouvelles lignes…
Radon Rosborough

201

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

5
c'était la meilleure solution pour moi car je voulais spécifier le type de fichier plus facilement que les comparaisons de chaînes. Merci.
Pogrindis du

J'aime aussi celui-ci juste parce que le globbing est presque une compétence fondamentale dans le nœud. Si vous souhaitez simplement récupérer les noms de fichiers, saisissez un cwddans l'objet options.
jcollum

1
Comment obtenir les résultats de l' globextérieur de lui-même? Par exemple. Je veux console.logles résultats, mais pas à l'intérieur glob()?
Lanti

13
@Lanti: La glob.sync(pattern, [options])méthode peut être plus facile à utiliser car elle renvoie simplement un tableau de noms de fichiers, plutôt que d'utiliser un rappel. Plus d'infos ici: github.com/isaacs/node-glob
Glenn Lawrence

2
Pour les gens comme moi qui recherchent une implémentation de glob en utilisant Promises, consultez globby par sindresorhus: github.com/sindresorhus/globby
Nacho Coloma

180

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

4
fs.readdirSync est une meilleure alternative native créée spécialement pour cela.
Eraden

37
fs.readdirSync ne marche malheureusement pas dans les sous-répertoires, sauf si vous êtes prêt à écrire votre propre routine pour faire exactement cela, ce que vous n'avez pas indiqué qu'il existe déjà des modules npm pour résoudre ce problème.
Ruben Tan

6
Voici un lien vers la marche github repo + docs: github.com/coolaj86/node-walk
santiagoIT

OP n'a pas demandé quelle API effectuait une lecture récursive. Dans tous les cas, la réponse acceptée fournit ce qui peut également servir de base à une lecture récursive.
Igwe Kalu

C'est une fonction fantastique. Question rapide: existe-t-il un moyen rapide d'ignorer certains répertoires? Je veux ignorer les répertoires commençant par.git
j_d

91

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

4
Pourquoi if (typeof files_ === 'undefined') files_=[];? vous n'avez qu'à faire à la var files_ = files_ || [];place de files_ = files_ || [];.
jkutianski

4
Vous avez oublié d'ajouter var fs = require('fs');au début de getFiles.
GFoley83

Il s'agit d'une méthode récursive. Il ne prend pas en charge les structures de dossiers très profondes, ce qui entraînera un débordement de pile.
Mathias Lykkegaard Lorenzen

63

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.


1
Devrait remplacer la ligne walkSyncde walk(filePath, callback);àwalkSync(filePath, callback);
MIDE11

3
Mais vous utilisez toujours fs.statSync, qui bloque, en version asynchrone. Ne devriez-vous pas utiliser fs.stat à la place?
MindlessRanger

C'est vraiment utile et cette méthode est récursive. Merci!
Little Roys

35

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


7
Jusqu'à présent, c'est la meilleure réponse ici!
Alex Ivasyuv

2
c'est ce que les gens recherchent en 2020 - devrait être "épinglé"
Val Redchenko

1
Meilleure réponse 2020!
Yves Lange

26

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

5
fs.walk est supprimé de fs-promise car il n'est pas pris en charge par fs ( github.com/kevinbeaty/fs-promise/issues/28 )
adnan

20

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.


1
J'ai également ajouté un excludeDirsargument de tableau. Il le change suffisamment pour que vous puissiez le modifier à la place (si vous le souhaitez). Sinon, je vais l'ajouter dans une réponse différente. gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AU

1
@AT Nice! Vous devez publier votre propre réponse, car c'est une extension utile. Gardons celui-ci sans particularité.
Hunan Rostomyan

19

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

10

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

10

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


Fonctionne très bien pour moi ET c'est récursif. N'oubliez pas que la syntaxe d'importation est toujours derrière un indicateur dans Node, vous devrez peut-être suivre l'ancienne méthode: const fs = require ('fs');
mjsarfatti

@Josh Cela fonctionne comme un charme. Cependant, ayant un peu de difficulté à comprendre comment fonctionne le [...files, ...getAllFiles(name)]ou [...files, name]. Un peu d'explication serait très utile :)
Md Mazedul Islam Khan

1
@MdMazedulIslamKhan L' ...utilisé ici est appelé une syntaxe étalée. Ce qu'il fait, c'est de prendre tous les objets à l'intérieur du tableau et de les «propager» dans le nouveau tableau. Dans ce cas, toutes les entrées à l'intérieur du filestableau sont ajoutées au retour avec toutes les valeurs renvoyées par l'appel récursif. Vous pouvez vous référer à la syntaxe étendue ici: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90

8

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

6

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


5

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

4
Prenez l'habitude d'ajouter des points-virgules à la fin de vos déclarations. Vous ne pouvez pas réduire le code autrement. Néanmoins, merci pour la contribution asynchrone si nécessaire.
user2867288

2
HAHAHAHA qui ne fait pas partie de la spécification, juste une personne aléatoire appelant son style de peluche préféré "standardjs". Les points-virgules sont une bonne pratique en particulier en Javascript pour maintenir la clarté du code. Sinon, vous et votre équipe devez mémoriser les règles de l'insertion automatique de points-virgules , et je connais au moins le développeur JS moyen où je travaille n'est pas si diligent.
user2867288

@ user2867288 Mais puisque l'ASI existe, nous pouvons l'utiliser, non? J'utilise eslint et plus joli pour formater mon code lors de l'enregistrement régulier et l'insertion de points-virgules n'est pas un problème.
douira

5

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

J'ai un dossier principal: scss, et à l'intérieur un autre dossier: thèmes, mais la liste finale me donne tous les répertoires, pas seulement les répertoires sans répertoire d'exclusion, que se passe-t-il?
SalahAdDin

Fonctionne très bien avec '.' répertoire de dossiers, avec les autres répertoires ne fonctionne pas.
SalahAdDin

5

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

3

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
}

1

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

1

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!


0

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


0

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

0

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

-1
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);
        }
    }
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.