同步检查Node.js中是否存在文件/目录

Check synchronously if file/directory exists in Node.js

如果文件或目录存在，如何使用node.js同步检查？

这个问题的答案多年来已经改变了。当前答案位于顶部，然后是多年来按时间顺序排列的各种答案：好的。当前答案

您可以使用fs.existsSync()：好的。

1
2
3
4

const fs = require("fs"); // Or `import fs from"fs";` with ESM
if (fs.existsSync(path)) {
// Do something
}

它被弃用了好几年，但现在不再是了。来自文档：好的。

Note that fs.exists() is deprecated, but fs.existsSync() is not. (The
callback parameter to fs.exists() accepts parameters that are
inconsistent with other Node.js callbacks. fs.existsSync() does not
use a callback.)

Ok.

您特别要求进行同步检查，但是如果您可以使用异步检查(通常最好使用I/O)，如果您使用的是async函数，则使用fs.promises.access，如果不使用，则使用fs.access(因为exists)(因为fs.exists)(因为fs.exists)被否决)：好的。

在async函数中：好的。

1
2
3
4
5
6

try {
await fs.promises.access("somefile");
// The check succeeded
} catch (error) {
// The check failed
}

或通过回拨：好的。

1
2
3
4
5
6
7

fs.access("somefile", error => {
if (!error) {
// The check succeeded
} catch (error) {
// The check failed
}
});

历史答案

以下是按时间顺序排列的历史答案：好的。

2010年的原始答案(stat/statSync或lstat/lstatSync)
2012年9月更新(exists/existsSync)
2015年2月更新(注意到exists/existsSync的折旧迫在眉睫，所以我们可能会回到stat/statSync或lstat或lstatSync的版本)
2015年12月更新(也有fs.access(path, fs.F_OK, function(){})/fs.accessSync(path, fs.F_OK)，但请注意，如果文件/目录不存在，则是一个错误；fs.stat的文档建议如果需要检查是否存在而不打开，则使用fs.access)
2016年12月更新fs.exists()仍被否决，但fs.existsSync()不再被否决。所以你现在可以安全地使用它。

2010年的原始答案：

您可以使用statSync或lstatSync(docs link)，这会给您一个fs.Stats对象。通常，如果函数的同步版本可用，那么它将与末尾带有Sync的异步版本同名。所以statSync是stat的同步版本；lstatSync是lstat的同步版本等。好的。

lstatSync告诉您某个东西是否存在，如果存在，它是一个文件还是一个目录(或在某些文件系统中，是一个符号链接、块设备、字符设备等)，例如，如果您需要知道它是否存在并且是一个目录：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13

var fs = require('fs');
try {
// Query the entry
stats = fs.lstatSync('/the/path');

// Is it a directory?
if (stats.isDirectory()) {
// Yes it is
}
}
catch (e) {
// ...
}

…同样的，如果是一个文件，有isFile；如果是一个块设备，有isBlockDevice等。注意try/catch；如果条目根本不存在，就会抛出一个错误。好的。

