在文档中，它显示了readdir和stat的两个版本。两者都有异步和同步版本readir/readdirSync和stat/statSync。
因为readidir和stat是异步的，所以我希望它们返回一个Promise，但是当尝试使用async/await时，脚本不会等待readdir解决，如果我使用.then/.catch时出现错误cannot read .then of undefined。
我在这里要做的就是将脚本在其中运行的目录内的目录映射到dirsOfCurrentDir映射。
cannot read .then of undefined const fs = require('fs');
const directory = `${ __dirname }/${ process.argv[2] }`;
const dirsOfCurrentDir = new Map();
fs.readdir(directory, (err, files) => {
let path;
if (err)
return console.log(err);
files.forEach(file => {
path = directory + file;
fs.stat(path, (err, stats) => {
if (err)
return console.log(err);
dirsOfCurrentDir.set(file, directory);
});
});
}).then(() => console.log('adasdasd'))
console.log(dirsOfCurrentDir)
Map {} const foo = async () => {
await fs.readdir(directory, (err, files) => {
let path;
if (err)
return console.log(err);
files.forEach(file => {
path = directory + file;
fs.stat(path, (err, stats) => {
if (err)
return console.log(err);
dirsOfCurrentDir.set(file, directory);
});
});
});
};
foo()
console.log(dirsOfCurrentDir)
我最终使用了两个功能readdirSync和statSync的同步版本。虽然我使用异步方法或承诺时会感觉更好，但我仍然没有弄清楚如何使用这两种方法使我的代码正常工作。
const fs = require('fs');
const directory = `${ __dirname }/${ process.argv[2] }`;
const dirsOfCurrentDir = new Map();
const dirContents = fs.readdirSync(directory);
dirContents.forEach(file => {
const path = directory + file;
const stats = fs.statSync(path);
if (stats.isDirectory())
dirsOfCurrentDir.set(file, path);
});
console.log(dirsOfCurrentDir); // logs out the map with all properties set
答案 0 :(得分：5)
由于readidir和stat是异步的，我希望它们返回Promise
首先，请确保您知道异步函数和async函数之间的区别。在Javascript中使用该特定关键字声明为async的函数，例如：
async function foo() {
...
}
总是返回一个Promise（根据用async关键字声明的函数的定义）。
但是诸如fs.readdir()之类的异步函数可能会或可能不会返回promise，具体取决于其内部设计。在这种特殊情况下，node.js中fs模块的原始实现仅使用回调，而不使用诺言（其设计早于诺言.js中存在诺言）。它的功能是异步的，但未声明为async，因此使用常规回调，而不是promise。
因此，您必须使用回调或“ promisify”接口将其转换为可返回承诺的内容，以便您可以将await与之配合使用。
有一个experimental interface in node.js v10为fs模块提供了内置的承诺。
const fsp = require('fs').promises;
fsp.readdir(...).then(...)
在早期版本的node.js中，有很多用于实现函数的选项。您可以使用util.promisify()：
const promisify = require('util').promisify;
const readdirP = promisify(fs.readdir);
const statP = promisify(fs.stat);
由于我尚未在节点v10上进行开发，因此我经常使用Bluebird Promise库并一次实现整个fs库的承诺：
const Promise = require('bluebird');
const fs = Promise.promisifyAll(require('fs'));
fs.readdirAsync(...).then(...)
要仅列出给定目录中的子目录，可以执行以下操作：
const fs = require('fs');
const path = require('path');
const promisify = require('util').promisify;
const readdirP = promisify(fs.readdir);
const statP = promisify(fs.stat);
const root = path.join(__dirname, process.argv[2]);
// utility function for sequencing through an array asynchronously
function sequence(arr, fn) {
return arr.reduce((p, item) => {
return p.then(() => {
return fn(item);
});
}, Promise.resolve());
}
function listDirs(rootDir) {
const dirsOfCurrentDir = new Map();
return readdirP(rootDir).then(files => {
return sequence(files, f => {
let fullPath = path.join(rootDir, f);
return statP(fullPath).then(stats => {
if (stats.isDirectory()) {
dirsOfCurrentDir.set(f, rootDir)
}
});
});
}).then(() => {
return dirsOfCurrentDir;
});
}
listDirs(root).then(m => {
for (let [f, dir] of m) {
console.log(f);
}
});
这是一个更通用的实现，它列出文件并为列出内容和如何显示结果提供几个选项：
const fs = require('fs');
const path = require('path');
const promisify = require('util').promisify;
const readdirP = promisify(fs.readdir);
const statP = promisify(fs.stat);
const root = path.join(__dirname, process.argv[2]);
// options takes the following:
// recurse: true | false - set to true if you want to recurse into directories (default false)
// includeDirs: true | false - set to true if you want directory names in the array of results
// sort: true | false - set to true if you want filenames sorted in alpha order
// results: can have any one of the following values
// "arrayOfFilePaths" - return an array of full file path strings for files only (no directories included in results)
// "arrayOfObjects" - return an array of objects {filename: "foo.html", rootdir: "//root/whatever", full: "//root/whatever/foo.html"}
// results are breadth first
// utility function for sequencing through an array asynchronously
function sequence(arr, fn) {
return arr.reduce((p, item) => {
return p.then(() => {
return fn(item);
});
}, Promise.resolve());
}
function listFiles(rootDir, opts = {}, results = []) {
let options = Object.assign({recurse: false, results: "arrayOfFilePaths", includeDirs: false, sort: false}, opts);
function runFiles(rootDir, options, results) {
return readdirP(rootDir).then(files => {
let localDirs = [];
if (options.sort) {
files.sort();
}
return sequence(files, fname => {
let fullPath = path.join(rootDir, fname);
return statP(fullPath).then(stats => {
// if directory, save it until after the files so the resulting array is breadth first
if (stats.isDirectory()) {
localDirs.push({name: fname, root: rootDir, full: fullPath, isDir: true});
} else {
results.push({name: fname, root: rootDir, full: fullPath, isDir: false});
}
});
}).then(() => {
// now process directories
if (options.recurse) {
return sequence(localDirs, obj => {
// add directory to results in place right before its files
if (options.includeDirs) {
results.push(obj);
}
return runFiles(obj.full, options, results);
});
} else {
// add directories to the results (after all files)
if (options.includeDirs) {
results.push(...localDirs);
}
}
});
});
}
return runFiles(rootDir, options, results).then(() => {
// post process results based on options
if (options.results === "arrayOfFilePaths") {
return results.map(item => item.full);
} else {
return results;
}
});
}
// get flat array of file paths,
// recursing into directories,
// each directory sorted separately
listFiles(root, {recurse: true, results: "arrayOfFilePaths", sort: true, includeDirs: false}).then(list => {
for (const f of list) {
console.log(f);
}
}).catch(err => {
console.log(err);
});
您可以将此代码复制到文件中并运行，并通过传递.作为参数来列出脚本目录或要列出的任何子目录名称。
如果您想要更少的选项（例如，不保留任何递归或不保留目录顺序），则可以大大减少此代码，甚至可以使其速度更快（并行运行一些异步操作）。