파일이 있는지 어떻게 확인 합니까?

모듈의 문서 fs에는 메소드에 대한 설명이 fs.exists(path, callback)있습니다. 그러나 내가 이해하는 것처럼 디렉토리 만 존재하는지 확인합니다. 그리고 파일 을 확인해야 합니다 !

어떻게 할 수 있습니까?

왜 파일을 열어 보지 않겠습니까? fs.open('YourFile', 'a', function (err, fd) { ... }) 어쨌든 1 분 검색 후 이것을 시도하십시오 :

var path = require('path'); 

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

// or 

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

Node.js v0.12.x 이상

모두 path.exists와 fs.exists사용되지 않습니다

*편집하다:

변경 : else if(err.code == 'ENOENT')

에: else if(err.code === 'ENOENT')

Linter는 double equals가 triple equals가 아니라고 불평합니다.

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

이 작업을 동 기적으로 수행하는 가장 쉬운 방법입니다.

if (fs.existsSync('/etc/file')) {
    console.log('Found file');
}

API 문서는 existsSync작동 방식을 말합니다
. 파일 시스템을 확인하여 주어진 경로가 존재하는지 여부를 테스트하십시오.

편집 :v10.0.0 우리가 사용할 수있는 노드 이후fs.promises.access(...)

파일이 있는지 확인하는 비동기 코드 예제 :

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

stat의 대안은 new 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;
}

fs.exists(path, callback)그리고 fs.existsSync(path), 지금은 사용되지 않는 볼 수 있습니다 https://nodejs.org/api/fs.html#fs_fs_exists_path_callback 및 https://nodejs.org/api/fs.html#fs_fs_existssync_path .

파일의 존재를 동 기적으로 테스트하기 위해 ie를 사용할 수 있습니다. fs.statSync(path). fs.Stats파일이 존재하는 경우 객체 참조 반환됩니다 https://nodejs.org/api/fs.html#fs_class_fs_stats를 , 그렇지 않으면 오류가 시도 / catch 문에 의해 사로 잡았 될 슬로우됩니다.

var fs = require('fs'),
  path = '/path/to/my/file',
  stats;

try {
  stats = fs.statSync(path);
  console.log("File exists.");
}
catch (e) {
  console.log("File does not exist.");
}

V6 이전 버전 : 다음은 문서입니다

  const fs = require('fs');    
  fs.exists('/etc/passwd', (exists) => {
     console.log(exists ? 'it\'s there' : 'no passwd!');
  });
// or Sync

  if (fs.existsSync('/etc/passwd')) {
    console.log('it\'s there');
  }

최신 정보

V6의 새 버전 : 대한 설명서fs.stat

fs.stat('/etc/passwd', function(err, stat) {
    if(err == null) {
        //Exist
    } else if(err.code == 'ENOENT') {
        // NO exist
    } 
});

최신 비동기 / 대기 방법 (노드 12.8.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() or fs.access()있기 때문에 fs.exists(path, callback)지금은 사용되지 않습니다

또 다른 좋은 방법은 fs-extra입니다.

fs.exists1.0.0부터 사용되지 않습니다. fs.stat대신 사용할 수 있습니다 .

var fs = require('fs');
fs.stat(path, (err, stats) => {
if ( !stats.isFile(filename) ) { // do this 
}  
else { // do this 
}});

다음은 설명서 fs.stats에 대한 링크입니다.

@ 폭스 : 좋은 대답! 더 많은 옵션이있는 약간의 확장 기능이 있습니다. 최근에 이동 솔루션으로 사용하고 있습니다.

var fs = require('fs');

fs.lstat( targetPath, function (err, inodeStatus) {
  if (err) {

    // file does not exist-
    if (err.code === 'ENOENT' ) {
      console.log('No file or directory at',targetPath);
      return;
    }

    // miscellaneous error (e.g. permissions)
    console.error(err);
    return;
  }


  // Check if this is a file or directory
  var isDirectory = inodeStatus.isDirectory();


  // Get file size
  //
  // NOTE: this won't work recursively for directories-- see:
  // http://stackoverflow.com/a/7550430/486547
  //
  var sizeInBytes = inodeStatus.size;

  console.log(
    (isDirectory ? 'Folder' : 'File'),
    'at',targetPath,
    'is',sizeInBytes,'bytes.'
  );


}

PS 아직 사용하지 않는 경우 fs-extra를 확인하십시오. 달콤합니다. https://github.com/jprichardson/node-fs-extra )

fs.existsSync()더 이상 사용되지 않는 것에 대한 부정확 한 의견이 많이 있습니다 . 그렇지 않습니다.

https://nodejs.org/api/fs.html#fs_fs_existssync_path

fs.exists ()는 더 이상 사용되지 않지만 fs.existsSync ()는 사용되지 않습니다.

async/awaitutil.promisify노드 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);
    }
  });
});

  fs.statSync(path, function(err, stat){
      if(err == null) {
          console.log('File exists');
          //code when all ok
      }else if (err.code == "ENOENT") {
        //file doesn't exist
        console.log('not file');

      }
      else {
        console.log('Some other error: ', err.code);
      }
    });

약간의 실험을 한 후 다음 예제를 사용하여 fs.stat파일이 존재하는지 비동기 적으로 확인하는 것이 좋습니다. 또한 "파일"이 "실제로 파일"(디렉토리가 아님)인지 확인합니다.

