एक प्रोग्रामिंग लैंग्वेज के रूप में, गो में इनबिल्ट सुविधाओं की एक विस्तृत श्रृंखला है, जिसमें टेक्स्ट (.txt) फ़ाइलों जैसी फ़ाइलों को बनाने, पढ़ने और लिखने की क्षमता शामिल है।

फाइलें आधुनिक दुनिया में हमारे दैनिक जीवन के महत्वपूर्ण घटक हैं। पाठ फ़ाइलें बाहरी सॉफ़्टवेयर या डेटाबेस के उपयोग के बिना संरचित मानव-पठनीय डेटा को संग्रहीत करने के लिए उपयोगी होती हैं।

यदि आप सोच रहे हैं कि आप गो में पाठ फ़ाइलों में हेरफेर कैसे शुरू कर सकते हैं, तो यह लेख आपके लिए सही जगह है।

गो में बुफियो पैकेज

bufio पैकेज, जो गो के मानक पुस्तकालय का एक हिस्सा है, का उपयोग बफर्ड इनपुट और आउटपुट ऑपरेशंस के लिए किया जाता है, इसलिए यह नाम है। bufio पैकेज पर बनाता है कब। पाठक और कब। लेखक इंटरफेस, जो बड़े पैमाने पर गो के अधिकांश मानक पैकेजों के कार्यान्वयन में उपयोग किए जाते हैं।

bufio पैकेज बफ़रिंग को लागू करके एक कदम आगे जाता है, जिससे यह पाठ्य डेटा से जुड़े IO संचालन के लिए उपयोगी हो जाता है।

उपयोग करने के लिए bufio अपने प्रोग्राम में पैकेज, आपको इसे अन्य पैकेजों के साथ आयात करना चाहिए।

आयात (
"fmt"
"bufio"
)

आपने शायद सुना होगा जब आपने

instagram viewer
गो के साथ शुरुआत की कि यह एक प्रोग्रामर के रूप में आपकी जरूरत की हर चीज के साथ आता है। आपके ऑपरेटिंग सिस्टम के साथ सीधे संचार के लिए, एक पैकेज होता है जिसे कहा जाता है ओएस जो प्लेटफ़ॉर्म-स्वतंत्र कार्य प्रदान करता है।

ओएस और bufio संकुल टेक्स्ट फ़ाइल हेरफेर को अविश्वसनीय रूप से सरल बनाते हैं।

हालांकि के विशाल बहुमत ओएस पैकेज के कार्य यूनिक्स की तरह हैं, वे सभी त्रुटि प्रबंधन की गो शैली को नियोजित करते हैं, जो त्रुटि संदेशों और डिबग कोड को पढ़ना आसान बनाता है।

तो, आप गो में टेक्स्ट वाली फाइलों में हेरफेर कैसे करते हैं?

टेक्स्ट फ़ाइल से डेटा कैसे पढ़ें

पाठ फ़ाइलों से डेटा पढ़ने के लिए, आपको कॉल करने की आवश्यकता है ओएस पैकेज खुला() फ़ंक्शन, जो फ़ाइल के नाम को पैरामीटर के रूप में पढ़ने के लिए स्वीकार करता है। फ़ाइल प्राप्त करने की एक अन्य विधि का उपयोग करना है खुली फाइल() समारोह।

के बीच प्रमुख अंतर है खुला() और खुली फाइल() उनके क्रियान्वयन में है। खुला() फ़ाइल को केवल-पढ़ने के लिए मोड में खोलता है ( O_RDONLY झंडा), जबकि खुली फाइल() तीन मापदंडों को स्वीकार करके अधिक लचीलापन देता है:

  • फ़ाइल का नाम
  • फाइल ओपन मोड: मान्य फाइल ओपन मोड नीचे दी गई तालिका में दिखाए गए हैं।
    झंडा अर्थ
    O_RDONLY फ़ाइल को केवल-पढ़ने के लिए मोड में खोलता है
    ओ_गलत फ़ाइल को केवल-लेखन मोड में खोलता है
    O_RDWR फ़ाइल को रीड-राइट मोड में खोलता है
    O_APPEND लिखते समय फ़ाइल में डेटा जोड़ता है
    O_CREATE यदि कोई मौजूद नहीं है तो एक नई फ़ाइल बनाता है
    O_EXCL O_CREATE के साथ प्रयोग किया जाता है, यह इंगित करने के लिए कि फ़ाइल केवल तभी बनाई जानी चाहिए जब वह मौजूद न हो
    O_SYNC सिंक्रोनस I/O के लिए फ़ाइल खोलता है
    O_TRUNC यदि संभव हो तो फ़ाइल को खुले में छोटा करें
  • फ़ाइल अनुमतियाँ: के समान लिनक्स में फ़ाइल अनुमति बिट्स फ़ाइल एक्सेस नियमों को निर्दिष्ट करने के लिए उपयोग किया जाता है, उदाहरण के लिए, 0777 सभी उपयोगकर्ता प्रकारों को पढ़ने, लिखने और निष्पादित करने की अनुमति देने के लिए।

नीचे दिया गया कोड दिखाता है कि गो का उपयोग करके टेक्स्ट फ़ाइल से डेटा कैसे पढ़ा जाए ओएस। खुला(), और स्कैन () जो इस मामले में, एक में चलता है लूप के लिए जाओ.