~~如果您不关心条目是什么并且只想知道它是否存在，您可以使用path.existsSync(或最新的fs.existsSync，如user618408所述：好的。~~

1
2
3
4
var path = require('path');
if (path.existsSync("/the/path")) { // or fs.existsSync
// ...
}

它不需要使用try/catch，但是它没有提供任何关于事物是什么的信息，只是它在那里。~~path.existsSync很久以前就被弃用了。好的。~~
旁注：您明确要求如何同步检查，所以我使用了上述函数的xyzSync版本。但只要可能，使用I/O，最好避免同步调用。从CPU的角度来看，对I/O子系统的调用需要花费大量的时间。注意调用lstat而不是lstatSync是多么容易：好的。

1
2
3
4
5
6
// Is it a directory?
lstat('/the/path', function(err, stats) {
if (!err && stats.isDirectory()) {
// Yes it is
}
});

但如果您需要同步版本，它就在那里。好的。2012年9月更新
下面几年前的答案现在有点过时了。当前的方法是使用fs.existsSync来同步检查文件/目录是否存在(或者，当然，使用fs.exists进行异步检查)，而不是使用下面的path版本。好的。
例子：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
var fs = require('fs');

if (fs.existsSync(path)) {
// Do something
}

// Or

fs.exists(path, function(exists) {
if (exists) {
// Do something
}
});

2015年2月更新
这里我们是在2015年，节点文档现在说EDOCX1(和fs.exists)"将被否决"。(因为节点人员认为在打开某个东西之前检查它是否存在是愚蠢的，而这并不是检查某个东西是否存在的唯一原因！)好的。
所以我们可能会回到各种各样的stat方法…当然，除非这种情况再次改变。好的。2015年12月更新
不知道有多久了，但也有fs.access(path, fs.F_OK, ...)和fs.accessSync(path, fs.F_OK)。至少截至2016年10月，fs.stat文件建议使用fs.access进行存在性检查("为了检查文件是否存在，而不随后对其进行操作，建议使用fs.access())"。但是请注意，访问不可用被认为是一个错误，因此如果您希望文件可以访问，那么这可能是最好的方法：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var fs = require('fs');

try {
fs.accessSync(path, fs.F_OK);
// Do something
} catch (e) {
// It isn't accessible
}

// Or

fs.access(path, fs.F_OK, function(err) {
if (!err) {
// Do something
} else {
// It isn't accessible
}
});

2016年12月更新
您可以使用fs.existsSync()：好的。

1
2
3
if (fs.existsSync(path)) {
// Do something
}

它被弃用了好几年，但现在不再是了。来自文档：好的。

Note that fs.exists() is deprecated, but fs.existsSync() is not. (The
callback parameter to fs.exists() accepts parameters that are
inconsistent with other Node.js callbacks. fs.existsSync() does not
use a callback.)

Ok.

好啊。

相关讨论

如果文件不存在，statsync会触发一个错误。

您可以链接到文档中的函数。在webkit浏览器(在我的例子中是safari)中，右键单击并选择"inspect element"，然后在HTML中找到要指向的函数的"id"属性。在这种情况下：nodejs.org/docs/v0.2.5/api.html fs-statsync-114

@Ohmantics：这很奇怪，我认为我确实做到了(一直到使用Webkit浏览器来查找元素ID:-)但它不起作用。但你的链接有效，所以显然不行。(甚至锚也和发现的一样！奇怪。

@杰西：exists没有告诉你它是一个目录，它可以是一个文件、管道或其他文件系统对象。当然不会"严重"过度复杂化？existsSync将只替换lstatSync调用，其余的只是显示它如何在循环中工作。(但不知道为什么我觉得这是必要的。)

@T.J.Crowder-并不是有意冒犯，只是认为做这么多的拦截有潜在的危险。如果在生产环境中，我建议至少将其包装在process.nextTick调用中。但是，如果您只是在编写脚本，并且绝对有必要测试它是什么类型的文件，那么这是一个非常合理的解决方案。我只是觉得这有点过分了。

@杰西：嗯，我不记得为什么我觉得有必要做一个循环例子，但是操作程序确实明确地说了"同步"，也许我觉得同步检查的唯一好理由就是循环……

path.exists和path.existssync都已被弃用，取而代之的是fs.exists和fs.existssync。

@德鲁：谢谢，更新了。

只是一个通知：path.existsSync现在是fs.existsSync

@ Bondye：是的。见答案的第一段。；-)

@T.J.Crowder啊，没想到顶部会有更新；)

fs.exists和fs.existsSync将被否决。我创建了is-there库来替换它们。@T.J.克劳德，如果你愿意的话，你可以把它包括在你的答案中。

"离子"？生意？你：哦，因为你大声的哭喊(对他们，不是对你)。因为除非你想打开它，否则没有用例来检查某个东西是否存在。叹息

@T.J.克劳德是的……我真的需要检查一个文件是否存在，什么都没有。这就是我创建is-there的原因。-)

