गो में अभिलेखागार के साथ काम करना

अभिलेखागार कई फाइलों को एक साथ एक ही प्रारूप में बंडल करता है, आमतौर पर ज़िप, टार या रार। संग्रह फ़ाइलें कुल फ़ाइल आकार को कम करने के लिए संपीड़न का भी उपयोग कर सकती हैं।

आप वेब पृष्ठों सहित सॉफ़्टवेयर और डेटा वितरित करने के लिए संग्रह का उपयोग कर सकते हैं। उपयोगकर्ताओं को डाउनलोड और इंस्टॉल करने के लिए आप अपने एप्लिकेशन को उसकी सभी फाइलों और निर्भरताओं के साथ संग्रहित भी कर सकते हैं।

गो का आर्काइव पैकेज आपको टार और जिप फॉर्मेट में आर्काइव बनाने और निकालने देता है।

गो का आर्काइव पैकेज

गो प्रदान करता है पुरालेख विभिन्न संग्रह प्रारूपों के साथ काम करने के लिए पैकेज। आप उपयोग कर सकते हैं ज़िप और टार संकुल उन स्वरूपों में संग्रह फ़ाइलों को बनाने, पढ़ने और लिखने के लिए। दोनों संकुल उपयोग में आसान एपीआई पर विभिन्न संपीड़न एल्गोरिदम का समर्थन करते हैं।

यहां बताया गया है कि आप अपनी गो फाइलों में जिप और टार पैकेज कैसे आयात कर सकते हैं:

आयात (
"संग्रह/ज़िप"
"संग्रह/टार"
)

संकुल आयात करने के बाद, आप संग्रह फ़ाइलों को बनाने और हेरफेर करने के लिए उनका उपयोग कर सकते हैं।

टार अभिलेखागार में फ़ाइलें बनाना और जोड़ना

टार पैकेज टार के साथ काम करता है tar और tar.gz स्वरूपों के संग्रह, PAX विस्तारित हेडर वाली फ़ाइलों को पढ़ने और लिखने के लिए समर्थन सहित।

टार पैकेज एक प्रदान करता है न्यूराइटर नए टार संग्रह बनाने के लिए कार्य करता है। न्यूराइटर लेता है कब। लेखक इंटरफ़ेस उदाहरण जो फ़ाइल या मेमोरी बफर हो सकता है और एक पॉइंटर देता है टार। लेखक संरचना।

पैकेट मुख्य
आयात (
"संग्रह/टार"
"ओएस"
)
समारोहमुख्य() {
// एक नई फाइल बनाएं
 फ़ाइल, _ := os. बनाएं("myarchive.tar")
आस्थगित करें फ़ाइल। बंद करना()
// एक नया टार आर्काइव बनाएं
 टारराइटर := टार. न्यूराइटर (फ़ाइल)
आस्थगित करें tarWriter. बंद करना()
}

बनाएं का कार्य ओएस पैकेज एक नई टार फ़ाइल बनाता है। टार। न्यूराइटर फ़ंक्शन एक फ़ाइल लेता है और एक नया संग्रह बनाता है।

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

आयात (
"संग्रह/टार"
"एफएमटी"
"आईओ"
"लकड़ी का लट्ठा"
"ओएस"
)
समारोहमुख्य() {
// एक नई फाइल बनाएं
 फ़ाइल, _ := os. बनाएं("myarchive.tar")
 फ़ाइल, _ = os. बनाएं("संदेश.txt")
आस्थगित करें फ़ाइल। बंद करना()
// एक नया टार आर्काइव बनाएं
 टारराइटर := टार. न्यूराइटर (फ़ाइल)
आस्थगित करें tarWriter. बंद करना()
// संग्रह में एक फ़ाइल जोड़ें
 फ़ाइल जोड़ने के लिए, _ := os. खुला("फ़ाइल1.txt")
आस्थगित करें फ़ाइल जोड़ने के लिए। बंद करना()
 फ़ाइलइन्फो, _: = फ़ाइल जोड़ने के लिए। स्टेट ()
 हेडर, _ := tar. फ़ाइलइन्फो हैडर (फ़ाइलइन्फो, "")
 tarWriter. राइट हैडर (हेडर)
 _, _ = आईओ। कॉपी (tarWriter, fileToAdd)
 fmt. प्रिंटलन("टीएआर संग्रह कार्रवाई पूर्ण")
}

