在运行nodemon命令时也有同样的问题，所以我减少了崇高文本中打开的文件的名称，错误消失了。

像我们所有人一样，您也是异步I/O的另一个受害者。对于异步调用，如果你循环了很多文件，Node.js将开始为每个要读取的文件打开一个文件描述符，然后等待操作，直到关闭它。

文件描述符保持打开状态，直到服务器上的资源可用来读取它。即使您的文件很小，读取或更新很快，也需要一些时间，但与此同时，循环不会停止打开新的文件描述符。所以如果你有太多的文件，限制将很快达到，你会得到一个漂亮的EMFILE。

有一个解决方案，创建一个队列来避免这种影响。

感谢编写Async的人，这里有一个非常有用的函数。有一个方法叫做Async。队列，您将创建一个具有限制的新队列，然后将文件名添加到队列中。

注意:如果你必须打开许多文件，最好存储当前打开的文件，不要无限地重新打开它们。

const fs = require('fs')
const async = require("async")

var q = async.queue(function(task, callback) {
    console.log(task.filename);
    fs.readFile(task.filename,"utf-8",function (err, data_read) {
            callback(err,task.filename,data_read);
        }
    );
}, 4);

var files = [1,2,3,4,5,6,7,8,9,10]

for (var file in files) {
    q.push({filename:file+".txt"}, function (err,filename,res) {
        console.log(filename + " read");
    });
}

您可以看到每个文件都被添加到队列(console.log文件名)中，但仅当当前队列低于您之前设置的限制时。

异步。队列通过回调获取关于队列可用性的信息，此回调仅在读取数据文件并且实现必须执行的任何操作时调用。(参见fileRead方法)

所以你不会被文件描述符搞得不知所措。

> node ./queue.js
0.txt
    1.txt
2.txt
0.txt read
3.txt
3.txt read
4.txt
2.txt read
5.txt
4.txt read
6.txt
5.txt read
7.txt
    1.txt read (biggest file than other)
8.txt
6.txt read
9.txt
7.txt read
8.txt read
9.txt read

在运行nodemon命令时也有同样的问题，所以我减少了崇高文本中打开的文件的名称，错误消失了。

请注意，您不必将这个问题过于复杂化，再试一次就可以了。

import { promises as fs } from "fs";

const filepaths = [];
const errors = [];

function process_file(content: string) {
    // logic here
}

await Promise.all(
    filepaths.map(function read_each(filepath) {
        return fs
            .readFile(filepath, "utf8")
            .then(process_file)
            .catch(function (error) {
                if (error.code === "EMFILE") return read_each(filepath);
                else errors.push({ file: filepath, error });
            });
    }),
);

我自己刚刚写了一小段代码来解决这个问题，所有其他的解决方案看起来都太重量级了，需要你改变程序结构。

这个解决方案只是暂停任何f。readFile或fs。writeFile调用，以便在任何给定时间运行的次数不超过设定的数目。

// Queuing reads and writes, so your nodejs script doesn't overwhelm system limits catastrophically
global.maxFilesInFlight = 100; // Set this value to some number safeish for your system
var origRead = fs.readFile;
var origWrite = fs.writeFile;

var activeCount = 0;
var pending = [];

var wrapCallback = function(cb){
    return function(){
        activeCount--;
        cb.apply(this,Array.prototype.slice.call(arguments));
        if (activeCount < global.maxFilesInFlight && pending.length){
            console.log("Processing Pending read/write");
            pending.shift()();
        }
    };
};
fs.readFile = function(){
    var args = Array.prototype.slice.call(arguments);
    if (activeCount < global.maxFilesInFlight){
        if (args[1] instanceof Function){
            args[1] = wrapCallback(args[1]);
        } else if (args[2] instanceof Function) {
            args[2] = wrapCallback(args[2]);
        }
        activeCount++;
        origRead.apply(fs,args);
    } else {
        console.log("Delaying read:",args[0]);
        pending.push(function(){
            fs.readFile.apply(fs,args);
        });
    }
};

fs.writeFile = function(){
    var args = Array.prototype.slice.call(arguments);
    if (activeCount < global.maxFilesInFlight){
        if (args[1] instanceof Function){
            args[1] = wrapCallback(args[1]);
        } else if (args[2] instanceof Function) {
            args[2] = wrapCallback(args[2]);
        }
        activeCount++;
        origWrite.apply(fs,args);
    } else {
        console.log("Delaying write:",args[0]);
        pending.push(function(){
            fs.writeFile.apply(fs,args);
        });
    }
};

我今天遇到了这个问题，没有找到好的解决方案，我创建了一个模块来解决它。我受到@fbartho的代码片段的启发，但希望避免覆盖fs模块。

我写的模块是Filequeue，你使用它就像fs:

var Filequeue = require('filequeue');
var fq = new Filequeue(200); // max number of files to open at once

fq.readdir('/Users/xaver/Downloads/xaver/xxx/xxx/', function(err, files) {
    if(err) {
        throw err;
    }
    files.forEach(function(file) {
        fq.readFile('/Users/xaver/Downloads/xaver/xxx/xxx/' + file, function(err, data) {
            // do something here
        }
    });
});