पैकेट मुख्य
आयात (
"bufio"
"fmt"
"लकड़ी का लट्ठा"
"ओएस"
)
/**
 की सामग्री "testfile.txt" फ़ाइल।
 लोरेन इपसाम डलार सिट आमेट
 लोरेन इपसाम डलार सिट आमेट
 लोरेन इपसाम डलार सिट आमेट
 लोरेन इपसाम डलार सिट आमेट
 लोरेन इपसाम डलार सिट आमेट
 लोरेन इपसाम डलार सिट आमेट
*/
समारोह मुख्य(){
 फ़ाइल, त्रुटि: = os. खुला("testfile.txt")
// एक अन्य विधि का उपयोग कर os. खुली फाइल()
 // फ़ाइल, त्रुटि = os. खुली फाइल("testfile.txt", ओएस। O_RDONLY, 0644)
 अगर गलती! = शून्य {
लकड़ी का लट्ठा।घातक(ग़लती होना)
 }
आस्थगित करेंफ़ाइल।बंद करना()
 fmt. प्रिंटलन("फ़ाइल सफलतापूर्वक खोली गई। अब फ़ाइल सामग्री को लाइन से लाइन पढ़ना:")
 // बनाएं चित्रान्वीक्षक से फ़ाइलकोपढ़नामूलपाठसे
 स्कैनर := बुफियो. न्यू स्कैनर (फ़ाइल)
// टेक्स्ट लाइन के बाइट्स को लाइन से स्कैन या पढ़ें
के लिएचित्रान्वीक्षकस्कैन() {
fmt.प्रिंट(चित्रान्वीक्षक।मूलपाठ())
 }
 अगर त्रुटि: = स्कैनर. एरर (); त्रुटि! = शून्य {
लकड़ी का लट्ठा।घातक(ग़लती होना)
 }
}

जब आप ऊपर दिए गए कोड को साथ चलाते हैं जाओ चलाओ filename.go, यह नीचे दिखाए गए आउटपुट का उत्पादन करता है:

यदि आप केवल फ़ाइल नाम में पास करते हैं, न कि पथ के लिए खुला() या खुली फाइल() रीड ऑपरेशंस के लिए फ़ंक्शन, गो मानता है कि फ़ाइल वर्तमान निर्देशिका में है और अगर यह नहीं मिलती है तो एक त्रुटि लौटाती है। यदि आपको वर्तमान निर्देशिका के बाहर फ़ाइलों के साथ काम करने की आवश्यकता है, तो आपको फ़ाइल के पथ में पास होना चाहिए।

टेक्स्ट फ़ाइल में डेटा कैसे लिखें

bufio पैकेज एक बफर प्रदान करता है लेखक इंटरफ़ेस जो डेटा के बाइट्स को स्टोर करता है और उन्हें किसकी मदद से फाइल में लिखता है फ्लश () समारोह।

अगला नमूना कोड एक फ़ाइल को पढ़ने के लिए एक निरंतरता है। इस उदाहरण में, डेटा मौजूदा को लिखा जाता है testfile.txt का उपयोग ओ_गलत और O_APPEND झंडे।

ऊपर दिए गए प्रोग्राम में कोड की निम्नलिखित पंक्तियाँ जोड़ें, कर्ली ब्रेस को बंद करने से पहले मुख्य() समारोह:

// फाइल करने के लिए आउटपुट डेटा लिखें
फ़ाइल, त्रुटि = os. ओपनफाइल ("testfile.txt", os. O_APPEND|os. O_WRONLY, 0644)
अगर गलती! = शून्य {
 लकड़ी का लट्ठा। घातक (गलत)
}
आस्थगित करें फ़ाइल। बंद करना()
fmt. Println ("फ़ाइल सफलतापूर्वक खोली गई, अब फ़ाइल में डेटा लिखने की तैयारी कर रहा है ...")
// फ़ाइल में डेटा लिखने के लिए बफर्ड राइटर ऑब्जेक्ट बनाएं
टेक्स्ट राइटर: = बुफियो. न्यूराइटर (फ़ाइल)
// फ़ाइल को सहेजने से पहले बफर को स्ट्रिंग लिखें।
_, त्रुटि = टेक्स्टवाइटर। राइटस्ट्रिंग ("- यह एक है नया फ़ाइल में पाठ जोड़ा गया।")
अगर गलती! = शून्य {
 लकड़ी का लट्ठा। घातक (गलत)
}
textWriter. फ्लश ()
fmt. Println ("डेटा सफलतापूर्वक फ़ाइल में लिखा गया ...")

आपके पूरे प्रोग्राम का आउटपुट इस तरह दिखना चाहिए:

जब आप खोलते हैं testfile.txt फ़ाइल, आप नीचे दी गई छवि की तरह फ़ाइल के अंत में संलग्न नई पंक्ति भी देखेंगे:

गो में फाइल हैंडलिंग आसान है

गो आपको विभिन्न प्रकार की फ़ाइलों के साथ काम करने की अनुमति देता है, न कि केवल पाठ फ़ाइलों के साथ। JSON और CSV सहित फ़ाइलों से विभिन्न प्रकार के डेटा के साथ काम करने के लिए कई अतिरिक्त इनबिल्ट लाइब्रेरी और फ़ंक्शन हैं।

यह देखने के लिए कि स्थिति के आधार पर वे अलग-अलग तरीके से कैसे व्यवहार करते हैं, आप विभिन्न फ़्लैग और फ़ाइल अनुमतियों के साथ प्रयोग कर सकते हैं जो उपयोग के लिए उपलब्ध हैं खुली फाइल().