我正在尝试使用Node.js获取目录中存在的所有文件的名称列表。我想要输出是一个文件名数组。我怎么能这样做？
答案 0 :(得分：1061)
您可以使用fs.readdir或fs.readdirSync方法。
<强> 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);
});
两种方法的区别在于第一种方法是异步的，因此必须提供一个在读取过程结束时执行的回调函数。
第二个是同步的，它将返回文件名数组，但它将停止进一步执行代码，直到读取过程结束。
答案 1 :(得分：173)
上面的答案并没有对目录进行递归搜索。以下是我为递归搜索所做的操作（使用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);
});
答案 2 :(得分：173)
IMO执行此类任务的最方便方法是使用glob工具。这是node.js的glob package。使用
安装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.
})
答案 3 :(得分：81)
获取所有子目录中的文件
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'))
答案 4 :(得分：55)
这是一个只使用原生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"...
});
或async版本：
walk('path/to/root/dir', function(filePath, stat) {
// do something with "filePath"...
});
区别在于节点在执行IO时的阻塞方式。鉴于上面的API是相同的，您可以使用异步版本来确保最佳性能。
但是使用同步版本有一个优点。步行完成后，执行某些代码会更容易，如步行后的下一个语句。使用异步版本，您需要一些额外的方法来了解何时完成。也许首先创建所有路径的地图，然后枚举它们。对于简单的build / util脚本（与高性能Web服务器相比），您可以使用同步版本而不会造成任何损害。
答案 5 :(得分：23)
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));
答案 6 :(得分：15)
<强>依赖关系。
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过于乐观了。对于任何严重的事情，添加一些错误处理。
答案 7 :(得分：12)
根据您的问题，我假设您不需要目录名称，而只需要文件。
animals
├── all.jpg
├── mammals
│ └── cat.jpg
│ └── dog.jpg
└── insects
└── bee.jpg
Walk功能贷方转到Justin Maier中的this gist
如果要只是文件路径的一个数组，请使用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"
];
答案 8 :(得分：10)
你不是说你想要递归地做，所以我假设你只需要目录的直接孩子。
示例代码：
const fs = require('fs');
const path = require('path');
fs.readdirSync('your-directory-path')
.filter((file) => fs.lstatSync(path.join(folder, file)).isFile());
答案 9 :(得分：7)
加载fs：
const fs = require('fs');
读取文件 async ：
fs.readdir('./dir', function (err, files) {
// "files" is an Array with files names
});
读取文件 sync ：
var files = fs.readdirSync('./dir');
答案 10 :(得分：6)
获取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();
}
答案 11 :(得分：6)
万一您需要一个具有目录结构的对象，我强烈建议您检查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"
}
]
}
]
}
否则，如果要使用自定义设置创建目录树对象，请查看以下代码段。在此codesandbox上可以看到一个实时示例。
// 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");
答案 12 :(得分：4)
这是一个异步递归版本。
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()
}
答案 13 :(得分：4)
从Node v10.10.0开始，可以将withFileTypes和fs.readdir的新fs.readdirSync选项与dirent.isDirectory()函数结合使用，以过滤目录。看起来像这样：
fs.readdirSync('./dirpath', {withFileTypes: true})
.filter(item => !item.isDirectory())
.map(item => item.name)
返回的数组的格式为：
['file1.txt', 'file2.txt', 'file3.txt']
答案 14 :(得分：3)
我的2美分，如果有人：
只想列出其项目中本地子文件夹中的文件名（目录除外）
thrift -out /src --gen php /data/service.thrift
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) {
// ...
}
};
答案 15 :(得分：3)
采用@ 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']));
答案 16 :(得分：3)
如果有人仍在搜索，我可以这样做：
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];
}, []);
及其工作对我非常有益
答案 17 :(得分：1)
我最近为此目的构建了一个工具...它异步获取目录并返回项目列表。您可以获取目录，文件或同时获取目录和文件，首先要获取文件夹。如果您不想获取整个文件夹，也可以对数据进行分页。
https://www.npmjs.com/package/fs-browser
这是链接，希望对您有所帮助！
答案 18 :(得分：1)
您可能还想递归地进行操作。
为此有一个NPM模块：
它使您可以将目录树表示为字符串或对象。使用文件回调，您也可以实现目标。如果需要，还可以指定要考虑的文件扩展名。
代码如下：
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
答案 19 :(得分：0)
如果上述许多选项看起来过于复杂或不是您要查找的内容，则使用 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) ;
});
}
答案 20 :(得分：0)
我通常使用：FS-Extra。
const fileNameArray = Fse.readdir('/some/path');
结果：
[
"b7c8a93c-45b3-4de8-b9b5-a0bf28fb986e.jpg",
"daeb1c5b-809f-4434-8fd9-410140789933.jpg"
]
答案 21 :(得分：0)
这将起作用并将结果存储在test.txt文件中，该文件将出现在同一目录中
fs.readdirSync(__dirname).forEach(file => {
fs.appendFileSync("test.txt", file+"\n", function(err){
})
})
答案 22 :(得分：0)
这是一个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
}
答案 23 :(得分：0)
使用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);
});
答案 24 :(得分：0)
我制作了一个节点模块来自动完成这项任务：mddir
node mddir“../ relative / path /”
安装：npm install mddir -g
为当前目录生成markdown：mddir
为任何绝对路径生成：mddir / absolute / path
为相对路径生成：mddir~ / Documents / whatever。
md文件在您的工作目录中生成。
目前忽略node_modules和.git文件夹。
如果收到错误'node \ r \ n：没有这样的文件或目录'，问题是您的操作系统使用不同的行结尾，并且mddir无法在不明确将行结束样式设置为Unix的情况下解析它们。这通常会影响Windows，但也会影响某些版本的Linux。必须在mddir npm全局bin文件夹中执行将行结尾设置为Unix样式。
获取npm bin文件夹路径：
npm config get prefix
cd进入该文件夹
brew install dos2unix
dos2unix lib / node_modules / mddir / src / mddir.js
这会将行结尾转换为Unix而不是Dos
然后正常运行：node mddir“../ relative / path /".
|-- .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
答案 25 :(得分：0)
答案 26 :(得分：-1)
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);
}
}
}