获取目录 nodejs 中的所有目录

Get all directories within directory nodejs

提问by Grofit

I was hoping this would be a simple thing, but I cannot find anything out there to do so.

我希望这将是一件简单的事情，但我找不到任何可以这样做的东西。

I just want to get all folders/directories within a given folder/directory.

我只想获取给定文件夹/目录中的所有文件夹/目录。

So for example:

例如：

<MyFolder>
|- SomeFolder
|- SomeOtherFolder
|- SomeFile.txt
|- SomeOtherFile.txt
|- x-directory

I would expect to get an array of:

我希望得到一个数组：

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

Or the above with the path if that was how it was served...

或者上面的路径，如果那是它的服务方式......

So does anything already exist to do the above?

那么是否已经存在任何东西来执行上述操作？

回答by Nick McCurdy

Here's a shorter, syncronous version of this answerthat can list all directories (hidden or not) in the current directory:

这是此答案的一个较短的同步版本，可以列出当前目录中的所有目录（隐藏或不隐藏）：

const { lstatSync, readdirSync } = require('fs')
const { join } = require('path')

const isDirectory = source => lstatSync(source).isDirectory()
const getDirectories = source =>
  readdirSync(source).map(name => join(source, name)).filter(isDirectory)

Update for Node 10.10.0+

节点 10.10.0+ 的更新

We can use the new withFileTypesoption of readdirSyncto skip the extra lstatSynccall:

我们可以使用新的withFileTypes选项readdirSync来跳过额外的lstatSync调用：

const { readdirSync } = require('fs')

const getDirectories = source =>
  readdirSync(source, { withFileTypes: true })
    .filter(dirent => dirent.isDirectory())
    .map(dirent => dirent.name)

回答by pravdomil

Thanks to JavaScript ES6 (ES2015) syntax features it's one liner:

多亏了 JavaScript ES6 (ES2015) 语法特性，它是一行代码：

Synchronous version

同步版本

const { readdirSync, statSync } = require('fs')
const { join } = require('path')

const dirs = p => readdirSync(p).filter(f => statSync(join(p, f)).isDirectory())

Asynchronous version for Node.js 10+ (experimental)

Node.js 10+ 的异步版本（实验性）

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

const dirs = async path => {
  let dirs = []
  for (const file of await readdir(path)) {
    if ((await stat(join(path, file))).isDirectory()) {
      dirs = [...dirs, file]
    }
  }
  return dirs
}

回答by Titlacauan

List directories using a path.

使用路径列出目录。

function getDirectories(path) {
  return fs.readdirSync(path).filter(function (file) {
    return fs.statSync(path+'/'+file).isDirectory();
  });
}

回答by Patrick McElhaney

Recursive solution

递归解

I came here in search of a way to get all of the subdirectories, and all of their subdirectories, etc. Building on the accepted answer, I wrote this:

我来这里是为了寻找一种获取所有子目录及其所有子目录等的方法。基于已接受的答案，我写了以下内容：

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

function flatten(lists) {
  return lists.reduce((a, b) => a.concat(b), []);
}

function getDirectories(srcpath) {
  return fs.readdirSync(srcpath)
    .map(file => path.join(srcpath, file))
    .filter(path => fs.statSync(path).isDirectory());
}

function getDirectoriesRecursive(srcpath) {
  return [srcpath, ...flatten(getDirectories(srcpath).map(getDirectoriesRecursive))];
}

回答by nicksweet

This should do it:

这应该这样做：

CoffeeScript (sync)

CoffeeScript（同步）

fs = require 'fs'

getDirs = (rootDir) ->
    files = fs.readdirSync(rootDir)
    dirs = []

    for file in files
        if file[0] != '.'
            filePath = "#{rootDir}/#{file}"
            stat = fs.statSync(filePath)

            if stat.isDirectory()
                dirs.push(file)

    return dirs

CoffeeScript (async)

CoffeeScript（异步）

fs = require 'fs'

getDirs = (rootDir, cb) ->
    fs.readdir rootDir, (err, files) ->
        dirs = []

        for file, index in files
            if file[0] != '.'
                filePath = "#{rootDir}/#{file}"
                fs.stat filePath, (err, stat) ->
                    if stat.isDirectory()
                        dirs.push(file)
                    if files.length == (index + 1)
                        cb(dirs)

JavaScript (async)

JavaScript（异步）

var fs = require('fs');
var getDirs = function(rootDir, cb) { 
    fs.readdir(rootDir, function(err, files) { 
        var dirs = []; 
        for (var index = 0; index < files.length; ++index) { 
            var file = files[index]; 
            if (file[0] !== '.') { 
                var filePath = rootDir + '/' + file; 
                fs.stat(filePath, function(err, stat) {
                    if (stat.isDirectory()) { 
                        dirs.push(this.file); 
                    } 
                    if (files.length === (this.index + 1)) { 
                        return cb(dirs); 
                    } 
                }.bind({index: index, file: file})); 
            }
        }
    });
}

回答by nickool

Alternatively, if you are able to use external libraries, you can use filehound. It supports callbacks, promises and sync calls.

或者，如果您能够使用外部库，则可以使用filehound. 它支持回调、承诺和同步调用。

Using promises:

使用承诺：

const Filehound = require('filehound');

Filehound.create()
  .path("MyFolder")
  .directory() // only search for directories
  .find()
  .then((subdirectories) => {
    console.log(subdirectories);
  });

Using callbacks:

使用回调：

const Filehound = require('filehound');

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

    console.log(subdirectories);
  });

Sync call:

同步通话：

const Filehound = require('filehound');

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

console.log(subdirectories);

For further information (and examples), check out the docs: https://github.com/nspragg/filehound

有关更多信息（和示例），请查看文档：https: //github.com/nspragg/filehound

Disclaimer: I'm the author.

免责声明：我是作者。

回答by Mayur

With node.js version >= v10.13.0, fs.readdirSyncwill return an array of fs.Direntobjects if withFileTypesoption is set to true.

对于 node.js 版本 >= v10.13.0，如果选项设置为，fs.readdirSync将返回一个fs.Dirent对象数组。withFileTypestrue

So you can use,

所以你可以使用，

const fs = require('fs')

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

回答by Jonathan bonzali

 var getDirectories = (rootdir , cb) => {
    fs.readdir(rootdir, (err, files) => {
        if(err) throw err ;
        var dirs = files.map(filename => path.join(rootdir,filename)).filter( pathname => fs.statSync(pathname).isDirectory());
        return cb(dirs);
    })

 }
 getDirectories( myDirectories => console.log(myDirectories));``

回答by 1mike12

Using fs-extra, which promises the async fs calls, and the new await async syntax:

使用 fs-extra，它承诺异步 fs 调用，以及新的 await 异步语法：

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("/")

回答by JumpLink

And a async version of getDirectories, you need the async modulefor this:

和 getDirectories 的异步版本，您需要异步模块：

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

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