Node.js जांचें कि क्या पथ फ़ाइल या निर्देशिका है

Question

मुझे ऐसा कोई भी खोज परिणाम नहीं मिल रहा है जो यह बताता हो कि यह कैसे करना है।

मैं केवल इतना करना चाहता हूं कि यह पता चल सके कि क्या दिया गया मार्ग एक फाइल या निर्देशिका (फ़ोल्डर) है।

Answer 1

fs.lstatSync(path_string).isDirectory()आपको बताना चाहिए। से डॉक्स :

Fststat () और fs.lstat () से लौटे ऑब्जेक्ट इस प्रकार के हैं।

stats.isFile()
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() (only valid with fs.lstat())
stats.isFIFO()
stats.isSocket()

ध्यान दें:

समाधान ऊपर होगा throwएक Errorहै; पूर्व के लिए, fileया directoryमौजूद नहीं है।

यदि आप एक trueया falseदृष्टिकोण चाहते हैं , fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();तो नीचे दिए गए टिप्पणियों में जोसेफ द्वारा बताए गए अनुसार प्रयास करें।

Comments

ध्यान दें कि यदि आप सामान्य ऐप के प्रदर्शन की परवाह करते हैं तो एसिंक्रोनस संस्करण आमतौर पर बेहतर होता है।

— एलेक्सा

ध्यान रखें कि यदि निर्देशिका या फ़ाइल मौजूद नहीं है, तो आपको एक त्रुटि वापस मिल जाएगी।

— एथन मिक

let isDirExists = fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();

— जोसेफ हारुष

ध्यान रखें कि यदि फ़ाइल या निर्देशिका मौजूद नहीं है, तो वह अपवाद को फेंक देगा जिसे पकड़ने की आवश्यकता है अन्यथा यह असामान्य निकास का कारण होगा।

— सर्गेई कुजनेत्सोव

Answer 2

अद्यतन: Node.Js> = 10

हम नए fs.promises API का उपयोग कर सकते हैं

const fs = require('fs').promises;

(async() => {
    const stat = await fs.lstat('test.txt');
    console.log(stat.isFile());
})().catch(console.error)

---

कोई भी Node.Js संस्करण

यहाँ अगर एक रास्ता एक फ़ाइल या एक निर्देशिका है आप कैसे पता लगा होता है अतुल्यकालिक रूप से है, जो नोड में सिफारिश की दृष्टिकोण है। fs.lstat का उपयोग करना

const fs = require("fs");

let path = "/path/to/something";

fs.lstat(path, (err, stats) => {

    if(err)
        return console.log(err); //Handle error

    console.log(`Is file: ${stats.isFile()}`);
    console.log(`Is directory: ${stats.isDirectory()}`);
    console.log(`Is symbolic link: ${stats.isSymbolicLink()}`);
    console.log(`Is FIFO: ${stats.isFIFO()}`);
    console.log(`Is socket: ${stats.isSocket()}`);
    console.log(`Is character device: ${stats.isCharacterDevice()}`);
    console.log(`Is block device: ${stats.isBlockDevice()}`);
});

---

समकालिक API का उपयोग करते समय ध्यान दें:

सिंक्रोनस फॉर्म का उपयोग करते समय किसी भी अपवाद को तुरंत फेंक दिया जाता है। आप अपवादों को संभालने के लिए कोशिश / पकड़ का उपयोग कर सकते हैं या उन्हें बुलबुले के लिए अनुमति दे सकते हैं।

try{
     fs.lstatSync("/some/path").isDirectory()
}catch(e){
   // Handle error
   if(e.code == 'ENOENT'){
     //no such file or directory
     //do something
   }else {
     //do something else
   }
}

Comments

क्या इसे अभी भी मार्च 2020 के रूप में प्रयोगात्मक माना जाता है? हम देखने के लिए कहाँ देख सकते हैं? - उफ़ मैं देखता हूं जब मैं ऊपर की लिंक पर क्लिक करता हूं तो यह अब स्थिर है (जिसका अर्थ है कि अब प्रायोगिक नहीं है)।

— अल्फ्रेमा

Answer 3

गंभीरता से, सवाल पांच साल और कोई अच्छा मुखौटा मौजूद है?

function is_dir(path) {
    try {
        var stat = fs.lstatSync(path);
        return stat.isDirectory();
    } catch (e) {
        // lstatSync throws an error if path doesn't exist
        return false;
    }
}

Answer 4