我还没读过答案，但我已经把这个答案投了赞成票。5年后更新的答案…它应该得到1！

当我看到他们标记"存在"为不赞成，肯定是一记耳光。

"节点人员认为在打开某个文件之前检查它是否存在是愚蠢的，这是愚蠢的"；为什么检查文件是否存在是愚蠢的？

@Petrhurtak：并非总是如此(因为有很多原因需要检查是否存在)，但是如果您要打开文件，最好只发出open调用并处理异常，或者如果找不到文件，则执行其他操作。毕竟，现实世界是混乱的：如果你先检查它，它就在那里，这并不意味着当你试图打开它时它仍然在那里；如果你先检查它，但它不在那里，这并不意味着它一会儿就不在那里。这样的时间安排看起来像是边缘问题，但它们总是会出现。所以，如果你要开门，没有必要先检查。

在这里，我认为使用错误控制流是一种反模式：链接

@杰罗姆耶斯：的确如此。我会在某个相关时间检查文件的存在，并期望打开的调用可能失败。但我不能控制nodejs API…

@T.J.Crowder：所以，我最终会创建自己的实用功能，我想我会称之为"fsexists"；)

@杰罗姆耶斯：你可以，但是爱奥尼亚？已经为您完成了(请参阅上面的注释)。-)

在我看来，将错误用于控制流是一种反模式，它会导致更为公开的代码。所以他们在贬低一个函数，而其他函数必须在自己的库中重新实现？世界跆拳道联盟。。。

支持更新答案，非常好。希望更多的人能做到这一点。

我的赞成票一共是786票。

很好，保持更新！对这一努力投赞成票：)

哈哈，我这几年都在查这个帖子，每次都有新的东西)。

我也一样。希望看到更高质量的答案。

现在我唯一的问题是，你怎么走这条路？我的意思是，我不知道文件是否在那里，或者我只是弄错了路径：o

@T.J.Crowder请您提供最新更新答案的节点最低版本？

@斯塔克戴夫：在答案的顶部：existsSync。还是我误解了？

我不赞成的唯一原因是柜台：1337

@ Nirazul：ROFL

这些更新是情绪的过山车。谢谢你这么细心。

我不记得曾经看到过什么东西不受欢迎。

这个答案陈年如美酒。

非常完整的答案，包括时间线和所有的东西，这是我的荣幸：)

@Mikemacana-啊，是的，很好的补充，现在API已经稳定了！

从源代码来看，有一个同步版本的path.exists--path.existsSync。看起来好像在医生那里找不到。
更新：
path.exists和path.existsSync现在已被否决。~~请使用fs.exists和fs.existsSync。~~
更新2016：
fs.exists和fs.existsSync也被否决。改用fs.stat()或fs.access()。

相关讨论

path.existssync(p)位于0.4.10 docs nodejs.org/docs/v0.4.10/api/path.html中

这应该是公认的答案。

实际上，最近的答案是：path.existssync已被弃用。它现在叫做fs.existsSync。

现在文档说fs.exists将被弃用。nodejs.org/api/fs.html fs诳u现有同步路径

我写了一个小库来替换旧的exists函数：is-there。

nodejs.org/api/fs.html fs fs existssync pathstability:0-已弃用：改用fs.statsync()或fs.accesssync()。

currenct docs(版本9)只将fs.exists标记为已弃用，而fs.existsSync不标记！

您的2016年更新与接受答案中的2016年更新正好相反…为什么？

使用当前推荐的(截至2015年)API(每个节点文档)，这是我要做的：

1
2
3
4
5
6
7
8
9
10
11
12
13
var fs = require('fs');

function fileExists(filePath)
{
try
{
return fs.statSync(filePath).isFile();
}
catch (err)
{
return false;
}
}

