Bir dosyanın varlığını nasıl kontrol ederim ?

Modülün belgelerinde fsyöntemin bir açıklaması vardır fs.exists(path, callback). Ama anladığım kadarıyla, sadece dizinlerin varlığını kontrol ediyor. Ve dosyayı kontrol etmem gerekiyor !

Bu nasıl yapılabilir?

Neden sadece dosyayı açmayı denemiyorsunuz? fs.open('YourFile', 'a', function (err, fd) { ... }) bir dakika aramasından sonra yine de şunu deneyin:

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 ve üstü için

Hem path.existsve fs.existskullanımdan kaldırıldı

*Düzenle:

Değişen: else if(err.code == 'ENOENT')

için: else if(err.code === 'ENOENT')

Linter çifte eşittir üçlü eşit olmamasından şikayet eder.

Fs.stat kullanma:

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

Bunu eşzamanlı olarak yapmanın daha kolay bir yolu.

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

API dokümanı nasıl existsSyncçalıştığını söylüyor :
Dosya sistemi ile kontrol ederek verilen yolun var olup olmadığını test edin.

Düzenleme: Düğümden beri v10.0.0kullanabilirizfs.promises.access(...)

Dosyanın var olup olmadığını kontrol eden örnek zaman uyumsuz kod:

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

Stat için bir alternatif yeni olanı kullanıyor olabilir fs.access(...):

kontrol için minimize kısa söz fonksiyonu:

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

Örnek kullanım:

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

genişletilmiş Promise yolu:

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

veya senkronize olarak yapmak istiyorsanız:

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

fs.exists(path, callback)ve fs.existsSync(path)şimdi kullanımdan kaldırılmışsa, bkz. https://nodejs.org/api/fs.html#fs_fs_exists_path_callback ve https://nodejs.org/api/fs.html#fs_fs_existssync_path .

Bir dosyanın varlığını eşzamanlı olarak test etmek için ie kullanılabilir. fs.statSync(path). fs.StatsDosya varsa bir nesne döndürülür, bkz. Https://nodejs.org/api/fs.html#fs_class_fs_stats , aksi takdirde try / catch deyimi tarafından yakalanacak bir hata atılır.

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 öncesi Eski Sürüm: işte belgeler

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

GÜNCELLEME

V6 yeni sürümleri: için dokümantasyonfs.stat

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

Modern eşzamansız / bekliyor yolu (Düğüm 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();

Kullanmamız lazım fs.stat() or fs.access()çünkü fs.exists(path, callback)şimdi kullanımdan kaldırıldı

Başka bir iyi yol da fs-extra

fs.exists1.0.0'dan beri kullanımdan kaldırıldı. Bunun fs.statyerine kullanabilirsiniz .

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

İşte fs.stats dokümanlarının bağlantısı

@Fox: harika cevap! İşte biraz daha fazla seçenek içeren bir uzantı. Son zamanlarda bir çözüm olarak kullandığım şey bu:

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, zaten kullanmıyorsanız fs-extra'ya bakın - oldukça tatlı. https://github.com/jprichardson/node-fs-extra )

Kullanımdan fs.existsSync()kaldırılmayla ilgili birçok yanlış yorum var ; o değil.

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

Fs.exists () öğesinin kullanımdan kaldırıldığını, ancak fs.existsSync () öğesinin kullanılmadığını unutmayın.

async/awaitutil.promisifyDüğüm 8'den itibaren sürüm :

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

Biraz deneme yaptıktan sonra, fs.statbir dosyanın var olup olmadığını zaman uyumsuz bir şekilde kontrol etmek için iyi bir yol olarak kullanarak aşağıdaki örneği buldum . Ayrıca, "dosyanızın" "gerçekten bir dosya" olduğunu (bir dizin değil) kontrol eder.

Bu yöntem, zaman uyumsuz bir kod tabanıyla çalıştığınızı varsayarak Promises kullanır:

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

Dosya yoksa, vaat yine de çözülür false. Dosya varsa ve bir dizinse, çözümlenir true. Dosyayı okumaya çalışan herhangi bir hata reject, hatanın kendisine söz verecektir .

Bunu https://nodejs.org/api/fs.html#fs_fs_access_path_mode_callback adresinde görüldüğü gibi yaptım.

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

Bununla ilgili bir problem var mı?

eski günlerde oturmadan önce sandalyenin orada olup olmadığını her zaman kontrol ederim. Şimdi node.js sitesi sadece gitmenizi öneriyor (kontrol etmeye gerek yok) ve cevap şöyle görünüyor:

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

kodu http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js/ adresinden Mart 2014'ten alınmıştır ve bilgisayara uyacak şekilde biraz değiştirilmiştir. İzni de denetler - test etme iznini kaldırınchmod a-r foo.txt

vannilla Nodejs geri arama

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

docs kullanmak gerektiğini söylüyorlar access()kaldırılmış için bir yedek olarakexists()

Söz verilen düğümler (düğüm 7+)

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

Popüler javascript çerçevesi

fs-ekstra

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

Gördüğünüz gibi çok daha basit. Ve promisify'a göre avantajı, bu paket ile tam yazımlara sahip olmanızdır (tam intellisense / daktilo)! Vakaların çoğu zaten bu kütüphaneyi ekleyeceksiniz çünkü (+ -10.000) diğer kütüphaneler buna bağlı.

Sen kullanabilirsiniz fs.statHedef bir dosya veya dizin olup olmadığını kontrol etmek ve kullanabileceğiniz fs.accessyazabilir eğer / check okuma / dosyasını çalıştırmak. ( path.resolvehedefin tam yolunu bulmak için kullanmayı unutmayın )

Belgeler:

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

Tam örnek (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);
}());

Zaman uyumsuz sürüm için! Ve söz sürümüyle! İşte temiz basit yol!

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

Daha iyi göstermek için kodumdan daha pratik bir snippet:

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

Yukarıdaki örnek sadece tanıtım amaçlıdır! Okuma akışının hata olayını kullanabilirdim! Herhangi bir hata yakalamak için! Ve iki çağrıyı atlayın!