Node.js गाइड, भाग 9: फ़ाइल सिस्टम के साथ कार्य करना

आज, Node.js ट्यूटोरियल के अनुवाद के नौवें भाग में, हम फाइलों के साथ काम करने के बारे में बात करेंगे। विशेष रूप से, हम fs और पथ मॉड्यूल के बारे में बात करेंगे - फ़ाइल डिस्क्रिप्टर के बारे में, फ़ाइल पथों के बारे में, फ़ाइलों के बारे में जानकारी प्राप्त करने, उन्हें पढ़ने और लिखने के बारे में, निर्देशिकाओं के साथ काम करने के बारे में।

Node.js में फ़ाइल डिस्क्रिप्टर के साथ कार्य करना

इससे पहले कि आप अपने सर्वर के फाइल सिस्टम में स्थित फाइलों के साथ बातचीत कर सकें, आपको एक फाइल डिस्क्रिप्टर प्राप्त करना होगा।

फ़ाइल खोलने के लिए fs मॉड्यूल से एसिंक्रोनस open() विधि का उपयोग करके विवरणक प्राप्त किया जा सकता है:

 const fs = require('fs') fs.open('/Users/flavio/test.txt', 'r', (err, fd) => { //fd -    }) 

fs.open() विधि को कॉल करते समय उपयोग किए जाने वाले दूसरे पैरामीटर, r ध्यान दें। यह एक ध्वज है जो सिस्टम को बताता है कि फ़ाइल को पढ़ने के लिए खोला जा रहा है। यहाँ कुछ और झंडे दिए गए हैं जो अक्सर इस और कुछ अन्य तरीकों से काम करते समय उपयोग किए जाते हैं:

• r+ - पढ़ने और लिखने के लिए फ़ाइल खोलें।
• w+ - फाइल के शुरुआत में स्ट्रीम पॉइंटर सेट करके पढ़ने और लिखने के लिए फाइल खोलें। यदि फ़ाइल मौजूद नहीं है, तो यह बनाई गई है।
• a - फाइल के अंत में स्ट्रीम पॉइंटर सेट करके लिखने के लिए फाइल खोलें। यदि फ़ाइल मौजूद नहीं है, तो यह बनाई गई है।
• a+ - फ़ाइल के अंत में स्ट्रीम पॉइंटर सेट करके पढ़ने और लिखने के लिए फ़ाइल खोलें। यदि फ़ाइल मौजूद नहीं है, तो यह बनाई गई है।

फ़ाइलें सिंक्रोनस विधि fs.openSync() का उपयोग करके खोली जा सकती हैं, जो कॉलबैक में फ़ाइल डिस्क्रिप्टर प्रदान करने के बजाय इसे लौटा देती है:

 const fs = require('fs') try { const fd = fs.openSync('/Users/flavio/test.txt', 'r') } catch (err) { console.error(err) } 

उपरोक्त विधियों में से किसी का उपयोग करके विवरणक प्राप्त करने के बाद, आप इसके साथ आवश्यक संचालन कर सकते हैं।

फ़ाइल डेटा

प्रत्येक फ़ाइल में इसके साथ एक डेटा सेट जुड़ा होता है; आप इस डेटा को Node.js. का उपयोग करके जांच सकते हैं विशेष रूप से, यह fs मॉड्यूल से stat() विधि का उपयोग करके किया जा सकता है।

इस विधि को कहा जाता है, फ़ाइल के लिए पथ को पास करना, और Node.js के बाद फ़ाइल के बारे में आवश्यक जानकारी प्राप्त करने के बाद, यह कॉलबैक को पारित विधि stat() विधि को कॉल करेगा। यहाँ यह कैसा दिखता है:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } //      `stats` }) 

Node.js में फ़ाइल जानकारी को सिंक्रोनाइज़ करने की क्षमता होती है। इस दृष्टिकोण के साथ, फ़ाइल के गुण प्राप्त होने तक मुख्य धागा अवरुद्ध है:

 const fs = require('fs') try { const stats = fs.statSync ('/Users/flavio/test.txt') } catch (err) { console.error(err) } 

फ़ाइल के बारे में जानकारी stats स्थिर में गिर जाएगी। इसकी जानकारी क्या है? वास्तव में, संबंधित वस्तु हमें बड़ी संख्या में उपयोगी गुण और तरीके प्रदान करती है:

• .isFile() और .isDirectory() विधियाँ क्रमशः अनुमति देती हैं, यह पता लगाने के लिए कि क्या जाँच की गई फ़ाइल एक नियमित फ़ाइल या निर्देशिका है।
• .isSymbolicLink() विधि आपको .isSymbolicLink() कि क्या कोई फ़ाइल एक प्रतीकात्मक लिंक है।
• फ़ाइल आकार को .size प्रॉपर्टी का उपयोग करके पाया जा सकता है।

यहां अन्य विधियां हैं, लेकिन ये सबसे अधिक उपयोग की जाती हैं। यहां उनका उपयोग करने का तरीका बताया गया है:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } stats.isFile() //true stats.isDirectory() //false stats.isSymbolicLink() //false stats.size //1024000 //= 1MB }) 