针对@broadband在评论中提出的eperm问题，提出了一个很好的观点。在许多情况下，fileexists()可能不是一个很好的方法来考虑这个问题，因为fileexists()不能保证布尔返回。您可以确定文件存在或不存在，但也可能会出现权限错误。权限错误不一定意味着文件存在，因为您可能对包含要检查的文件的目录缺少权限。当然，在检查文件是否存在时也有可能遇到其他错误。
所以我上面的代码实际上是doesfileexistendodiohaveaccesstoit()，但您的问题可能是doesfilenotexistandcouldicreateit()，这将是完全不同的逻辑(这将需要考虑eperm错误等)。
虽然fs.existssync答案直接解决了这里提出的问题，但这通常不是您想要的(您不只是想知道路径上是否存在"某物"，您可能关心存在的"某物"是文件还是目录)。
底线是，如果您正在检查文件是否存在，那么您可能会这样做，因为您打算根据结果采取一些操作，并且该逻辑(检查和/或后续操作)应该适应这样的想法：在该路径上找到的某个东西可能是一个文件或目录，并且在检查的过程。

相关讨论

很好，我添加了isdirectory()使其成为文件/文件夹检查器。var stats=fs.statsync(filepath)；返回stats.isfile()stats.isdirectory()；

如果程序没有访问该文件的权限，即使该文件存在，它仍然返回false，即从chmod ugo rwx file.txt文件或在Windows中右键单击…异常消息：exception fs.statsync(..f.txt)：错误：eperm:不允许操作，stat'x:f.txt'。所以这个案例不在上面的代码中。

哇，JS有时候很迟钝。当然，97%的时间您将使用该文件，但没有一个简单的file.exists()实用程序用于3%，而是强迫我们用一个try-catch来包装它？变得真实…今天的婊子。

另一个更新
我自己也需要这个问题的答案，我查找了节点文档，似乎您不应该使用fs.exists，而是使用fs.open并使用输出的错误来检测文件是否不存在：
来自文档：

fs.exists() is an anachronism and exists only for historical reasons.
There should almost never be a reason to use it in your own code.

In particular, checking if a file exists before opening it is an
anti-pattern that leaves you vulnerable to race conditions: another
process may remove the file between the calls to fs.exists() and
fs.open(). Just open the file and handle the error when it's not
there.

http://nodejs.org/api/fs.html fs fs exists path回调

相关讨论

有没有办法用OpenSync来完成，而不是打开

@Greghornby我想它应该和OpenSync一样工作

对于那些仍然需要exists和existsSync的人，我创建了is-there。

这种贬低让我很恼火。打开一个文件只是为了查看是否抛出了一个错误，当需要的只是对文件存在的了解时，这似乎是在浪费资源。

我使用下面的函数来测试文件是否存在。它还捕获其他异常。因此，如果存在权利问题，如chmod ugo-rwx filename或WindowsRight Click -> Properties -> Security -> Advanced -> Permission entries: empty list ..函数按应返回异常。文件存在，但我们无权访问它。忽视这种例外情况是错误的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function fileExists(path) {

try {
return fs.statSync(path).isFile();
}
catch (e) {

if (e.code == 'ENOENT') { // no such file or directory. File really does not exist
console.log("File does not exist.");
return false;
}

console.log("Exception fs.statSync (" + path +"):" + e);
throw e; // something else went wrong, we don't have rights, ...
}
}

异常输出，文件不存在时的nodejs错误文档：

1
2
3
4
5
6
7
{
[Error: ENOENT: no such file or directory, stat 'X:\\delsdfsdf.txt']
errno: -4058,
code: 'ENOENT',
syscall: 'stat',
path: 'X:\\delsdfsdf.txt'
}

例外情况：如果我们没有对该文件的权限，但存在：

1
2
3
4
5
6
7
{
[Error: EPERM: operation not permitted, stat 'X:\file.txt']
errno: -4048,
code: 'EPERM',
syscall: 'stat',
path: 'X:\\file.txt'
}

