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

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

多年来，这个问题的答案一直在变化。目前的答案在顶部，接下来是历年来按时间顺序排列的各种答案：

当前答案 您可以使用：

它被弃用了好几年，但现在不再是了。从文档中：

请注意，

fs.exists（）

已被弃用，但

fs.existsSync（）

未被弃用。(修订) 回调参数到

fs.exists（）

接受 与其他Node.js回调不一致。

fs.existsSync（）

不一致 使用回调。）

您已经明确要求进行同步检查，但如果您可以使用异步检查（通常最好使用I/O），请在使用

async

函数时使用，否则（因为）：

在

async

函数中：

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

或通过回调：

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

---

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

• 2010年的原始答案
  （

  stat

  /

  statSync

  或

  lstat

  /

  lstatSync

  ）
• 2012年9月更新
  （

  存在

  /

  存在同步

  ）
• 2015年2月更新
  （注意到

  即将被弃用，存在
  /
  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

（），这将为您提供。通常，如果函数的同步版本可用，它将与异步版本具有相同的名称，并在末尾使用

Sync

。因此

statSync

是

stat

的同步版本

lstatSync

是同步版本的

lstat

等

lstatSync

告诉您是否存在某个内容，如果存在，它是文件还是目录（或者在某些文件系统中是符号链接、块设备、字符设备等），例如，如果您需要知道它是否存在并且是目录：

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

；如果条目根本不存在，它将抛出一个错误

如果您不关心条目是什么，只想知道它是否存在，您可以使用（或与最新的，

fs.existsSync

）作为：

它不需要一个

try/catch

，但不提供关于事物是什么的信息，只是它就在那里

path.existsSync

早就被弃用了

---

旁注：您明确询问了如何同步检查，因此我使用了上述函数的

xyzync

版本。但在可能的情况下，使用I/O时，最好避免同步调用。从CPU的角度来看，对I/O子系统的调用需要花费大量的时间。请注意，调用lstatSync比调用lstatSync更容易：

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

但是如果你需要同步版本，它就在那里

2012年9月更新 以下几年前的答案现在有点过时了。当前的方法是使用同步检查文件/目录是否存在（当然也可以是异步检查），而不是下面的

path

版本

例如：

var fs = require('fs');

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

// Or

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

2015年2月更新

---

在2015年，节点文档现在说

fs.existsSync

（和

fs.exists

）“将被弃用”。（因为节点人员认为在打开某个对象之前检查该对象是否存在是愚蠢的；但这不是检查该对象是否存在的唯一原因！）

所以我们可能回到了各种

stat

方法。。。当然，除非这种情况再次发生变化

2015年12月更新 不知道它在那里多久了，但也有。并且至少在2016年10月，建议使用

fs.access

进行存在性检查（“为了检查文件是否存在，而不在事后对其进行操作，建议使用

fs.access（）

”）。但是请注意，访问不可用被认为是一个错误，因此，如果您希望该文件可以访问，那么这可能是最好的：

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.exists（）

已被弃用，但

fs.existsSync（）

未被弃用。(修订) 回调参数到

fs.exists（）

接受 与其他Node.js回调不一致。

fs.existsSync（）

不一致 使用回调。）

---

path

模块不提供同步版本的

path.exists

，因此您必须使用

fs

模块

---

我能想象的最快的事情是使用

fs.realpathSync

，它将抛出一个您必须捕获的错误，因此您需要使用try/catch创建自己的包装函数。

查看源代码，有一个同步版本的

path.exists

-

path.existsSync

。看起来它在文档中被遗漏了

更新：

path.exists

和

path.existsSync

现在已被弃用。请使用

fs.e
var fs = require('fs');

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

// Or

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

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

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

var fs = require('fs');

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

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

{
  [Error: ENOENT: no such file or directory, stat 'X:\\delsdfsdf.txt']
  errno: -4058,
  code: 'ENOENT',
  syscall: 'stat',
  path: 'X:\\delsdfsdf.txt'
}

{
  [Error: EPERM: operation not permitted, stat 'X:\file.txt']
  errno: -4048,
  code: 'EPERM',
  syscall: 'stat',
  path: 'X:\\file.txt'
}

function statPath(path) {
  try {
    return fs.statSync(path);
  } catch (ex) {}
  return false;
}

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

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

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

$ 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' }

$ 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' }

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

(async () => {
    try {
        console.log(await dir_exists('god'));
        console.log(await dir_exists('fsm/appendage'));
    }
    catch(e) {
        console.log(e);
    }
})();

function getFile(path){
    try{
        return require(path);
    }catch(e){
        return false;
    }
}

const fs = require('fs');

if(fs.existsSync(<path_that_need_to_be_checked>)){
  // enter the code to excecute after the folder is there.
}
else{
  // Below code to create the folder, if its not there
  fs.mkdir('<folder_name>', cb function);
}