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?

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.

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

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

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

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.

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

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

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.

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

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

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

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

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

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

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

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

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
}

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

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!

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

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

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

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