相关讨论

确实如此，这是自node反对使用最后37种方法以来为数不多的最新答案之一。

啊，你打败了我。如果我读了这本书，我本可以节省一些时间的。

这里的一些答案说，fs.exists和fs.existsSync都被否决了。根据文件，这不再是真的了。现在只有fs.exists被折旧：

Note that fs.exists() is deprecated, but fs.existsSync() is not. (The
callback parameter to fs.exists() accepts parameters that are
inconsistent with other Node.js callbacks. fs.existsSync() does not
use a callback.)

因此，您可以安全地使用fs.existssync()来同步检查文件是否存在。

fs.exists()已弃用，请不要使用它https://nodejs.org/api/fs.html fs exists path回调
您可以使用以下方法实现核心节点：https://github.com/node js/node-v0.x-archive/blob/master/lib/module.js_l86

1
2
3
4
5
6
function statPath(path) {
try {
return fs.statSync(path);
} catch (ex) {}
return false;
}

这将返回stats对象，然后一旦您获得了可以尝试的stats对象

1
2
3
4
var exist = statPath('/path/to/your/file.js');
if(exist && exist.isFile()) {
// do something
}

path模块不提供path.exists的同步版本，因此您必须使用fs模块。
我能想象的最快的事情是使用fs.realpathSync，它将抛出一个您必须捕获的错误，因此您需要使用try/catch来创建自己的包装器函数。

相关讨论

nodejs.org/docs/latest/api/path.html path.existssync

fs.stat()上的文档说，如果不想操纵文件，就使用fs.access()。它没有给出理由，可能会更快或更少地使用备忘录？
我使用node进行线性自动化，所以我认为我共享了用于测试文件存在性的功能。

1
2
3
4
5
6
7
8
9
10
11
var fs = require("fs");

function exists(path){
//Remember file access time will slow your program.
try{
fs.accessSync(path);
} catch (err){
return false;
}
return true;
}

使用文件系统(fs)测试将触发错误对象，然后需要用try/catch语句包装这些对象。节省一些精力，并使用0.4.x分支中介绍的功能。

1
2
3
4
5
6
7
8
9
10
var path = require('path');

var dirs = ['one', 'two', 'three'];

dirs.map(function(dir) {
path.exists(dir, function(exists) {
var message = (exists) ? dir + ': is a directory' : dir + ': is not a directory';
console.log(message);
});
});

相关讨论

path.exists现在位于fs下，所以它是fs.exists(path，callback)

下面是一个简单的包装解决方案：

1
2
3
4
var fs = require('fs')
function getFileRealPath(s){
try {return fs.realpathSync(s);} catch(e){return false;}
}

用途：

适用于目录和文件

如果项存在，则返回文件或目录的路径

如果项不存在，则返回false

例子：

1
2
3
4
5
6
var realPath,pathToCheck='<your_dir_or_file>'
if( (realPath=getFileRealPath(pathToCheck)) === false){
console.log('file/dir not found: '+pathToCheck);
} else {
console.log('file/dir exists: '+realPath);
}

确保使用==运算符测试返回值是否等于false。在适当的工作条件下，fs.realpathsync()不会返回false，因此我认为这应该100%有效。
我希望看到的解决方案不会产生错误并导致性能下降。从API的角度来看，fs.exists()似乎是最优雅的解决方案。

相关讨论

"丹，谢谢。我删去了删节的文字。我记不起那张便条是什么。如果是我，我会添加注释。

NP。我正在删除我的评论。

从答案来看，似乎没有官方的API对此的支持(如直接和明确的检查)。许多答案都说要使用stat，但是它们并不严格。例如，我们不能假设stat抛出的任何错误都意味着某个东西不存在。
假设我们尝试不存在的东西：

1
2
$ node -e 'require("fs").stat("god",err=>console.log(err))'
{ Error: ENOENT: no such file or directory, stat 'god' errno: -2, code: 'ENOENT', syscall: 'stat', path: 'god' }

