यदि फ़ाइल मौजूद है तो Node.js की जाँच करें

Question

मैं फ़ाइल के अस्तित्व की जाँच कैसे करूँ ?

मॉड्यूल के लिए प्रलेखन fsमें विधि का वर्णन है fs.exists(path, callback)। लेकिन, जैसा कि मैं समझता हूं, यह केवल निर्देशिकाओं के अस्तित्व की जांच करता है। और मुझे फ़ाइल की जांच करने की आवश्यकता है !

यह कैसे किया जा सकता है?

Comments

2018 तक, उपयोग करें fs.access('file', err => err ? 'does not exist' : 'exists'), fs.access

— mb21

Answer 1

सिर्फ फाइल खोलने की कोशिश क्यों नहीं की गई? fs.open('YourFile', 'a', function (err, fd) { ... }) वैसे भी एक मिनट की खोज के बाद यह कोशिश करें:

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

लाइनर ट्रिपल बराबर नहीं होने के बारे में शिकायत करता है।

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

Comments

लेकिन, जैसा कि यह निकला, fs.existsकाम भी करता है। मुझे फ़ाइल की अनुमति के साथ समस्या है।

— रोमनगोर्बतको

path.existsवास्तव मेंfs.exists

— अरनौद रिनक्विन

किसी को भी यह अब (Node.js v0.12.x) पढ़ने ध्यान रखें कि fs.existsऔर fs.existsSyncभी बहिष्कृत कर दिया गया है। फ़ाइल अस्तित्व की जांच करने का सबसे अच्छा तरीका है fs.stat, जैसा कि ऊपर दर्शाया गया है।

— अंतीक्षि

नोड js दस्तावेज़ीकरण से, ऐसा लगता है कि यदि आप फ़ाइल को उसके अस्तित्व की जाँच करने के बाद खोलने की योजना बना रहे हैं, तो यह वास्तव में इसे खोलना है और मौजूद नहीं होने पर त्रुटियों को संभालना है। क्योंकि आपकी फ़ाइल आपके मौजूद चेक और खुले फ़ंक्शन के बीच निकाली जा सकती है ...

— newprog

@Antrikshy fs.existsSyncअब वंचित नहीं है, हालांकि fs.existsअभी भी है।

— रयानजिम

Answer 2

इसे सिंक्रोनाइज़ करने का एक आसान तरीका है।

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

एपीआई डॉक का कहना है कि कैसे existsSyncकाम करते हैं:
फ़ाइल सिस्टम के साथ जांच करके दिए गए पथ मौजूद हैं या नहीं, इसका परीक्षण करें।

Comments

fs.existsSync(path)अब पदावनत कर दिया गया है, देखें नोडज्स . org/api/fs.html#fs_fs_existssync_path । एक तुल्यकालिक कार्यान्वयन के fs.statSync(path)लिए सलाह दी जाती है, मेरा उत्तर देखें।

— lmeurs

@Imeurs लेकिन nodejs.org/api/fs.html#fs_fs_existssync_path कहते हैं: ध्यान दें कि fs.exists () पदावनत है, लेकिन fs.existsSync () नहीं है।

— HaveF

fs.existsSyncपदावनत कर दिया गया था, लेकिन अब यह नहीं है।

— रयानजिम

Answer 3

संपादित करें: नोड के बाद से v10.0.0हम उपयोग कर सकते हैंfs.promises.access(...)

उदाहरण async कोड जो जाँचता है कि फ़ाइल मौजूद है:

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

---

स्टेट के लिए एक विकल्प नया प्रयोग कर सकता है 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;
}

Comments

Upvoted, यह निश्चित रूप से पता लगाने के लिए सबसे आधुनिक (2018) तरीका है कि क्या कोई फाइल Node.js में मौजूद है

— AKMorris

हाँ, यह आधिकारिक रूप से जाँचने का तरीका है कि फाइल मौजूद है या नहीं और बाद में हेरफेर की उम्मीद नहीं है। अन्यथा खुले / लिखने / पढ़ने का उपयोग करें और त्रुटि को संभालें। nodejs.org/api/fs.html#fs_fs_stat_path_callback

— जस्टिन

प्रलेखन में मुझे लगता है fs.constants.F_OKआदि। क्या उन्हें भी एक्सेस करना संभव है fs.F_OK? अजीब। इसके अलावा, जो अच्छा है।

— सैमसन

fs.promises.access(path, fs.constants.F_OK);बस एक वादा बनाने के बजाय इसे एक वादा करने के साथ इसे करने की कोशिश कर सकते हैं ।

— जेरेमी ट्रपका

Answer 4

fs.exists(path, callback)और fs.existsSync(path)अभी पदावनत हो चुके हैं, https://nodejs.org/api/fs.html#fs_fs_ex_exists_path_callback और https://nodejs.org/api/fs.html#fs_fs_exnitsyncync_path देखें ।

एक फ़ाइल के अस्तित्व का परीक्षण करने के लिए सिंक्रोनाइज़ एक का उपयोग कर सकते हैं। fs.statSync(path)। fs.Statsफ़ाइल मौजूद होने पर कोई ऑब्जेक्ट लौटाया जाएगा, https://nodejs.org/api/fs.html#fs_class_fs_stats देखें , अन्यथा एक त्रुटि डाली जाती है जिसे प्रयास / कैच स्टेटमेंट द्वारा पकड़ा जाएगा।

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