अपनी आवश्यकताओं के आधार पर, आप शायद नोड के pathमॉड्यूल पर भरोसा कर सकते हैं ।

आप फ़ाइल सिस्टम को हिट करने में सक्षम नहीं हो सकते हैं (उदाहरण के लिए फ़ाइल अभी तक नहीं बनाई गई है) और tbh आप शायद फ़ाइल सिस्टम से टकराने से बचना चाहते हैं जब तक कि आपको वास्तव में अतिरिक्त सत्यापन की आवश्यकता न हो। यदि आप यह अनुमान लगा सकते हैं कि आप इस प्रकार के .<extname>प्रारूप के लिए क्या जाँच रहे हैं , तो बस नाम को देखें।

जाहिर है कि अगर आप किसी extname के बिना किसी फ़ाइल की तलाश कर रहे हैं तो आपको यह सुनिश्चित करने के लिए फाइल सिस्टम को हिट करने की आवश्यकता होगी। लेकिन इसे तब तक सरल रखें जब तक आपको अधिक जटिल की आवश्यकता न हो।

const path = require('path');

function isFile(pathItem) {
  return !!path.extname(pathItem);
}

Comments

जाहिर है कि यह सभी स्थितियों में काम नहीं करेगा लेकिन अन्य उत्तरों की तुलना में यह बहुत तेज और आसान है यदि आप आवश्यक अनुमान लगा सकते हैं।

— इलेक्ट्रोविर

Answer 5

ऊपर दिए गए उत्तर यह जांचते हैं कि क्या फाइलसिस्टम में एक पथ है जो एक फ़ाइल या निर्देशिका है। लेकिन यह इस बात की पहचान नहीं करता है कि एक दिया हुआ रास्ता एक फ़ाइल या निर्देशिका है।

इसका उत्तर "/" का उपयोग करके निर्देशिका-आधारित पथों की पहचान करना है। जैसे -> "/ c / dos / run /।" <- अनुगामी अवधि।

किसी निर्देशिका या फ़ाइल के पथ की तरह, जिसे अभी तक नहीं लिखा गया है। या एक अलग कंप्यूटर से एक पथ। या एक पथ जहाँ एक ही नाम की फ़ाइल और निर्देशिका दोनों मौजूद हैं।

// /tmp/
// |- dozen.path
// |- dozen.path/.
//    |- eggs.txt
//
// "/tmp/dozen.path" !== "/tmp/dozen.path/"
//
// Very few fs allow this. But still. Don't trust the filesystem alone!

// Converts the non-standard "path-ends-in-slash" to the standard "path-is-identified-by current "." or previous ".." directory symbol.
function tryGetPath(pathItem) {
    const isPosix = pathItem.includes("/");
    if ((isPosix && pathItem.endsWith("/")) ||
        (!isPosix && pathItem.endsWith("\\"))) {
        pathItem = pathItem + ".";
    }
    return pathItem;
}
// If a path ends with a current directory identifier, it is a path! /c/dos/run/. and c:\dos\run\.
function isDirectory(pathItem) {
    const isPosix = pathItem.includes("/");
    if (pathItem === "." || pathItem ==- "..") {
        pathItem = (isPosix ? "./" : ".\\") + pathItem;
    }
    return (isPosix ? pathItem.endsWith("/.") || pathItem.endsWith("/..") : pathItem.endsWith("\\.") || pathItem.endsWith("\\.."));
} 
// If a path is not a directory, and it isn't empty, it must be a file
function isFile(pathItem) {
    if (pathItem === "") {
        return false;
    }
    return !isDirectory(pathItem);
}

नोड संस्करण: v11.10.0 - फरवरी 2019

अंतिम विचार: फाइलसिस्टम को भी क्यों मारा?

Answer 6

यहां एक फ़ंक्शन है जिसका मैं उपयोग करता हूं। कोई भी इस पोस्ट में उपयोग promisifyऔर await/asyncसुविधा नहीं बना रहा है तो मैंने सोचा कि मैं साझा करूंगा।

const promisify = require('util').promisify;
const lstat = promisify(require('fs').lstat);

async function isDirectory (path) {
  try {
    return (await lstat(path)).isDirectory();
  }
  catch (e) {
    return false;
  }
}

नोट: मैं इसका उपयोग नहीं करता require('fs').promises;क्योंकि यह एक वर्ष के लिए प्रायोगिक रहा है, बेहतर है कि इस पर भरोसा न करें।