让我们尝试一些存在但我们无法访问的内容：

1
2
3
$ mkdir -p fsm/appendage && sudo chmod 0 fsm
$ node -e 'require("fs").stat("fsm/appendage",err=>console.log(err))'
{ Error: EACCES: permission denied, stat 'access/access' errno: -13, code: 'EACCES', syscall: 'stat', path: 'fsm/appendage' }

至少你会想要：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let dir_exists = async path => {
let stat;
try {
stat = await (new Promise(
(resolve, reject) => require('fs').stat(path,
(err, result) => err ? reject(err) : resolve(result))
));
}
catch(e) {
if(e.code === 'ENOENT') return false;
throw e;
}

if(!stat.isDirectory())
throw new Error('Not a directory.');

return true;
};

这个问题不清楚你是否真的希望它是同步的，或者你只是希望它被写得像是同步的。此示例使用await/async，以便它只同步写入，但异步运行。
这意味着您必须在顶层这样称呼它：

1
2
3
4
5
6
7
8
9
(async () => {
try {
console.log(await dir_exists('god'));
console.log(await dir_exists('fsm/appendage'));
}
catch(e) {
console.log(e);
}
})();

另一种选择是使用.then和.catch来实现异步调用返回的承诺(如果需要进一步实现)。
如果您想检查某个东西是否存在，那么最好确保它是正确的类型，如目录或文件。示例中包含了这一点。如果不允许它是符号链接，则必须使用lstat而不是stat，因为stat将自动遍历链接。
您可以替换这里所有的异步来同步代码，并使用statsync代替。但是，一旦Async和Wait得到普遍支持，同步调用将成为多余的，最终会被贬低(否则，您必须在每个地方和链上定义它们，就像Async一样，使其真正没有意义)。

相关讨论

最初的问题没有说明这一点。我也在演示如何毫不含糊地做事情。由于缺乏清晰性，许多答案可能会引起错误。人们通常希望对事物进行编程，使其看起来是同步的，但不一定需要同步执行。statsync与我演示的代码不同。两种说法都是模棱两可的，所以你只是在强加你的个人解释。如果你找到了一个你不理解的答案，最好是直接在评论或下午问出来，找出需要什么样的编辑。

如果你想要的话，你也可以盗取我的代码样本，适当地命名它，放到Github上，添加到NPM中，然后答案就只有一行/链接：d。

为了举例，代码是简短的，但欢迎您提交编辑建议以包括&；&；！isfile或检查符号链接等(同样，尽管问题从未明确说明，即使这是他们想要的)。正如我已经指出的那样，我的回答满足了对问题的一种解释，并不像你的一行建议那样做。

为那些"正确"的人更新了asnewr，指出它并没有直接回答问题，更多的是带来一个备选方案。
同步解决方案：
fs.existsSync('filePath')也见这里的文件。

Returns true if the path exists, false otherwise.

异步承诺解决方案
在异步上下文中，您可以使用await关键字在sync方法中编写异步版本。您只需将异步回调方法转换为如下承诺：

1
2
3
4
5
6
7
8
9
10
11
12
13
function fileExists(path){
return new Promise((resolve, fail) => fs.access(path, fs.constants.F_OK,
(err, result) => err ? fail(err) : resolve(result))
//F_OK checks if file is visible, is default does no need to be specified.

}

async function doSomething() {
var exists = await fileExists('filePath');
if(exists){
console.log('file exists');
}
}

access()上的文档。

相关讨论

操作需要同步解决方案

关于javascript：如何调试node.js应用程序？

关于javascript:在node.js中写入文件

关于javascript：如何将命令行参数传递给node.js程序？

关于javascript：如何决定何时使用node.js？

关于javascript：node.js module.exports的目的是什么？如何使用它？

关于node.js：如何将NodeJS和NPM更新到下一个版本？

关于node.js：查找已安装的NPM包的版本