Node.js और पथ मॉड्यूल में फ़ाइल पथ

फ़ाइल पथ फ़ाइल सिस्टम में उस स्थान का पता है जहां वह स्थित है।

लिनक्स और macOS पर, पथ इस तरह दिख सकता है:

 /users/flavio/file.txt 

विंडोज पर, रास्ते थोड़े अलग दिखते हैं:

 C:\users\flavio\file.txt 

विभिन्न ऑपरेटिंग सिस्टम का उपयोग करते समय पथ रिकॉर्डिंग स्वरूपों में अंतर को ध्यान में रखा जाना चाहिए, ऑपरेटिंग सिस्टम को Node.js सर्वर को तैनात करने के लिए उपयोग किया जाता है।

Node.js में फ़ाइल पथ के साथ काम करने के लिए डिज़ाइन किया गया एक मानक path मॉड्यूल है। एक कार्यक्रम में इस मॉड्यूल का उपयोग करने से पहले, इसे जुड़ा होना चाहिए:

 const path = require('path') 

Informationगेटिंग फ़ाइल पथ जानकारी

यदि आपके पास फ़ाइल के लिए एक रास्ता है, तो path मॉड्यूल की क्षमताओं का उपयोग करके, आप धारणा और आगे की प्रक्रिया के लिए सुविधाजनक रूप में, इस पथ के बारे में विवरण प्राप्त कर सकते हैं। यह इस तरह दिखता है:

 const notes = '/users/flavio/notes.txt' path.dirname(notes) // /users/flavio path.basename(notes) // notes.txt path.extname(notes) // .txt 

यहां, notes लाइन में, फ़ाइल पथ संग्रहीत है। path मॉड्यूल के निम्नलिखित तरीकों का उपयोग path को पार्स करने के लिए किया गया था:

• dirname() - फ़ाइल की मूल निर्देशिका लौटाता है।
• basename() - फाइल का नाम देता है।
• extname() - फ़ाइल एक्सटेंशन देता है।

आप .basename() विधि को कॉल करके एक्सटेंशन के बिना फ़ाइल नाम का पता लगा सकते हैं और इसे विस्तार का प्रतिनिधित्व करने वाला दूसरा तर्क दे सकते हैं:

 path.basename(notes, path.extname(notes)) //notes 

फ़ाइल पथों के साथ काम करना

पथ के कई हिस्सों को पथ का उपयोग करके जोड़ा जा सकता है। path.join() विधि:

 const name = 'flavio' path.join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

आप पथ का उपयोग करके इसके सापेक्ष पथ के आधार पर फ़ाइल का पूर्ण पथ पा सकते हैं। path.resolve() विधि:

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'       

