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

Du kannst den … benutzen fs.readdir oder fs.readdirSync Methoden. fs ist im Node.js-Kern enthalten, sodass Sie nichts installieren müssen.

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, sodass Sie eine Callback-Funktion bereitstellen müssen, die ausgeführt wird, wenn der Leseprozess endet.

Die zweite ist synchron, sie gibt das Dateinamenarray zurück, stoppt jedoch jede weitere Ausführung Ihres Codes, bis der Lesevorgang beendet ist.

IMO ist der bequemste Weg, solche Aufgaben zu erledigen, a Kugel Werkzeug. Hier ist ein Glob-Paket für node.js. Mit installieren

npm install glob

Verwenden Sie dann Platzhalter, um Dateinamen abzugleichen (Beispiel aus Paket’s Webseite)

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

Wenn Sie vorhaben zu verwenden rund Hier ist ein Beispiel, um nach XML-Dateien zu suchen, die sich im aktuellen Ordner befinden

var globby = require('globby');

const paths = await globby("**/*.xml");  

Die obige Antwort führt jedoch keine rekursive Suche im Verzeichnis durch. Folgendes habe ich für eine rekursive Suche getan (mit Knotenwanderung: 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 + "https://stackoverflow.com/" + stat.name);
    next();
});

walker.on('end', function() {
    console.log(files);
});

Holen Sie sich Dateien in allen Unterverzeichnissen

const fs=require('fs');

function getFiles (dir, files_){
    files_ = files_ || [];
    var files = fs.readdirSync(dir);
    for (var i in files){
        var name = dir + "https://stackoverflow.com/" + 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, die nur das native verwendet fs und path Module:

// 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.readdir stattdessen):

// 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 auf (für die Sync-Version):

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 blockiert, während er die E/A ausführt. Da die obige API dieselbe ist, könnten Sie einfach die asynchrone Version verwenden, um maximale Leistung sicherzustellen.

Es gibt jedoch einen Vorteil bei der Verwendung der synchronen Version. Es ist einfacher, Code auszuführen, sobald der Walk abgeschlossen ist, wie in der nächsten Anweisung nach dem Walk. Bei der asynchronen Version benötigen Sie eine zusätzliche Möglichkeit, um zu wissen, wann Sie fertig sind. Vielleicht zuerst eine Karte aller Pfade erstellen und sie dann aufzählen. Für einfache Build/Utility-Skripte (im Vergleich zu Hochleistungs-Webservern) könnten Sie die Sync-Version verwenden, ohne Schaden anzurichten.

Ab Node v10.10.0 ist es möglich, die neue zu verwenden withFileTypes Option für fs.readdir und fs.readdirSync in Kombination mit der dirent.isDirectory() Funktion zum Filtern nach Dateinamen in einem Verzeichnis. Das sieht so aus:

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

Das zurückgegebene Array hat die Form:

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

Dokumente für die fs.Dirent-Klasse

Promises mit ES7 verwenden

Asynchrone Nutzung mit mz/fs

Die mz -Modul stellt versprochene Versionen der Core-Node-Bibliothek bereit. 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 asynchronen Funktionen in ES7 schreiben:

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

Update für rekursive Auflistung

Einige der Benutzer haben den Wunsch angegeben, eine rekursive Auflistung zu sehen (wenn auch nicht in der Frage) … Verwenden 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));