经过一些实验，我找到了下面使用fs的示例。Stat是异步检查文件是否存在的好方法。它还检查您的“文件”是否“真的是一个文件”(而不是一个目录)。

这个方法使用Promises，假设你使用的是异步代码库:

const fileExists = path => {
  return new Promise((resolve, reject) => {
    try {
      fs.stat(path, (error, file) => {
        if (!error && file.isFile()) {
          return resolve(true);
        }

        if (error && error.code === 'ENOENT') {
          return resolve(false);
        }
      });
    } catch (err) {
      reject(err);
    }
  });
};

如果文件不存在，承诺仍然解析，尽管是错误的。如果文件确实存在，并且它是一个目录，则is解析为true。任何试图读取文件的错误都将拒绝错误本身的承诺。

使用util的异步/等待版本。从节点8开始承诺:

const fs = require('fs');
const { promisify } = require('util');
const stat = promisify(fs.stat);

describe('async stat', () => {
  it('should not throw if file does exist', async () => {
    try {
      const stats = await stat(path.join('path', 'to', 'existingfile.txt'));
      assert.notEqual(stats, null);
    } catch (err) {
      // shouldn't happen
    }
  });
});

describe('async stat', () => {
  it('should throw if file does not exist', async () => {
    try {
      const stats = await stat(path.join('path', 'to', 'not', 'existingfile.txt'));
    } catch (err) {
      assert.notEqual(err, null);
    }
  });
});

编辑: 从节点v10.0.0开始，我们可以使用fs.promises.access(…)

检查文件是否存在的异步代码示例:

function checkFileExists(file) {
  return fs.promises.access(file, fs.constants.F_OK)
           .then(() => true)
           .catch(() => false)
}

stat的替代方法可能是使用新的fs.access(…):

简化的短承诺函数检查:

s => new Promise(r=>fs.access(s, fs.constants.F_OK, e => r(!e)))

示例用法:

let checkFileExists = s => new Promise(r=>fs.access(s, fs.constants.F_OK, e => r(!e)))
checkFileExists("Some File Location")
  .then(bool => console.log(´file exists: ${bool}´))

扩大承诺方式:

// returns a promise which resolves true if file exists:
function checkFileExists(filepath){
  return new Promise((resolve, reject) => {
    fs.access(filepath, fs.constants.F_OK, error => {
      resolve(!error);
    });
  });
}

或者如果你想同步操作:

function checkFileExistsSync(filepath){
  let flag = true;
  try{
    fs.accessSync(filepath, fs.constants.F_OK);
  }catch(e){
    flag = false;
  }
  return flag;
}

现代异步/等待方式(Node 12.8. net)。x)

const fileExists = async path => !!(await fs.promises.stat(path).catch(e => false));

const main = async () => {
    console.log(await fileExists('/path/myfile.txt'));
}

main();

我们需要使用fs.stat()或fs.access()，因为fs。Exists (path, callback)现在已弃用

另一个好方法是fs-extra

考虑直接打开或读取文件，以避免竞争条件:

const fs = require('fs');

fs.open('foo.txt', 'r', (err, fd) => {
  // ...
});

fs.readFile('foo.txt', (err, data) => {
  if (!err && data) {
    // ...
  }
})

使用fs.existsSync:

if (fs.existsSync('foo.txt')) {
  // ...
}

使用fs.stat:

fs.stat('foo.txt', function(err, stat) {
  if (err == null) {
    console.log('File exists');
  } else if (err.code === 'ENOENT') {
    // file does not exist
    fs.writeFile('log.txt', 'Some log\n');
  } else {
    console.log('Some other error: ', err.code);
  }
});

弃用:

fs。Exists已弃用。

使用path.exists:

const path = require('path');

path.exists('foo.txt', function(exists) { 
  if (exists) { 
    // ...
  } 
});

使用path.existsSync:

if (path.existsSync('foo.txt')) { 
  // ...
}

vannilla Nodejs 回调

function fileExists(path, cb){
  return fs.access(path, fs.constants.F_OK,(er, result)=> cb(!err && result)) //F_OK checks if file is visible, is default does no need to be specified.
}

文档说你应该使用access()来代替已弃用的exists()

带有内置承诺的Nodejs (node 7+)

function fileExists(path, cb){
  return new Promise((accept,deny) => 
    fs.access(path, fs.constants.F_OK,(er, result)=> cb(!err && result))
  );
}

流行的javascript框架

fs-extra

var fs = require('fs-extra')
await fs.pathExists(filepath)

如你所见，简单多了。与promisify相比，它的优势在于你可以使用这个包实现完整的类型(完整的智能感知/typescript)!大多数情况下，您已经包含了这个库，因为(+-10.000)其他库都依赖于它。