इस स्थिति में, Node.js बस वर्तमान वर्किंग डायरेक्टरी की /flavio.txt जाने वाले मार्ग पर /flavio.txt को जोड़ता है। यदि, इस पद्धति को कॉल करते समय, आप फ़ोल्डर में पथ का प्रतिनिधित्व करने वाला एक और पैरामीटर पास करते हैं, तो यह विधि निरपेक्ष पथ को निर्धारित करने के लिए एक आधार के रूप में उपयोग करती है:

 path.resolve('tmp', 'flavio.txt') // '/Users/flavio/tmp/flavio.txt'       

यदि पहला पैरामीटर के रूप में पारित मार्ग स्लैश से शुरू होता है, तो इसका मतलब है कि यह एक निरपेक्ष पथ है।

 path.resolve('/etc', 'flavio.txt') // '/etc/flavio.txt' 

यहाँ एक और उपयोगी विधि है - path.normalize() । यह आपको उस पथ का उपयोग करके फ़ाइल का वास्तविक पथ खोजने की अनुमति देता है जिसमें एक डॉट ( . ), दो अंक ( .. ), या दो स्लैश जैसे सापेक्ष पथ क्वालिफायर होते हैं:

 path.normalize('/users/flavio/..//test.txt') // /users/test.txt 

किसी निर्देशिका के अस्तित्व के लिए normalize() resolve() और normalize() तरीके जाँच नहीं करते हैं। वे बस उन्हें दिए गए डेटा के आधार पर रास्ता ढूंढते हैं।

Node.js में फ़ाइलें पढ़ना

Node.js में फ़ाइलों को पढ़ने का सबसे आसान तरीका fs.readFile() विधि का उपयोग करना है, इसे फ़ाइल और कॉलबैक के लिए मार्ग पास करना है, जिसे फ़ाइल डेटा (या त्रुटि ऑब्जेक्ट) के हस्तांतरण के साथ कहा जाएगा:

 fs.readFile('/Users/flavio/test.txt', (err, data) => { if (err) {   console.error(err)   return } console.log(data) }) 

यदि आवश्यक हो, तो आप इस विधि के तुल्यकालिक संस्करण का उपयोग कर सकते हैं - fs.readFileSync() :

 const fs = require('fs') try { const data = fs.readFileSync('/Users/flavio/test.txt') console.log(data) } catch (err) { console.error(err) } 

डिफ़ॉल्ट रूप से, utf8 एन्कोडिंग का उपयोग फ़ाइलों को पढ़ते समय किया जाता है, लेकिन उपयुक्त पैरामीटर को विधि से पास करके एन्कोडिंग को स्वतंत्र रूप से सेट किया जा सकता है।

fs.readFile() और fs.readFileSync() विधियाँ फ़ाइल की संपूर्ण सामग्री को मेमोरी में पढ़ती हैं। इसका मतलब यह है कि इन विधियों का उपयोग करके बड़ी फ़ाइलों के साथ काम करने से आपके एप्लिकेशन की मेमोरी खपत को गंभीरता से प्रभावित किया जाएगा और इसका प्रदर्शन प्रभावित होगा। यदि आपको ऐसी फ़ाइलों के साथ काम करने की आवश्यकता है, तो धाराओं का उपयोग करना सबसे अच्छा है।

Node.js को फाइलें लिखना

