如何获取 Node.js 目录中存在的所有文件的名称列表？

Question

我正在尝试使用 Node.js 获取目录中存在的所有文件的名称列表。 我想要 output 这是一个文件名数组。 我怎样才能做到这一点？

Answer 1

您可以使用fs.readdir或fs.readdirSync方法。 fs包含在 Node.js 核心中，因此无需安装任何东西。

文件读取目录

const testFolder = './tests/';
const fs = require('fs');

fs.readdir(testFolder, (err, files) => {
  files.forEach(file => {
    console.log(file);
  });
});

fs.readdir同步

const testFolder = './tests/';
const fs = require('fs');

fs.readdirSync(testFolder).forEach(file => {
  console.log(file);
});

这两种方法的区别在于，第一种方法是异步的，因此您必须提供一个回调函数，该函数将在读取过程结束时执行。

第二个是同步的，它将返回文件名数组，但它将停止任何进一步的代码执行，直到读取过程结束。

Answer 2

IMO 执行此类任务的最便捷方法是使用glob工具。 这是 node.js 的glob 包。 安装

npm install glob

然后使用通配符匹配文件名（示例取自包的网站）

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

如果您打算使用globby，这里是一个示例，用于查找当前文件夹下的任何 xml 文件

import globby = require('globby');

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

Answer 3

不过，上面的答案并未对目录执行递归搜索。 这是我为递归搜索所做的（使用node-walk : 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);
});

Answer 4

获取所有子目录中的文件

const fs=require('fs');

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

Answer 5

这是一个仅使用本机fs和path模块的简单解决方案：

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

或异步版本（使用fs.readdir代替）：

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

然后你只需调用（同步版本）：

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

或异步版本：

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

不同之处在于节点在执行 IO 时如何阻塞。 鉴于上面的 API 是相同的，您可以只使用异步版本来确保最佳性能。

但是，使用同步版本有一个优势。 一旦遍历完成，就更容易执行一些代码，就像遍历之后的下一条语句一样。 使用异步版本，您需要一些额外的方式来知道何时完成。 也许首先创建所有路径的地图，然后枚举它们。 对于简单的构建/实用程序脚本（与高性能 Web 服务器相比），您可以使用同步版本而不会造成任何损坏。

Answer 6

从 Node v10.10.0 开始，可以将fs.readdir和fs.readdirSync的新withFileTypes选项与dirent.isDirectory()函数结合使用来过滤目录中的文件名。 看起来像这样：

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

返回的数组格式如下：

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

fs.Dirent 类的文档

Answer 7

在 ES7 中使用 Promise

与 mz/fs 异步使用

mz模块提供了核心节点库的promisified 版本。 使用它们很简单。 首先安装库...

npm install mz

然后...

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

或者，您可以在 ES7 的异步函数中编写它们：

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

更新递归列表

一些用户表示希望看到递归列表（尽管不在问题中）...使用fs-promise 。 它是围绕mz的薄包装。

npm install fs-promise;

然后...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));

Answer 8

非递归版本

你不是说你想递归地做，所以我假设你只需要目录的直接子级。

示例代码：

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

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

Answer 9

依赖性。

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

定义。

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

用法。

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

请注意fileList太乐观了。 对于任何严重的情况，请添加一些错误处理。

Answer 10

我从你的问题中假设你不想要目录名称，只需要文件。

目录结构示例

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

Walk功能

在此要点中归功于Justin Maier

如果您只需要文件路径数组，请使用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), []);
}

用法

async function main() {
   console.log(await walk('animals'))
}

输出

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

Answer 11

如果有人还在搜索这个，我会这样做：

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

它的工作对我来说非常好

Answer 12

加载fs ：

const fs = require('fs');

异步读取文件：

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

读取文件同步：

var files = fs.readdirSync('./dir');

Answer 13

获取sorted文件名。 您可以根据特定的extension过滤结果，例如'.txt' 、 '.jpg'等。

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

Answer 14

这是一个 TypeScript，可选递归，可选错误日志和异步解决方案。 您可以为要查找的文件名指定正则表达式。

我使用了fs-extra ，因为它是对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
}

Answer 15

盒子外面

如果您想要一个具有开箱即用的目录结构的对象，我强烈建议您检查directory-tree 。

假设你有这个结构：

photos
│   june
│   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg

const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

将返回：

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

自定义对象

否则，如果您想使用自定义设置创建目录树对象，请查看以下代码段。 在这个代码和框上可以看到一个活生生的例子。

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

然后你可以简单地做：

// another-file.js 

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

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

Answer 16

这是一个异步递归版本。

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

Answer 17

采用@Hunan-Rostomyan 的一般方法，使其更加简洁，并添加了excludeDirs参数。 使用includeDirs扩展很简单，只需遵循相同的模式：

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

用法示例：

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));

Answer 18

如果有人，我的 2 美分：

只想从项目的本地子文件夹中列出文件名（不包括目录）

• ✅ 没有额外的依赖
• ✅ 1 个功能
• ✅ 规范化路径（Unix vs. Windows）

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

