Wie erhalten Sie eine Liste der Namen aller Dateien, die in einem Verzeichnis in Node.js vorhanden sind?

979

Ich versuche mit Node.js eine Liste der Namen aller in einem Verzeichnis vorhandenen Dateien zu erhalten. Ich möchte eine Ausgabe, die ein Array von Dateinamen ist. Wie kann ich das machen?

resopollution
quelle
9
fs.readdirfunktioniert, kann aber keine Dateinamen-Glob-Muster wie verwenden ls /tmp/*core*. Schauen Sie sich github.com/isaacs/node-glob an . Globs können sogar in Unterverzeichnissen suchen.
Jess
Checkout NPM readdir-recursiveModul, wenn Sie die Namen von Dateien auch in Unterverzeichnissen suchen
Ethan Davis
1
fs.readdir ist eine einfache asynchrone Lösung - Beispiele hier
am
Immer noch nicht mit einem Iterator antworten? Ich muss 2,5 Millionen Dateien scannen. Ich möchte nach 10 Minuten keine Liste mit 2,5 m Pfad erhalten.
Flavien Volken

Antworten:

1342

Sie können die Methoden fs.readdiroder fs.readdirSyncverwenden.

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

Der Unterschied zwischen den beiden Methoden besteht darin, dass die erste asynchron ist. Sie müssen daher eine Rückruffunktion bereitstellen, die ausgeführt wird, wenn der Lesevorgang endet.

Die zweite ist synchron. Sie gibt das Dateinamen-Array zurück, stoppt jedoch die weitere Ausführung Ihres Codes, bis der Lesevorgang endet.

CMS
quelle
204
Hinweis: readdirZeigt auch Verzeichnisnamen an . Verwenden Sie fs.stat(path, callback(err, stats))und, um diese zu filtern stats.isDirectory().
Rob W
3
Ich sollte hinzufügen, dass Sie höchstwahrscheinlich mit readdire arbeiten sollten, weil Sie IO im Knoten nicht blockieren möchten.
DragonKnight
5
@ user3705055, es sei denn, Sie verwenden gulp, um ein Verzeichnis von Dateien zu lesen, die von der Quellreihenfolge abhängen, und kompilieren Sie sie zu einer einzigen ausführbaren Datei.
r3wt
2
@Sancarn Sie möchten versuchen, die Ausgabe von zu analysieren ls? Warten Sie einfach, bis jemand einige Dateinamen mit eingebetteten Leerzeichen und Zeilenumbrüchen erstellt…
Radon Rosborough
201

IMO ist der bequemste Weg, solche Aufgaben zu erledigen, die Verwendung eines Glob- Tools. Hier ist ein Glob-Paket für node.js. Installieren mit

npm install glob

Verwenden Sie dann einen Platzhalter, um die Dateinamen abzugleichen (Beispiel von der Website des Pakets).

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.
})
KFL
quelle
5
Dies war die beste Lösung für mich, da ich den Dateityp einfacher angeben wollte als Zeichenfolgenvergleiche. Vielen Dank.
Pogrindis
Ich mag dieses auch, nur weil Globbing fast eine grundlegende Fähigkeit im Knoten ist. Wenn Sie nur Dateinamen zurückerhalten möchten, übergeben Sie ein cwdim Optionsobjekt.
JCollum
1
Wie können die Ergebnisse von globaußerhalb von sich selbst erhalten? Z.B. Ich möchte zu console.logden Ergebnissen, aber nicht drinnen glob()?
Lanti
13
@Lanti: Die glob.sync(pattern, [options])Methode ist möglicherweise einfacher zu verwenden, da sie einfach ein Array von Dateinamen zurückgibt, anstatt einen Rückruf zu verwenden. Weitere Infos hier: github.com/isaacs/node-glob
Glenn Lawrence
2
Für Leute wie mich, die nach einer Glob-Implementierung mit Promises suchen, besuchen Sie globby von sindresorhus: github.com/sindresorhus/globby
Nacho Coloma
180

Die obige Antwort führt jedoch keine rekursive Suche im Verzeichnis durch. Hier ist , was ich für eine rekursive Suche hat (unter Verwendung von Knoten-Spaziergang : 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);
});
Ruben Tan
quelle
4
fs.readdirSync ist eine bessere, native Alternative, die speziell dafür entwickelt wurde.
Eraden
37
fs.readdirSync geht leider nicht in Unterverzeichnisse, es sei denn, Sie sind bereit, Ihre eigene Routine zu schreiben, um genau das zu tun. Sie haben nicht angegeben, dass es bereits npm-Module gibt, um genau dieses Problem zu lösen.
Ruben Tan
6
Hier ist ein Link zum Walk Github Repo + Docs: github.com/coolaj86/node-walk
SantiagoIT
OP hat nicht gefragt, welche API einen rekursiven Lesevorgang durchführt. In jedem Fall liefert die akzeptierte Antwort, was auch als Grundlage für eine rekursive Lesung dienen kann.
Igwe Kalu
Dies ist eine fantastische Funktion. Kurze Frage: Gibt es eine schnelle Möglichkeit, bestimmte Verzeichnisse zu ignorieren? Ich möchte Verzeichnisse ignorieren, die mit.git
j_d
91

Holen Sie sich Dateien in allen Unterverzeichnissen

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'))
Tito100
quelle
4
Warum if (typeof files_ === 'undefined') files_=[];? Sie müssen nur var files_ = files_ || [];statt tun files_ = files_ || [];.
Jkutianski
4
Sie haben zu var fs = require('fs');Beginn vergessen, hinzuzufügen getFiles.
GFoley83
Dies ist eine rekursive Methode. Es werden keine sehr tiefen Ordnerstrukturen unterstützt, was zu einem Stapelüberlauf führt.
Mathias Lykkegaard Lorenzen
63

Hier ist eine einfache Lösung, bei der nur Native fsund pathModule verwendet werden:

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

oder asynchrone Version (verwendet fs.readdirstattdessen):

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

Dann rufen Sie einfach an (für die Synchronisierungsversion):

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

oder asynchrone Version:

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

Der Unterschied besteht darin, wie der Knoten während der Ausführung der E / A blockiert. Da die oben genannte API identisch ist, können Sie einfach die asynchrone Version verwenden, um maximale Leistung sicherzustellen.

Die Verwendung der synchronen Version bietet jedoch einen Vorteil. Es ist einfacher, Code auszuführen, sobald der Spaziergang abgeschlossen ist, wie in der nächsten Anweisung nach dem Spaziergang. Mit der asynchronen Version benötigen Sie eine zusätzliche Methode, um zu wissen, wann Sie fertig sind. Erstellen Sie möglicherweise zuerst eine Karte aller Pfade und führen Sie sie dann auf. Für einfache Build / Util-Skripte (im Vergleich zu Hochleistungs-Webservern) können Sie die Synchronisierungsversion verwenden, ohne Schaden zu verursachen.

Ali
quelle
1
Sollte die Leitung walkSyncvon walk(filePath, callback);biswalkSync(filePath, callback);
MIDE11
3
Sie verwenden jedoch weiterhin fs.statSync, das in der asynchronen Version blockiert. Sollten Sie nicht stattdessen fs.stat verwenden?
MindlessRanger
Dies ist sehr hilfreich und diese Methode ist rekursiv. Vielen Dank!
Little Roys
35

Ab Node 10.10.0 ist es möglich, die neue withFileTypesOption für fs.readdirund fs.readdirSyncin Kombination mit der dirent.isDirectory()Funktion zum Filtern nach Dateinamen in einem Verzeichnis zu verwenden. Das sieht so aus:

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

Das zurückgegebene Array hat folgende Form:

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

Dokumente für die Klasse fs.Dirent

bnp887
quelle
7
Bisher ist das hier die beste Antwort!
Alex Ivasyuv
2
Das ist es, wonach die Leute im Jahr 2020 suchen - sollte "festgesteckt" werden
Val Redchenko
1
Beste Antwort 2020!
Yves Lange
26

Versprechen mit ES7 verwenden

Asynchrone Verwendung mit mz / fs

Das mzModul bietet vielversprechende Versionen der Kernknotenbibliothek. Ihre Verwendung ist einfach. Installieren Sie zuerst die Bibliothek ...

npm install mz

Dann...

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

Alternativ können Sie sie in ES7 in asynchrone Funktionen schreiben:

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

Update für rekursive Auflistung

Einige Benutzer haben den Wunsch angegeben, eine rekursive Liste anzuzeigen (obwohl nicht in der Frage enthalten) ... Verwendung fs-promise. Es ist eine dünne Hülle herum mz.

npm install fs-promise;

dann...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));
Evan Carroll
quelle
5
fs.walk wird aus fs-versprechen entfernt, da es von fs nicht unterstützt wird ( github.com/kevinbeaty/fs-promise/issues/28 )
adnan
20

Abhängigkeiten.

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

Definition.

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

Verwendungszweck.

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

Bitte beachten Sie, dass dies fileListviel zu optimistisch ist. Fügen Sie bei schwerwiegenden Problemen eine Fehlerbehandlung hinzu.

Hunan Rostomyan
quelle
1
Ich habe auch ein excludeDirsArray-Argument hinzugefügt . Es ändert es genug, so dass Sie es vielleicht stattdessen bearbeiten sollten (wenn Sie es wollen). Ansonsten werde ich es in einer anderen Antwort hinzufügen. gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AT
1
@AT Schön! Sie sollten Ihre eigene Antwort posten, da dies eine nützliche Erweiterung ist. Lassen Sie uns dieses Stück ohne Merkmale halten.
Hunan Rostomyan
19

nicht rekursive Version

Sie sagen nicht, dass Sie es rekursiv tun möchten, also nehme ich an, dass Sie nur direkte untergeordnete Elemente des Verzeichnisses benötigen.

Beispielcode:

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

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

Laden fs:

const fs = require('fs');

Dateien asynchron lesen :

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

Lesen Sie Dateien sync :

var files = fs.readdirSync('./dir');
Eduardo Cuomo
quelle
10

Wenn noch jemand danach sucht, mache ich das:

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

und seine Arbeit ist sehr gut für mich

Josh
quelle
Hat super für mich funktioniert UND es ist rekursiv. Denken Sie daran, dass sich die Importsyntax immer noch hinter einem Flag in Node befindet. Möglicherweise müssen Sie den alten Weg gehen: const fs = require ('fs');
mjsarfatti
@ Josh Es funktioniert wie Charme. Es ist jedoch etwas schwierig zu verstehen, wie das [...files, ...getAllFiles(name)]oder [...files, name]funktioniert. Ein bisschen Erklärung wäre sehr hilfreich :)
Md Mazedul Islam Khan
1
@MdMazedulIslamKhan Die ...hier verwendete wird als Spread-Syntax bezeichnet. Grundsätzlich werden alle Objekte im Array übernommen und in das neue Array "verteilt". In diesem Fall werden alle Einträge innerhalb des filesArrays zusammen mit allen vom rekursiven Aufruf zurückgegebenen Werten zur Rückgabe hinzugefügt. Sie können sich hier auf die Spread-Syntax beziehen: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90
8

Erhalten Sie sortedDateinamen. Sie können die Ergebnisse filtern , basierend auf einem spezifischen extensionwie '.txt', '.jpg'und so weiter.

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

Ich gehe von Ihrer Frage aus, dass Sie keine Verzeichnisnamen, sondern nur Dateien möchten.

Beispiel:

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

Wenn Sie nur ein Array der Dateipfade möchten, verwenden Sie 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'))

kehrt zurück:

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

Credits gehen an https://gist.github.com/lovasoa/8691344#gistcomment-2927279

a.barbieri
quelle
5

Hier ist eine asynchrone rekursive Version.

    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()
    }
Oggy Transfluxitor Jones
quelle
4
Gewöhnen Sie sich an, am Ende Ihrer Anweisungen Semikolons hinzuzufügen. Sie können den Code sonst nicht minimieren. Trotzdem vielen Dank für den dringend benötigten asynchronen Beitrag.
user2867288
2
HAHAHAHA, das nicht Teil der Spezifikation ist, nur eine zufällige Person, die ihren bevorzugten Flusenstil "standardjs" nennt. Semikolons sind besonders in Javascript eine gute Praxis, um die Klarheit des Codes zu gewährleisten. Andernfalls müssen Sie und Ihr Team die Regeln für das automatische Einfügen von Semikolons auswendig lernen , und ich weiß, dass zumindest der durchschnittliche JS-Entwickler, in dem ich arbeite, nicht so fleißig ist.
user2867288
@ user2867288 Aber da ASI existiert, können wir es verwenden, nein? Ich verwende eslint und hübscher, um meinen Code beim regelmäßigen Speichern zu formatieren, und das Einfügen von Semikolons ist kein Problem.
Douira
5

Nahm den allgemeinen Ansatz von @ Hunan-Rostomyan, machte es ein wenig prägnanter und fügte excludeDirsArgumente hinzu . Es wäre trivial zu erweitern includeDirs, folgen Sie einfach dem gleichen Muster:

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

Anwendungsbeispiel:

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));
BEIM
quelle
Ich habe einen Hauptordner: scss und einen anderen Ordner: Themen, aber die endgültige Liste gibt mir alle Verzeichnisse, nicht nur Verzeichnisse ohne Ausschlussverzeichnis, was passiert?
SalahAdDin
Funktioniert nur gut mit '.' Ordnerverzeichnis, mit den restlichen Verzeichnissen funktioniert nicht.
SalahAdDin
5

Out of the Box

Für den Fall, dass Sie ein Objekt mit sofort einsatzbereiter Verzeichnisstruktur wünschen, empfehle ich Ihnen dringend, den Verzeichnisbaum zu überprüfen .

Nehmen wir an, Sie haben diese Struktur:

photos
   june
   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg
const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

Wird zurückkehren:

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

Benutzerdefiniertes Objekt

Wenn Sie andernfalls ein Verzeichnisbaumobjekt mit Ihren benutzerdefinierten Einstellungen erstellen möchten, sehen Sie sich das folgende Snippet an. Auf dieser Codesandbox ist ein Live-Beispiel sichtbar .

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

Dann können Sie einfach tun:

// another-file.js 

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

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

Dies ist eine TypeScript-Lösung, optional rekursiv, optional Fehlerprotokollierung und asynchrone Lösung. Sie können einen regulären Ausdruck für die Dateinamen angeben, die Sie suchen möchten.

Ich habe verwendet fs-extra, weil es eine einfache Super-Set-Verbesserung ist 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
}
Paul F. Wood
quelle
1

Dies funktioniert und speichert das Ergebnis in der Datei test.txt, die im selben Verzeichnis vorhanden ist

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

Ich habe kürzlich ein Tool dafür erstellt, das genau dies tut ... Es ruft ein Verzeichnis asynchron ab und gibt eine Liste von Elementen zurück. Sie können entweder Verzeichnisse, Dateien oder beides abrufen, wobei Ordner an erster Stelle stehen. Sie können die Daten auch paginieren, wenn Sie nicht den gesamten Ordner abrufen möchten.

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

Dies ist der Link, hoffe es hilft jemandem!

stefantigro
quelle
0

Nur ein Hinweis: Wenn Sie vorhaben, Vorgänge für jede Datei in einem Verzeichnis auszuführen, versuchen Sie es mit vinyl-fs (das von gulp , dem Streaming-Build-System, verwendet wird).

XåpplI'-I0llwlg'I -
quelle
0

Ich habe ein Knotenmodul erstellt, um diese Aufgabe zu automatisieren: mddir

Verwendungszweck

Knoten mddir "../relative/path/"

So installieren Sie: npm install mddir -g

So generieren Sie einen Abschlag für das aktuelle Verzeichnis: mddir

So generieren Sie für einen beliebigen absoluten Pfad: mddir / absolute / path

So generieren Sie für einen relativen Pfad: mddir ~ / Documents / Whatever.

Die MD-Datei wird in Ihrem Arbeitsverzeichnis generiert.

Ignoriert derzeit die Ordner node_modules und .git.

Fehlerbehebung

Wenn Sie die Fehlermeldung 'node \ r: Keine solche Datei oder kein solches Verzeichnis' erhalten, besteht das Problem darin, dass Ihr Betriebssystem unterschiedliche Zeilenenden verwendet und mddir diese nicht analysieren kann, ohne dass Sie den Zeilenendenstil explizit auf Unix setzen. Dies betrifft normalerweise Windows, aber auch einige Linux-Versionen. Das Festlegen von Zeilenenden auf den Unix-Stil muss im globalen bin-Ordner mddir npm erfolgen.

Zeilenenden reparieren

Holen Sie sich den npm bin Ordnerpfad mit:

npm config get prefix

CD in diesen Ordner

Gebräu installiere dos2unix

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

Dadurch werden Zeilenenden in Unix anstelle von Dos konvertiert

Führen Sie dann wie gewohnt Folgendes aus: node mddir "../relative/path/".

Beispiel für eine generierte Markdown-Dateistruktur '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
John Byrne
quelle
0

Verwenden Sie npm list-Inhalte - Modul. Es liest den Inhalt und den Unterinhalt des angegebenen Verzeichnisses und gibt die Liste der Dateipfade und Ordnerpfade zurück.

const list = require('list-contents');

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});
Paweł
quelle
-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);
        }
    }
}
Francois
quelle