Node.js में, fs.writeFile() विधि का उपयोग करके फ़ाइलों को लिखना सबसे आसान है:

 const fs = require('fs') const content = 'Some content!' fs.writeFile('/Users/flavio/test.txt', content, (err) => { if (err) {   console.error(err)   return } //   }) 

एक ही विधि का एक तुल्यकालिक संस्करण भी है - fs.writeFileSync() :

 const fs = require('fs') const content = 'Some content!' try { const data = fs.writeFileSync('/Users/flavio/test.txt', content) //   } catch (err) { console.error(err) } 

ये विधियाँ, डिफ़ॉल्ट रूप से, मौजूदा फ़ाइलों की सामग्री को प्रतिस्थापित करती हैं। आप उचित ध्वज का उपयोग करके उनके मानक व्यवहार को बदल सकते हैं:

 fs.writeFile('/Users/flavio/test.txt', content, { flag: 'a+' }, (err) => {}) 

झंडे का उपयोग यहां किया जा सकता है, जिसे हमने पहले से ही विवरणकर्ताओं पर अनुभाग में सूचीबद्ध किया है। झंडों के बारे में विवरण यहाँ पाया जा सकता है ।

किसी फ़ाइल में डेटा संलग्न करें

fs.appendFile() विधि (और इसके तुल्यकालिक संस्करण, fs.appendFileSync() ) का उपयोग फ़ाइल के अंत में डेटा संलग्न करने के लिए किया जाता है:

 const content = 'Some content!' fs.appendFile('file.log', content, (err) => { if (err) {   console.error(err)   return } //! }) 

धागे का उपयोग करने के बारे में

ऊपर, हमने उन तरीकों का वर्णन किया है जो किसी फ़ाइल में लिखते समय, उस पर हस्तांतरित डेटा की पूरी मात्रा को लिखते हैं, जिसके बाद, यदि उनके तुल्यकालिक संस्करणों का उपयोग किया जाता है, तो वे प्रोग्राम पर नियंत्रण वापस कर देते हैं, और यदि अतुल्यकालिक संस्करणों का उपयोग किया जाता है, तो वे कॉलबैक कहते हैं। यदि यह स्थिति आपके अनुकूल नहीं है, तो धाराओं का उपयोग करना बेहतर होगा।

Node.js में निर्देशिकाओं के साथ कार्य करना

fs मॉड्यूल डेवलपर को कई सुविधाजनक तरीके प्रदान करता है जिसका उपयोग निर्देशिकाओं के साथ काम करने के लिए किया जा सकता है।

फ़ोल्डर के अस्तित्व के लिए जाँच करें

यह जाँचने के लिए कि क्या निर्देशिका मौजूद है और क्या Node.js इसे एक्सेस कर सकता है, अनुमतियों को देखते हुए, आप fs.access() विधि का उपयोग कर सकते हैं।

एक नया फ़ोल्डर बनाएँ

नए फ़ोल्डर बनाने के लिए, आप fs.mkdir() और fs.mkdirSync() प्रकार का उपयोग कर सकते हैं:

 const fs = require('fs') const folderName = '/Users/flavio/test' try { if (!fs.existsSync(dir)){   fs.mkdirSync(dir) } } catch (err) { console.error(err) } 

The फ़ोल्डर की सामग्री का उपयोग करना

किसी फ़ोल्डर की सामग्री को पढ़ने के लिए, आप fs.readdir() और fs.readdirSync() विधियों का उपयोग कर सकते हैं। यह उदाहरण फ़ोल्डर की सामग्री को पढ़ता है - अर्थात, इसमें कौन सी फाइलें और उपनिर्देशिकाएं हैं, इसके बारे में जानकारी और उनके रिश्तेदार पथ लौटाते हैं:

 const fs = require('fs') const path = require('path') const folderPath = '/Users/flavio' fs.readdirSync(folderPath) 

इस तरह से आप फ़ाइल का पूरा रास्ता पा सकते हैं:

 fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName) } 

परिणाम केवल फाइल प्राप्त करने और निर्देशिका के उत्पादन से बाहर करने के लिए फ़िल्टर किए जा सकते हैं:

 const isFile = fileName => { return fs.lstatSync(fileName).isFile() } fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName)).filter(isFile) } 

Folder फ़ोल्डर का नाम बदलें