이 방법은 비동기 코드베이스로 작업한다고 가정하고 약속을 사용합니다.

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

파일이 존재하지 않더라도 약속은 여전히 ​​해결 false됩니다. 파일이 존재하고 디렉토리 인 경우 resolve true입니다. 파일을 읽으려고 시도하는 모든 오류 reject는 오류 자체를 약속합니다.

https://nodejs.org/api/fs.html#fs_fs_access_path_mode_callback에서 볼 수 있듯이이 방법으로했습니다.

fs.access('./settings', fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK, function(err){
  console.log(err ? 'no access or dir doesnt exist' : 'R/W ok');

  if(err && err.code === 'ENOENT'){
    fs.mkdir('settings');
  }
});

이것에 문제가 있습니까?

앉기 전 옛날에는 의자가 있는지 항상 확인한 다음 다른 의자에 앉아 코치와 같은 대안 계획을 세웁니다. 이제 node.js 사이트는 그냥 갈 필요가 없으며 (확인 할 필요가 없음) 대답은 다음과 같습니다.

    fs.readFile( '/foo.txt', function( err, data )
    {
      if(err) 
      {
        if( err.code === 'ENOENT' )
        {
            console.log( 'File Doesn\'t Exist' );
            return;
        }
        if( err.code === 'EACCES' )
        {
            console.log( 'No Permission' );
            return;
        }       
        console.log( 'Unknown Error' );
        return;
      }
      console.log( data );
    } );

2014 년 3 월 부터 http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js/ 에서 가져온 코드 이며 컴퓨터에 맞게 약간 수정되었습니다. 권한도 확인합니다-테스트 권한 제거chmod a-r foo.txt

바닐라 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 (노드 7 이상)

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

인기있는 자바 스크립트 프레임 워크

fs-extra

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

당신이 훨씬 더 간단하게 볼 수 있습니다. 그리고 약속보다 더 유리한 점은이 패키지로 완전한 타이핑을 할 수 있다는 것입니다 (완전한 정보 / 타입 스크립트)! (+ -10.000) 다른 라이브러리가이 라이브러리에 의존하기 때문에 대부분이 라이브러리를 포함했을 것입니다.

fs.stat대상이 파일 또는 디렉토리인지 확인 하는 데 사용할 수 있으며 파일을 쓰거나 fs.access읽거나 실행할 수 있는지 확인할 수 있습니다. ( path.resolve대상의 전체 경로를 얻는 데 사용해야 함)

선적 서류 비치:

• path.resolve
• fs.stat
• fs.access

전체 예 (TypeScript)

import * as fs from 'fs';
import * as path from 'path';

const targetPath = path.resolve(process.argv[2]);

function statExists(checkPath): Promise<fs.Stats> {
  return new Promise((resolve) => {
    fs.stat(checkPath, (err, result) => {
      if (err) {
        return resolve(undefined);
      }

      return resolve(result);
    });
  });
}

function checkAccess(checkPath: string, mode: number = fs.constants.F_OK): Promise<boolean> {
  return new Promise((resolve) => {
    fs.access(checkPath, mode, (err) => {
      resolve(!err);
    });
  });
}

(async function () {
  const result = await statExists(targetPath);
  const accessResult = await checkAccess(targetPath, fs.constants.F_OK);
  const readResult = await checkAccess(targetPath, fs.constants.R_OK);
  const writeResult = await checkAccess(targetPath, fs.constants.W_OK);
  const executeResult = await checkAccess(targetPath, fs.constants.X_OK);
  const allAccessResult = await checkAccess(targetPath, fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);

  if (result) {
    console.group('stat');
    console.log('isFile: ', result.isFile());
    console.log('isDir: ', result.isDirectory());
    console.groupEnd();
  }
  else {
    console.log('file/dir does not exist');
  }

  console.group('access');
  console.log('access:', accessResult);
  console.log('read access:', readResult);
  console.log('write access:', writeResult);
  console.log('execute access:', executeResult);
  console.log('all (combined) access:', allAccessResult);
  console.groupEnd();

  process.exit(0);
}());

비동기 버전! 그리고 약속 버전으로! 여기 깨끗하고 간단한 방법!

try {
    await fsPromise.stat(filePath);
    /**
     * File exists!
     */
    // do something
} catch (err) {
    if (err.code = 'ENOENT') {
        /**
        * File not found
        */
    } else {
        // Another error!
    }
}

더 나은 설명을 위해 내 코드에서보다 실용적인 스 니펫 :

try {
    const filePath = path.join(FILES_DIR, fileName);
    await fsPromise.stat(filePath);
    /**
     * File exists!
     */
    const readStream = fs.createReadStream(
        filePath,
        {
            autoClose: true,
            start: 0
        }
    );

    return {
        success: true,
        readStream
    };
} catch (err) {
    /**
     * Mapped file doesn't exists
     */
    if (err.code = 'ENOENT') {
        return {
            err: {
                msg: 'Mapped file doesn\'t exists',
                code: EErrorCode.MappedFileNotFound
            }
        };
    } else {
        return {
            err: {
                msg: 'Mapped file failed to load! File system error',
                code: EErrorCode.MappedFileFileSystemError
            }
        }; 
   }
}

위의 예는 단지 설명을위한 것입니다! 읽기 스트림의 오류 이벤트를 사용할 수있었습니다! 오류를 잡기 위해! 그리고 두 통화를 건너 뛰십시오!