कार्यक्रम के साथ नई टार और पाठ फ़ाइलें बनाता है बनाएं का कार्य ओएस पैकेज और न्यूराइटर, फ़ाइल को आर्काइव में जोड़ने से पहले।

खुला फ़ंक्शन फ़ाइल को संग्रह में जोड़ने के लिए खोलता है। ध्यान दें कि आपको नाम की फ़ाइल की आवश्यकता होगी फ़ाइल1.txt इस कार्यक्रम को सफलतापूर्वक चलाने के लिए अपनी कार्यशील निर्देशिका में।

आप उपयोग कर सकते हैं स्टेट टार हेडर के लिए आपको जिस मेटाडेटा की आवश्यकता होगी, उसे लाने के लिए फ़ाइल उदाहरण का कार्य। इसके परिणाम को पास करें FileInfoHeader, फिर उस परिणाम को पास करें राइटहेडर टैर फ़ाइल सेट अप करने के लिए कार्य करें। अंत में, फ़ाइल का उपयोग करके संग्रह में कॉपी करें कब। प्रतिलिपि.

टार अभिलेखागार से फ़ाइलें निकालना

आप उपयोग कर सकते हैं न्यूरीडर टैर आर्काइव फ़ाइल की सामग्री को पढ़ने के लिए कार्य करता है। NewReader फ़ंक्शन एक लेता है कब। पाठक इंटरफ़ेस जो फ़ाइल या मेमोरी बफर हो सकता है। यह एक सूचक को a पर लौटाता है टार। पाठक संरचना।

आयात (
"संग्रह/टार"
"आईओ"
"ओएस"
)
समारोहमुख्य() {
// टार आर्काइव खोलें
 फ़ाइल, _ := os. खुला("myarchive.tar")
आस्थगित करें फ़ाइल। बंद करना()
// एक नया टार रीडर बनाएं
 टैररीडर: = टैर. न्यूरीडर (फ़ाइल)
// संग्रह में फ़ाइलों पर पुनरावृति करें
के लिए {
 हेडर, इरेट: = tarReader. अगला()
अगर त्रुटि == आईओ। ईओएफ {
तोड़ना
 }
// फ़ाइल निकालें
 आउटफाइल, _ := os. बनाएं (शीर्षक। नाम)
आस्थगित करें आउटफाइल। बंद करना()
 _, _ = आईओ। कॉपी (आउटफाइल, टैररीडर)
 }
}

पाश के लिए अनंत टार रीडर इंस्टेंस को ट्रैवर्स करता है और प्रत्येक फाइल को कॉपी करके फाइलों को निकालता है आईओ पैकेज प्रतिलिपि समारोह।

ज़िप संग्रह में फ़ाइलें बनाना और जोड़ना

आप इसके साथ एक नया ज़िप संग्रह बना सकते हैं न्यूराइटर का कार्य ज़िप पैकेट। न्यूवाइटर फ़ंक्शन एक फ़ाइल उदाहरण लेता है और एक ज़िप लेखक देता है।

आयात (
"संग्रह/ज़िप"
"ओएस"
)
समारोहमुख्य() {
// एक नई फाइल बनाएं
 फ़ाइल, त्रुटि: = os. बनाएं("आर्काइव.ज़िप")
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
आस्थगित करें फ़ाइल। बंद करना()
// एक नया ज़िप लेखक बनाएँ
 जिपराइटर := जिप. न्यूराइटर (फ़ाइल)
आस्थगित करें zipWriter. बंद करना()
}

