पैकेज और मॉड्यूल प्रबंधन का पूरा गाइड

1. गो मॉड्यूल और पैकेज प्रबंधन की बुनियादी जानकारी

गो मॉड्यूल गो भाषा के आधिकारिक पैकेज प्रबंधन और डिपेंडेंसी संस्करण नियंत्रण सिस्टम है, जो गो 1.11 से पेश किया गया था और जो गो 1.13 के पहले से डिफ़ॉल्ट डिपेंडेंसी प्रबंधन तंत्र बन गया है। गो मॉड्यूल प्रत्येक परियोजना को एक मोड्यूल के रूप में देखता है, जिसमें परियोजना में गो कोड और उसकी तमाम पैकेज शामिल होती है।

कार्य का सिद्धांत

गो मॉड्यूल परियोजना की डिपेंडेंसियों को go.mod फ़ाइल के माध्यम से नियंत्रित करता है। यह फ़ाइल परियोजना की मूल निर्भरताओं और उनके संस्करणों को सूचीबद्ध करती है। एक मोड्यूल में कई पैकेज हो सकते हैं, हालांकि सामान्यत: एक रिपॉज़िटरी एक मोड्यूल होता है।

पूरा करने या अन्य कमांडों का निष्पादन करने के समय, यदि मौजूदा निर्देशिका में go.mod फ़ाइल मौजूद नहीं है, तो गो टूलचेन वर्तमान कार्य के लिए मस्तूल दिशा और उसके माता निर्देशिकाओं में go.mod की खोज करेगा। यदि मिल जाता है, तो वह उस फ़ाइल में डिपेंडेंसी सूचना का उपयोग करके पैकेजों को प्राप्त करेगा और बनाएगा; अन्यथा, वह GOPATH मोड के तहत डिपेंडेंसी प्रबंधन विधि का उपयोग करेगा।

गो भाषा में भूमिका

• संस्करण नियंत्रण: गो मॉड्यूल डेवलपर को तृतीय-पक्ष पुस्तकालयों के विशिष्ट संस्करण का उपयोग स्पष्ट रूप से वर्तमानीकरण सुनिश्चित करने की अनुमति देता है।
• पैकेज प्रबंधन: परियोजना की डिपेंडेंसियों और उनके संस्करणों को सरलता से प्रबंधित करना।
• मोड्यूल तटबंधन: अलग-अलग परियोजनाएँ, प्रत्येक परियोजना का अपनी डिपेंडेंसी प्रबंधन के लिए खुद की go.mod फ़ाइल होने के कारण, एक ही पैकेज के विभिन्न संस्करणों पर आधारित हो सकती हैं।

पैकेज और मॉड्यूल प्रबंधन किसी भी आधुनिक प्रोग्रामिंग भाषा के लिए महत्वपूर्ण पहलू है, क्योंकि यह आवश्यकता परियोजना प्रमाण उपयोगकर्ताओं के लिए डिपेंडेंसी प्रबंधन, पैकेज संस्करण अपग्रेड, और पुनर्निर्माण कार्यों को सुविधाजनक बनाता है। गो भाषा में, जैसे ही परियोजनाएँ और डिपेंडेंसियों का पैमाना बढ़ता है, गो मॉड्यूल्स डिपेंडेंसी प्रबंधन की चुनौतियों का सामर्थ्यपूर्ण समाधान प्रदान करते हैं।

2. अपने खुद के गो मॉड्यूल का सक्षम करना

नए गो मॉड्यूल का आरंभ करना बहुत सरल है। आप अपने परियोजना के रूट निर्देशिका में निम्नलिखित कमांड को निष्पादित कर सकते हैं:

go mod init <module-name>

यहाँ, <module-name> सामान्यत: कोड रिपॉज़िटरी का पता होता है, जैसे github.com/username/repo।

go.mod फ़ाइल का उद्देश्य

जब go mod init कमांड सफलतापूर्वक निष्पादित होती है, तो वर्तमान निर्देशिका में एक go.mod फ़ाइल बनाई जाएगी। इस फ़ाइल में निम्नलिखित परिभाषित होता है:

• वर्तमान मोड्यूल का नाम।
• गो संस्करण।
• हर पैमाना के लिए आवश्यक जानकारी, जिसमें प्रत्येक पैकेज के लिए उपयुक्त संस्करण शामिल है।

go.mod फ़ाइल गो मॉड्यूल संदर्भ में सबसे महत्वपूर्ण घटक है, और यह स्वचालित रूप से अपडेट की जाएगी जैसे ही डिपेंडेंसियों को जोड़ा या हटाया जाता है।

3. गो पैकेज बनाना और ढाचे बनाना

