Holen Sie sich alle Verzeichnisse im Verzeichnis Node.js

Question

Ich hatte gehofft, dass dies eine einfache Sache wäre, aber ich kann nichts finden, um dies zu tun.

Ich möchte einfach alle Ordner/Verzeichnisse innerhalb eines bestimmten Ordners/Verzeichnisses erhalten.

Zum Beispiel:

|- SomeFolder
|- SomeOtherFolder
|- SomeFile.txt
|- SomeOtherFile.txt
|- x-directory

Ich würde erwarten, ein Array von zu erhalten:

["SomeFolder", "SomeOtherFolder", "x-directory"]

Oder das oben Gesagte mit dem Pfad, wenn es so serviert wurde...

Gibt es also bereits etwas, das das oben Genannte tut?

Answer 1

Mit node.js-Version >= v10.13.0, wird fs.readdirSync ein Array von fs.Dirent-Objekten zurückgeben, wenn die withFileTypes-Option auf true gesetzt ist.

Also kannst du verwenden,

const fs = require('fs')

const directories = source => fs.readdirSync(source, {
   withFileTypes: true
}).reduce((a, c) => {
   c.isDirectory() && a.push(c.name)
   return a
}, [])

Answer 2

Alternativ, wenn Sie externe Bibliotheken verwenden können, können Sie filehound verwenden. Es unterstützt Callbacks, Promises und synchrone Aufrufe.

Verwendung von Promises:

const Filehound = require('filehound');

Filehound.create()
  .path("MeinOrdner")
  .directory() // nur nach Verzeichnissen suchen
  .find()
  .then((subdirectories) => {
    console.log(subdirectories);
  });

Verwendung von Callbacks:

const Filehound = require('filehound');

Filehound.create()
  .path("MeinOrdner")
  .directory()
  .find((err, subdirectories) => {
    if (err) return console.error(err);

    console.log(subdirectories);
  });

Synchroner Aufruf:

const Filehound = require('filehound');

const subdirectories = Filehound.create()
  .path("MeinOrdner")
  .directory()
  .findSync();

console.log(subdirectories);

Für weitere Informationen (und Beispiele) schauen Sie sich die Dokumentation an: https://github.com/nspragg/filehound

Haftungsausschluss: Ich bin der Autor.

Answer 3

Unter Verwendung von fs-extra, das die asynchronen fs-Aufrufe verspricht, und der neuen await async-Syntax:

const fs = require("fs-extra");

async function getDirectories(path){
    let filesAndDirectories = await fs.readdir(path);

    let directories = [];
    await Promise.all(
        filesAndDirectories.map(name =>{
            return fs.stat(path + name)
            .then(stat =>{
                if(stat.isDirectory()) directories.push(name)
            })
        })
    );
    return directories;
}

let directories = await getDirectories("/")

Answer 4

Diese Antwort verwendet keine blockierenden Funktionen wie readdirSync oder statSync. Sie verwendet keine externen Abhängigkeiten und befindet sich nicht in den Tiefen der Rückrufhölle.

Stattdessen verwenden wir moderne JavaScript-Annehmlichkeiten wie Promises und async-await-Syntax. Und asynchrone Ergebnisse werden parallel und nicht sequenziell verarbeitet -

const { readdir, stat } =
  require("fs").promises

const { join } =
  require("path")

const dirs = async (path = ".") =>
  (await stat(path)).isDirectory()
    ? Promise
        .all
          ((await readdir(path))
              .map(p => dirs(join(path, p)))
          )
        .then
          (results =>
              [].concat(path, ...results)
          )
    : []

Ich werde ein Beispiel-Paket installieren und dann unsere Funktion testen -

$ npm install ramda
$ node

Lassen Sie uns sehen, wie es funktioniert -

> dirs(".").then(console.log, console.error)

[ '.'
, 'node_modules'
, 'node_modules/ramda'
, 'node_modules/ramda/dist'
, 'node_modules/ramda/es'
, 'node_modules/ramda/es/internal'
, 'node_modules/ramda/src'
, 'node_modules/ramda/src/internal'
]

---

Mit einem verallgemeinerten Modul, Parallel, können wir die Definition von dirs vereinfachen -

const Parallel =
  require("./Parallel")

const dirs = async (path = ".") =>
  (await stat(path)).isDirectory()
    ? Parallel(readdir(path))
        .flatMap(f => dirs(join(path, f)))
        .then(results => [path, ...results])
    : []

Das oben verwendete Parallel-Modul war ein Muster, das aus einer Reihe von Funktionen extrahiert wurde, die entworfen wurden, um ein ähnliches Problem zu lösen. Für weitere Erklärungen siehe diese verwandte Q&A.

Answer 5

Und eine asynchrone Version von getDirectories, benötigen Sie das async Modul dafür:

var fs = require('fs');
var path = require('path');
var async = require('async'); // https://github.com/caolan/async

// Originalfunktion
function getDirsSync(srcpath) {
  return fs.readdirSync(srcpath).filter(function(file) {
    return fs.statSync(path.join(srcpath, file)).isDirectory();
  });
}

function getDirs(srcpath, cb) {
  fs.readdir(srcpath, function (err, files) {
    if(err) { 
      console.error(err);
      return cb([]);
    }
    var iterator = function (file, cb)  {
      fs.stat(path.join(srcpath, file), function (err, stats) {
        if(err) { 
          console.error(err);
          return cb(false);
        }
        cb(stats.isDirectory());
      })
    }
    async.filter(files, iterator, cb);
  });
}