/**
 * @param {string} relativeName "resources/foo/goo"
 * @return {string[]}
 */
const listFileNames = (relativeName) => {
  try {
    const folderPath = path.join(process.cwd(), ...relativeName.split("/"));
    return fs
      .readdirSync(folderPath, { withFileTypes: true })
      .filter((dirent) => dirent.isFile())
      .map((dirent) => dirent.name.split(".")[0]);
  } catch (err) {
    // ...
  }
};

README.md
package.json
resources
 |-- countries
    |-- usa.yaml
    |-- japan.yaml
    |-- gb.yaml
    |-- provinces
       |-- .........


listFileNames("resources/countries") #=> ["usa", "japan", "gb"]

Answer 19

它只有两行代码：

fs=require('fs')
fs.readdir("./img/", (err,filename)=>console.log(filename))

图片：

Answer 20

提醒一下：如果您打算对目录中的每个文件执行操作，请尝试乙烯基-fs （流构建系统gulp使用它）。

Answer 21

您可能还想以递归方式执行此操作。

这有一个NPM模块：

npm dree

它允许您将目录树的表示形式表示为字符串或对象。 通过文件回调，您还可以实现目标。 如果需要，您还可以指定要考虑的文件扩展名。

这是代码：

const dree = require('dree');

const fileNames = [];
const fileCb = function(file) {
    fileNames.push(file.name);
}

dree.scan('path-to-directory', { extensions: [ 'html', 'js' ] }, fileCb);

console.log(fileNames); // All the html and js files inside the given folder and its subfolders

Answer 22

这将工作并将结果存储在 test.txt 文件中，该文件将出现在同一目录中

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

Answer 23

我最近为此构建了一个工具，它可以做到这一点......它异步获取一个目录并返回一个项目列表。 您可以获取目录、文件或两者，首先是文件夹。 如果您不想获取整个文件夹，您还可以对数据进行分页。

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

这是链接，希望它可以帮助某人！

Answer 24

我制作了一个节点模块来自动执行此任务： mddir

用法

节点 mddir "../relative/path/"

安装： npm install mddir -g

为当前目录生成降价：mddir

为任何绝对路径生成： mddir /absolute/path

生成相对路径：mddir ~/Documents/whatever。

md 文件在您的工作目录中生成。

当前忽略 node_modules 和 .git 文件夹。

故障排除

如果您收到错误“node\\r: No such file or directory”，则问题在于您的操作系统使用了不同的行尾，并且 mddir 无法解析它们，除非您将行尾样式明确设置为 Unix。 这通常会影响 Windows，但也会影响某些版本的 Linux。 必须在 mddir npm global bin 文件夹中将行结尾设置为 Unix 样式。

行尾修复

使用以下命令获取 npm bin 文件夹路径：

npm config get prefix

cd 到那个文件夹

brew 安装 dos2unix

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

这会将行尾转换为 Unix 而不是 Dos

然后正常运行：node mddir "../relative/path/"。

示例生成的 Markdown 文件结构 '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

Answer 25

使用npm list-contents模块。 它读取给定目录的内容和子内容，并返回文件和文件夹路径的列表。

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

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});

Answer 26

我通常使用： FS-Extra 。

const fileNameArray = Fse.readdir('/some/path');

结果：

[
  "b7c8a93c-45b3-4de8-b9b5-a0bf28fb986e.jpg",
  "daeb1c5b-809f-4434-8fd9-410140789933.jpg"
]

Answer 27

如果上述许多选项看起来太复杂或不是您正在寻找的，则是使用 node-dir 的另一种方法 - https://github.com/fshost/node-dir

npm install node-dir

这是一个列出所有在子目录中搜索的 .xml 文件的简单函数

import * as nDir from 'node-dir' ;

listXMLs(rootFolderPath) {
    let xmlFiles ;

    nDir.files(rootFolderPath, function(err, items) {
        xmlFiles = items.filter(i => {
            return path.extname(i) === '.xml' ;
        }) ;
        console.log(xmlFiles) ;       
    });
}

Answer 28

使用flatMap ：

function getFiles(dir) {
  return fs.readdirSync(dir).flatMap((item) => {
    const path = `${dir}/${item}`;
    if (fs.statSync(path).isDirectory()) {
      return getFiles(path);
    }

    return path;
  });
}

给定以下目录：

dist
├── 404.html
├── app-AHOLRMYQ.js
├── img
│   ├── demo.gif
│   └── start.png
├── index.html
└── sw.js

用法：

getFiles("dist")

输出：

[
  'dist/404.html',
  'dist/app-AHOLRMYQ.js',
  'dist/img/demo.gif',
  'dist/img/start.png',
  'dist/index.html'
]

Answer 29

我的一个班轮代码：

const path = 'somePath/'
const filesArray = fs.readdirSync(path).filter(file => fs.lstatSync(path+file).isFile())

Answer 30

试试这个，它对我有用

import fs from 'fs/promises';
const files= await fs.readdir('path/to/folder');
console.log(files); // array

Answer 31

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