आप फ़ोल्डर का नाम बदलने के लिए fs.rename() और fs.renameSync() विधियों का उपयोग कर सकते हैं। पहला पैरामीटर वर्तमान फ़ोल्डर पथ है, दूसरा एक नया है:

 const fs = require('fs') fs.rename('/Users/flavio', '/Users/roger', (err) => { if (err) {   console.error(err)   return } // }) 

आप सिंक्रोनस विधि fs.renameSync() का उपयोग करके फ़ोल्डर का नाम बदल सकते हैं:

 const fs = require('fs') try { fs.renameSync('/Users/flavio', '/Users/roger') } catch (err) { console.error(err) } 

▍ फ़ोल्डर हटाएँ

किसी फ़ोल्डर को हटाने के लिए, आप fs.rmdir() या fs.rmdirSync() विधियों का उपयोग कर सकते हैं। यह ध्यान दिया जाना चाहिए कि एक फ़ोल्डर को हटाना जिसमें कुछ है एक खाली फ़ोल्डर को हटाने की तुलना में कुछ अधिक जटिल कार्य है। यदि आपको ऐसे फ़ोल्डर्स को हटाने की आवश्यकता है, तो fs-extra पैकेज का उपयोग करें, जो बहुत लोकप्रिय है और अच्छी तरह से समर्थित है। यह fs मॉड्यूल के लिए एक प्रतिस्थापन है, इसकी क्षमताओं का विस्तार।

fs-extra पैकेज से remove() विधि उन फ़ोल्डरों को हटा सकती है जिनमें पहले से ही कुछ है।

आप इस मॉड्यूल को इस प्रकार स्थापित कर सकते हैं:

 npm install fs-extra 

यहाँ इसके उपयोग का एक उदाहरण है:

 const fs = require('fs-extra') const folder = '/Users/flavio' fs.remove(folder, err => { console.error(err) }) 

इसके तरीकों का उपयोग वादों के रूप में किया जा सकता है:

 fs.remove(folder).then(() => { // }).catch(err => { console.error(err) }) 

Async / प्रतीक्षित निर्माण भी स्वीकार्य है:

 async function removeFolder(folder) { try {   await fs.remove(folder)   // } catch (err) {   console.error(err) } } const folder = '/Users/flavio' removeFolder(folder) 

एफएस मॉड्यूल

ऊपर, हम पहले से ही fs मॉड्यूल के कुछ तरीकों के पार आ गए हैं जो कि फाइल सिस्टम के साथ काम करते समय उपयोग किए जाते हैं। वास्तव में, इसमें कई और उपयोगी चीजें शामिल हैं। याद रखें कि इसे स्थापित करने की आवश्यकता नहीं है, कार्यक्रम में इसका उपयोग करने के लिए, इसे जोड़ने के लिए पर्याप्त है:

 const fs = require('fs') 

उसके बाद, आपको उसकी विधियों तक पहुंच प्राप्त होगी, जिनमें से हम निम्नलिखित पर ध्यान देते हैं, जिनमें से कुछ आप पहले से ही जानते हैं:

• fs.access() : किसी फ़ाइल के अस्तित्व और अनुमतियों के आधार पर इसे एक्सेस करने की क्षमता की जाँच करता है।
• fs.appendFile() : डेटा को एक फ़ाइल में fs.appendFile() । यदि फ़ाइल मौजूद नहीं है, तो इसे बनाया जाएगा।
• fs.chmod() : किसी फ़ाइल के लिए अनुमतियाँ परिवर्तित करता है। इसी तरह के तरीके: fs.lchmod() , fs.fchmod() ।
• fs.chown() : दिए गए फ़ाइल के लिए स्वामी और समूह को बदलता है। इसी तरह के तरीके: fs.fchown() , fs.lchown() ।
• fs.close() : फ़ाइल डिस्क्रिप्टर को बंद कर देता है।
• fs.copyFile() : फ़ाइल को कॉपी करता है।
• fs.createReadStream() : किसी फ़ाइल को पढ़ने के लिए एक स्ट्रीम बनाता है।
• fs.createWriteStream() : एक फाइल राइट स्ट्रीम बनाता है।
• fs.link() : फ़ाइल के लिए एक नया हार्ड लिंक बनाता है।
• fs.mkdir() : एक नई निर्देशिका बनाता है।
• fs.mkdtemp() : एक अस्थायी निर्देशिका बनाता है।
• fs.open() : एक फ़ाइल खोलता है।
• fs.readdir() : डायरेक्टरी की सामग्री को पढ़ता है।
• fs.readFile() : किसी फ़ाइल की सामग्री को पढ़ता है। इसी तरह की विधि: fs.read() ।
• fs.readlink() : एक प्रतीकात्मक लिंक का मूल्य पढ़ता है।
• fs.realpath() : वर्णों का उपयोग करके निर्मित सापेक्ष फ़ाइल पथ को हल करता है . और .. , पूरे रास्ते में।
• fs.rename() : फ़ाइल या फ़ोल्डर का नाम बदल देता है।
• fs.rmdir() : फ़ोल्डर को हटाता है।
• fs.stat() : रिटर्न फाइल जानकारी। इसी तरह के तरीके: fs.fstat() , fs.lstat() ।
• fs.symlink() : फ़ाइल के लिए एक नया प्रतीकात्मक लिंक बनाता है।
• fs.truncate() : निर्दिष्ट लंबाई में फ़ाइल को fs.truncate() । इसी तरह की विधि: fs.ftruncate() ।
• fs.unlink() : एक फ़ाइल या प्रतीकात्मक लिंक को हटाता है।
• fs.unwatchFile() : फ़ाइल परिवर्तनों की निगरानी अक्षम करता है।
• fs.utimes() : किसी फ़ाइल का टाइमस्टैम्प बदल देता है। इसी तरह की विधि: fs.futimes() ।
• fs.watchFile() : फ़ाइल परिवर्तनों की निगरानी करने में सक्षम करता है। इसी तरह की विधि: fs.watch() ।
• fs.writeFile() : फ़ाइल में डेटा लिखते हैं। इसी तरह की विधि: fs.write() ।

fs मॉड्यूल की एक दिलचस्प विशेषता यह है कि इसके सभी तरीके, डिफ़ॉल्ट रूप से, अतुल्यकालिक हैं, लेकिन उनमें से सिंक्रोनस संस्करण भी हैं, जिनके नाम एसिंक्रोनस विधियों के नामों में Sync शब्द जोड़कर प्राप्त किए जाते हैं।

उदाहरण के लिए:

• fs.rename()
• fs.renameSync()
• fs.write()
• fs.writeSync()

सिंक्रोनस विधियों का उपयोग गंभीरता से प्रभावित करता है कि प्रोग्राम कैसे काम करता है।

Node.js 10 इन वादों-आधारित एपीआई के लिए प्रयोगात्मक समर्थन प्रदान करता है।

fs.rename() विधि का अन्वेषण करें। यहां कॉलबैक का उपयोग करते हुए इस पद्धति का एक अतुल्यकालिक संस्करण है:

 const fs = require('fs') fs.rename('before.json', 'after.json', (err) => { if (err) {   return console.error(err) } // }) 

इसके तुल्यकालिक संस्करण का उपयोग करते समय, त्रुटियों को संभालने के लिए ट्राइ try/catch निर्माण का उपयोग किया जाता है:

 const fs = require('fs') try { fs.renameSync('before.json', 'after.json') // } catch (err) { console.error(err) } 

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

पथ मॉड्यूल

पथ मॉड्यूल, जिसके बारे में हमने इसकी कुछ विशेषताओं के बारे में भी बात की है, इसमें कई उपयोगी उपकरण हैं जो आपको फ़ाइल सिस्टम के साथ बातचीत करने की अनुमति देते हैं। जैसा कि पहले ही उल्लेख किया गया है, आपको इसे स्थापित करने की आवश्यकता नहीं है, क्योंकि यह Node.js. का हिस्सा है इसका उपयोग करने के लिए, इसे जोड़ने के लिए पर्याप्त है:

 const path = require('path') 

इस मॉड्यूल का path.sep गुण पथ पथ खंडों (Windows और / और लिनक्स और path.delimiter ) को अलग करने के लिए उपयोग किया गया चरित्र प्रदान करता है, और path.delimiter गुण चरित्र को कई पथों को अलग करने के लिए उपयोग किया जाता है ( ; विंडोज पर और : Linux पर ; और macOS)।

आइए हम path मॉड्यूल के कुछ तरीकों पर विचार और वर्णन करें।

Bpath.basename ()

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

 require('path').basename('/test/something') //something require('path').basename('/test/something.txt') //something.txt require('path').basename('/test/something.txt', '.txt') //something 

▍path.dirname ()

पथ का वह भाग लौटाता है जो निर्देशिका नाम का प्रतिनिधित्व करता है:

 require('path').dirname('/test/something') // /test require('path').dirname('/test/something/file.txt') // /test/something 

▍path.extname ()

पथ का वह भाग लौटाता है जो फ़ाइल एक्सटेंशन का प्रतिनिधित्व करता है:

 require('path').extname('/test/something') // '' require('path').extname('/test/something/file.txt') // '.txt' 

▍path.isAbsolute ()

यदि मार्ग निरपेक्ष है तो सही है:

 require('path').isAbsolute('/test/something') // true require('path').isAbsolute('./test/something') // false 

▍path.join ()

पथ के कई भागों को जोड़ता है:

 const name = 'flavio' require('path').join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

▍path.normalize ()

उस पथ के आधार पर वास्तविक पथ का पता लगाने की कोशिश करना जिसमें ऐसे पात्र शामिल होते हैं जिनका उपयोग सापेक्ष पथ बनाने के लिए किया जाता है . , और // :

 require('path').normalize('/users/flavio/..//test.txt') ///users/test.txt 

▍path.parse ()

एक ऐसी वस्तु को रास्ता देता है जिसके गुण पथ के अलग-अलग हिस्सों का प्रतिनिधित्व करते हैं:

• root : रूट निर्देशिका।
• dir : रूट डायरेक्टरी से शुरू होने वाला फ़ाइल पथ
• base : फ़ाइल का नाम और एक्सटेंशन।
• name : फ़ाइल का नाम।
• ext : फ़ाइल एक्सटेंशन।

इस विधि का उपयोग करके एक उदाहरण दिया गया है:

 require('path').parse('/users/test.txt') 

उनके काम के परिणामस्वरूप, निम्नलिखित वस्तु प्राप्त की जाती है:

 { root: '/', dir: '/users', base: 'test.txt', ext: '.txt', name: 'test' } 

▍path.relative ()

तर्क के रूप में लेता है, 2 तरीके। वर्तमान कार्य निर्देशिका के आधार पर पहले पथ से दूसरे पथ पर सापेक्ष पथ लौटाता है:

 require('path').relative('/Users/flavio', '/Users/flavio/test.txt') //'test.txt' require('path').relative('/Users/flavio', '/Users/flavio/something/test.txt') //'something/test.txt' 

▍path.resolve ()

इसमें दिए गए सापेक्ष पथ के आधार पर निरपेक्ष पथ ढूँढता है:

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'      . 

परिणाम

आज हमने Node.js fs और path मॉड्यूल को देखा, जिनका उपयोग फ़ाइल सिस्टम के साथ काम करने के लिए किया जाता है। इस श्रृंखला के अगले भाग में, जिस पर यह समाप्त होता है, हम os , events , http मॉड्यूल पर चर्चा करेंगे, धाराओं के साथ काम करने के बारे में बात करेंगे और Node.js. में डेटाबेस प्रबंधन प्रणालियों के साथ।

प्रिय पाठकों! Node.js में फ़ाइल सिस्टम के साथ काम करते समय आप किस npm संकुल का उपयोग करते हैं?