3.1 पैकेज बनाने की मूल बातें

गो भाषा में, एक पैकेज में कई गो स्रोत फ़ाइलों का संग्रह होता है, सामान्यत: एक ही निर्देशिका में स्थित, और यह एक विशिष्ट सेट की कार्यात्मकताएँ शामिल करता है। प्रत्येक गो फ़ाइल package कीवर्ड का उपयोग करके दर्शाता है कि वह किस पैकेज का हिस्सा है।

नए पैकेज बनाने के लिए, आपको निम्नलिखित करना होगा:

1. पैकेज की निर्देशिका को प्रस्तुत करने के लिए एक फ़ोल्डर बनाएं।
2. फ़ोल्डर में .go फ़ाइलें बनाएं और फ़ाइल की पहली पंक्ति पर package <package-name> निर्धारित करें।

पैकेज का नाम सामान्यत: निर्देशिका के नाम से संबंधित होता है लेकिन यह संरचित रूप से संगत न होने का अनिवार्य नहीं है। पैकेज का नाम छोटा, स्पष्ट और अधिप्राण रहना चाहिए और यदि संभव हो, अंडरस्कोर का उपयोग बचाया जाए।

3.2 पैकेज संरचना

आपके गो पैकेजों को एक तर्कसंगत तरीके से संरचित करना, कोड की पढ़ाई, रखरखाव, और पुनःउपयोग सुनिश्चित करने के लिए महत्वपूर्ण होता है।

• निर्देशिका संरचना: कार्यात्मकता के आधार पर निर्देशिकाओं को विभाजित करें, जहाँ प्रत्येक निर्देशिका एक पैकेज को प्रस्तुत करता है।
• नामजरी: निर्देशिकाएँ जैसे _test आमतौर पर परीक्षण फ़ाइलों को संदर्भित करती हैं, cmd निर्देशिका का सामान्यत: कमांड-रेखा अनुप्रयोगों के लिए उपयोग किया जाता है, और internal निर्देशिका बाह्य उपयोग के लिए नहीं होता है गोपनीय कोड शामिल करता है।

/root-directory
    /pkg
        /subpackage1
            subpackage1.go
        /subpackage2
            subpackage2.go
    /cmd
        main.go  // कमांड-रेखा अनुप्रयोगों के लिए cmd निर्देशिका
    /internal
        helper.go

इस संरचित पहुंच से स्पष्ट रूप से तत्वों का संरचना का प्रस्ताव है और कोड के संरचन को संभालना, परीक्षण और संकलन करना औरात बनाता है। इस प्रकार के अच्छे संरचित पैकेज आसानी से दूसरे परियोजनाओं द्वारा आयात और उपयोग किए जा सकते हैं।

पूर्व उल्लिखित संरचनात्मक और नामकरण के नियमों का पालन निर्माणकर्ताओ

4.1 आंतरिक पैकेजों को आयात करना

मान लीजिए आपकी परियोजना संरचना निम्नलिखित रूप में है:

├── src
│   ├── main.go
│   └── mypackage
│       └── mymodule.go

इस उदाहरण में, mypackage एक आंतरिक पैकेज है जिसे आपने बनाया है, जिसमें mymodule.go नामक एक फ़ाइल है। पहले यह सुनिश्चित करें कि mymodule.go फ़ाइल सही पैकेज नाम घोषित करती है:

// mymodule.go
package mypackage

// SomeFunction mypackage में एक सार्वजनिक फ़ंक्शन है
func SomeFunction() {
    // फ़ंक्शन का अंमलन
}

अब, अगर हम main.go फ़ाइल में mypackage पैकेज से SomeFunction का उपयोग करना चाहते हैं, तो हमें इसे आयात करना होगा:

// main.go
package main

import (
    "fmt"
    "project/src/mypackage"
)

func main() {
    mypackage.SomeFunction()
    fmt.Println("फ़ंक्शन को बुलाया गया है")
}

उपरोक्त आयात वक्तव्य main.go फ़ाइल में mypackage पैकेज को आयात करता है, जिससे हम उस पैकेज से फ़ंक्शन को mypackage.SomeFunction का उपयोग करने की संभावना होती है।

4.2 बाह्य पैकेजों का उपयोग करना

जब ज़्यादा जटिल कार्यान्वयन की आवश्यकता होती है, तो हम अक्सर बाह्य पैकेजों पर आश्रित होते हैं। बाह्य पैकेजें दूसरे डेवलपर्स द्वारा लिखी और सार्वजनिक रूप से उपलब्ध होती हैं, जिन्हें हम अपने परियोजनाओं में आसानी से एकीकृत कर सकते हैं। बाह्य पैकेजें खोजने के लिए आप godoc.org जैसी वेबसाइटों पर जा सकते हैं या GitHub पर खोज सकते हैं।