zipWriter चर एक नया स्टोर करता है लेखक उदाहरण है कि न्यूवाइटर लौटाता है।

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

आयात (
"संग्रह/ज़िप"
"ओएस"
)
समारोहमुख्य() {
// नई फाइलें बनाएं
 फ़ाइल, त्रुटि: = os. बनाएं("आर्काइव.ज़िप")
 फ़ाइल, त्रुटि = os. बनाएं("फ़ाइल1.txt")
 फ़ाइल, त्रुटि = os. बनाएं("फ़ाइल2.txt")
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
आस्थगित करें फ़ाइल। बंद करना()
// एक नया ज़िप लेखक बनाएँ
 जिपराइटर := जिप. न्यूराइटर (फ़ाइल)
आस्थगित करें zipWriter. बंद करना()
// संग्रह में फ़ाइलें जोड़ें
 फ़ाइल 1, त्रुटि: = zipWriter. बनाएं("फ़ाइल1.txt")
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
 फ़ाइल 2, त्रुटि: = zipWriter. बनाएं("फ़ाइल2.txt")
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
// संग्रह में फ़ाइलों को डेटा लिखें
 फ़ाइल 1. लिखें ([]बाइट("हैलो वर्ल्ड!"))
 file2.लिखें([]बाइट("अलविदा दुनिया!"))
 fmt. प्रिंटलन("ज़िप संग्रहण कार्य पूरा हुआ")
}

मुख्य कार्य का उपयोग करके शुरू होता है बनाएं एक नई ज़िप फ़ाइल और दो पाठ फ़ाइलें बनाने के लिए। यह तब संग्रह में दो पाठ फ़ाइलों को जोड़ने के लिए दो लेखक बनाता है। लिखना प्रत्येक फ़ाइल उदाहरण का कार्य संग्रह में प्रत्येक फ़ाइल को संदेश लिखता है।

ज़िप संग्रह से फ़ाइलें निकालना

आप किसी मौजूदा ज़िप फ़ाइल को इसके साथ पढ़कर निकाल सकते हैं ओपनरीडर फ़ंक्शन, फिर इसकी सामग्री के माध्यम से लूपिंग और फ़ाइलों की प्रतिलिपि बनाना आईओ पैकेट।

आयात (
"संग्रह/ज़िप"
"एफएमटी"
"आईओ"
"ओएस"
)
समारोहमुख्य() {
// संग्रह खोलें
 जिपरीडर, इरेट: = जिप। ओपनरीडर("आर्काइव.ज़िप")
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
आस्थगित करें zipReader. बंद करना()
// संग्रह से फ़ाइलें निकालें
के लिए _, फ़ाइल: = श्रेणी zipReader. फ़ाइल {
 zippedFile, त्रुटि: = file. खुला()
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
आस्थगित करें zippedFile. बंद करना()
// ज़िप की गई फ़ाइल के समान नाम वाली एक नई फ़ाइल बनाएँ
 एक्सट्रेक्टेडफाइल, इरेट: = os. बनाएं (फ़ाइल। नाम)
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
आस्थगित करें एक्सट्रेक्टेडफाइल. बंद करना()
// ज़िप की गई फ़ाइल से डेटा को नई फ़ाइल में कॉपी करें
 _, त्रुटि = io. प्रतिलिपि (निकाले गए फ़ाइल, ज़िपित फ़ाइल)
अगर गलती! = शून्य {
घबड़ाहट(गलत)
 }
 fmt. प्रिंटफ("निकाला गया %s\n", फ़ाइल। नाम)
 }
}

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

मैन्युअल रूप से या प्रोग्रामेटिक रूप से अनज़िप करें—यह आपके ऊपर है

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

अन्य मामलों में, आप मौजूदा एप्लिकेशन का उपयोग करने से बेहतर हो सकते हैं। आप Windows, macOS, और Linux पर संग्रहों को अनज़िप करने के लिए बिल्ट-इन या तृतीय-पक्ष ऐप्स का उपयोग कर सकते हैं।