Comments

Fs.existsync के लिए आपके द्वारा प्रदान किया गया लिंक स्पष्ट रूप से यह बताता है कि यह "पदावनति नहीं है" ध्यान दें कि fs.exists () पदावनत है, लेकिन fs.existsSync () नहीं है। (fs.exists के लिए कॉलबैक पैरामीटर) (असंगत हैं पैरामीटर को स्वीकार करता है)। अन्य Node.js कॉलबैक के साथ। fs.existsSync () एक कॉलबैक का उपयोग नहीं करता है।) "

— shreddish

पहला (ऊपर से) उत्तर, जिसमें उल्लेख किया गया है कि fsचर कहाँ से आता है

— दिमित्री कोरोलीव

जिस समय यह उत्तर लिखा गया था, जानकारी सही थी; हालाँकि, fs.existsSync()अब वंचित नहीं है।

— रेयानजिम

Answer 5

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

Comments

दोनों fs.existsऔर fs.existsSyncलिंक आप साझा के अनुसार पदावनत कर रहे हैं।

— एंडी

existsSyncउस डॉक्टर के अनुसार पदावनत नहीं किया जाता है, जब आप इसे पढ़ते हैं तो यह हो सकता है।

— डारपन

Answer 6

आधुनिक async / प्रतीक्षित तरीका (नोड 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)अब पदावनत कर दिया गया है

एक और अच्छा तरीका एफएस-अतिरिक्त है

Answer 7

fs.exists1.0.0 के बाद से पदावनत कर दिया गया है। आप fs.statइसके बजाय उपयोग कर सकते हैं ।

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

यहाँ प्रलेखन fststats के लिए लिंक है

Comments

stats.isFile()की जरूरत नहीं है filename।

— 12

Answer 8

@ फॉक्स: शानदार जवाब! यहां कुछ और विकल्पों के साथ थोड़ा विस्तार दिया गया है। यह वही है जो मैं हाल ही में एक समाधान के रूप में उपयोग कर रहा हूं:

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 )

Answer 9

fs.existsSync()पदावनत किए जाने के बारे में बहुत सारी गलत टिप्पणियां हैं ; यह नहीं।

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

ध्यान दें कि fexexists () पदावनत है, लेकिन fs.existsSync () नहीं है।

Answer 10

async/awaitutil.promisifyNode 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);
    }
  });
});

Answer 11

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

Answer 12

थोड़े से प्रयोग के बाद, मुझे निम्न उदाहरण मिला कि 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। यदि फ़ाइल मौजूद है, और यह एक निर्देशिका है, तो हल है true। फ़ाइल को पढ़ने का प्रयास करने वाली कोई भी rejectत्रुटि त्रुटि का वादा करेगी ।

Answer 13

वैसे मैंने इसे इस तरह किया, जैसा कि https://nodejs.org/api/fs.html#fs_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');
  }
});

क्या इससे कोई समस्या है?

Answer 14

पुराने दिनों में बैठने से पहले मैं हमेशा देखता हूं कि अगर कुर्सी है तो मैं बैठता हूं और मेरे पास एक वैकल्पिक योजना है जैसे कोच पर बैठना। अब नोड.जेएस साइट का सुझाव है कि बस जाएं (जांच की कोई आवश्यकता नहीं है) और उत्तर इस तरह दिखता है:

    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 से http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js/ से लिया गया कोड , और फिट कंप्यूटर के लिए थोड़ा संशोधित। यह अनुमति के लिए भी जाँच करता है - परीक्षण के लिए अनुमति को हटा देंchmod a-r foo.txt

Answer 15

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()

निर्माण में वादे के साथ नोड्स (नोड 7+)

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

लोकप्रिय जावास्क्रिप्ट फ्रेमवर्क

FS-अतिरिक्त

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

जैसा कि आप बहुत सरल देखते हैं। और प्रॉमिस करने पर लाभ यह है कि आपके पास इस पैकेज के साथ पूर्ण टाइपिंग है (पूर्ण इंटेलीसेन्स / टाइपस्क्रिप्ट)! अधिकांश मामलों में आपने पहले ही इस लाइब्रेरी को शामिल कर लिया होगा क्योंकि (+ -10.000) अन्य पुस्तकालय इस पर निर्भर हैं।

Answer 16

आप यह fs.statजांचने के लिए उपयोग कर सकते हैं कि क्या लक्ष्य एक फ़ाइल या निर्देशिका है और आप यह fs.accessजांचने के लिए उपयोग कर सकते हैं कि क्या आप फ़ाइल को लिख / पढ़ / निष्पादित कर सकते हैं। ( path.resolveलक्ष्य के लिए पूर्ण पथ पाने के लिए उपयोग करना याद रखें )

प्रलेखन:

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

पूर्ण उदाहरण (टाइपस्क्रिप्ट)

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

Answer 17

अतुल्यकालिक संस्करण के लिए! और वादा संस्करण के साथ! यहाँ साफ सरल तरीका है!

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

ऊपर का उदाहरण सिर्फ प्रदर्शन के लिए है! मैं पठन स्ट्रीम की त्रुटि घटना का उपयोग कर सकता था! किसी भी त्रुटि को पकड़ने के लिए! और दो कॉल छोड़ें!