मान लीजिए आप अपने परियोजना में gorilla/mux का उपयोग करना चाहते हैं, जो की एक लोकप्रिय HTTP अनुरोध राउटर लाइब्रेरी है। आप इसे आयात और उपयोग कर सकते हैं निम्नलिखित रूप में:

पहले, go get कमांड का उपयोग करके पैकेज को इंस्टॉल करें:

go get -u github.com/gorilla/mux

फिर, अपने कोड में gorilla/mux को आयात और उपयोग करें:

package main

import (
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter() // एक राउटर इंस्टेंस बनाएं
    // रूट नियम जोड़ें
    r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request){
        w.Write([]byte("gorilla/mux में आपका स्वागत है!"))
    })
    
    // HTTP सर्वर चालू करें
    http.ListenAndServe(":8000", r)
}

ऊपर के कोड में, हम gorilla/mux को आयात करते हैं ताकि हम एक HTTP राउटर बना सकें, मूल मार्ग के लिए एक हैंडलर फ़ंक्शन परिभाषित करें, और अंत में http.ListenAndServe का उपयोग करके 8000 पोर्ट पर सर्वर को शुरू करें।

5. मॉड्यूल विभागों का प्रबंधन

एक बड़े पैमाने पर परियोजना में मॉड्यूल विभागों का प्रबंधन विशेष रूप से महत्वपूर्ण हो जाता है। यह सुनिश्चित करने में मदद करता है कि प्रत्येक निर्माण या परियोजना प्रतिरूप को सत्यापित रूप से समान संस्करण के आधार पर विभाजनों का उपयोग संदर्भित कर सकता है।

5.1 go get का उपयोग करके विभागों को अपडेट करना

go get कमांड न केवल नए पैकेज विभागों को जोड़ सकता है, बल्कि मौजूदा वाले को अपडेट भी कर सकता है। नीचे go get के लिए कुछ सामान्य विकल्प हैं:

• एकल पैकेज को अपडेट करें:

  go get -u github.com/some/package

• इस पैकेज के सभी विभागों को अपडेट करें:

  go get -u github.com/some/package/...

• परियोजना में सभी विभागों को अपडेट करें:

  go get -u ./...

• डाउनलोड करें परन्तु इंस्टॉल न करें:

  go get -d github.com/some/package

अपड

5.2 संस्करण नियंत्रण और go.mod

गो के वर्शन 1.11 से, गो ने Go Modules नामक नए डिपेंडेंसी प्रबंधन प्रणाली प्रदान की है। परियोजना के मूल निर्देशिका में, go.mod फ़ाइल पैकेजों की डिपेंडेंसियों को दर्ज करती है।

go.mod फ़ाइल में निम्नलिखित अनुभाग शामिल होते हैं:

• मॉड्यूल वर्तमान परियोजना के लिए मॉड्यूल पथ की घोषणा करता है।
• रिक्वायर व्यावसायिक संस्करण के साथ डिपेंडेंसियों की घोषणा करता है।
• रिप्लेसमेंट विशेष संस्करणों के लिए प्रतिस्थापन मॉड्यूल पथ का और संस्करण का निर्देश कर सकता है।
• छोड़ता है स्पष्ट संस्करणों को निकालने के लिए प्रयोग किया जाता है।

एक go.mod फ़ाइल का उदाहरण इस तरह हो सकता है:

मॉड्यूल github.com/my/awesome-project

go 1.14

रिक्वायर (
    github.com/gorilla/mux v1.7.4
    golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975
)

रिप्लेस (
    github.com/old/dependency => github.com/new/dependency v1.2.3
)

छोड़ता है (
    github.com/old/dependency v1.1.4
)

परियोजना में go build या go test जैसे कमांड चलाते समय, गो स्वचालित रूप से go.mod फ़ाइल को उत्पन्न या अपडेट करता है ताकि परियोजना के लिए सभी आवश्यक डिपेंडेंसियों का निर्धारण कर सके। संस्करण नियंत्रण में सर्वोत्तम अभ्यास है कि go.mod और go.sum (जिसमें डिपेंडेंसियों के अपेक्षित नाकवी हैश को दर्ज किया गया है) फ़ाइलों को नियमित रूप से कमिट करना।

go.mod फ़ाइल के माध्यम से प्रबंधन करके, इसे सुनिश्चित किया जाता है कि टीम में प्रत्येक डेवलपर समान डिपेंडेंसी संस्करण का उपयोग करता है, इससे "लेकिन मेरे मशीन पर काम करता है" की अजीब स्थिति से बचा जा सकता है।