गो पैकेज कैसे लिखें

एक गो पैकेज में एक ही डायरेक्टरी में स्थित गो फाइल्स होती हैं, जिसकी शुरुआत में एक ही package एक्सप्रेशन होता है। प्रोग्राम से जुड़ने वाले पैकेज आपको उनकी क्षमताओं का विस्तार करने की अनुमति देते हैं। कुछ पैकेज मानक गो लाइब्रेरी का हिस्सा हैं। इसका मतलब है कि यदि आप गो का उपयोग करते हैं, तो वे पहले से ही स्थापित हैं। go get पैकेज कमांड का उपयोग करके अन्य पैकेज स्थापित किए go get । आप अपने स्वयं के गो-पैकेज भी लिख सकते हैं, विशेष निर्देशिकाओं में फाइलें बना सकते हैं, और पैकेज डिजाइन के नियमों का पालन कर सकते हैं।



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

आवश्यक शर्तें

• अपने गो सॉफ़्टवेयर वातावरण को सेट करें (यहां जानें कि यह कैसे करना है )। एक गो कार्यक्षेत्र बनाएं (उपरोक्त सामग्री का पांचवां बिंदु इसके लिए समर्पित है)। इस सामग्री के अगले भाग में आप ऐसे उदाहरण पा सकते हैं जिन्हें घर पर पुन: प्रस्तुत करने की सिफारिश की जाती है। इसलिए आप उनसे बेहतर तरीके से निपट सकते हैं।
• GOPATH अपने ज्ञान को गहरा करने के लिए - इस सामग्री पर एक नज़र डालें।

पैकेज लिखना और आयात करना

पैकेज कोड लिखना नियमित गो कोड लिखने के समान है। पैकेज में फ़ंक्शंस, प्रकार और चर की घोषणाएं हो सकती हैं, जिन्हें बाद में अन्य गो-कार्यक्रमों में उपयोग किया जा सकता है।

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

 └── $GOPATH    └── src        └── github.com            └── gopherguides 

हम उस पैकेज को नाम देने जा रहे हैं जिसे हम इस गाइड में विकसित करेंगे, greet । ऐसा करने के लिए, gopherguides निर्देशिका में greet निर्देशिका बनाएं। परिणामस्वरूप, मौजूदा फ़ोल्डर संरचना निम्न रूप लेगी:

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet 

अब हम greet डायरेक्टरी में पहली फाइल जोड़ने के लिए तैयार हैं। आमतौर पर, एक फ़ाइल जो पैकेज का एंट्री पॉइंट होता है, उसे पैकेज डायरेक्टरी के समान कहा जाता है। इस स्थिति में, इसका मतलब है कि हम, greet निर्देशिका में, greet.go फ़ाइल बनाएँ:

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet                    └── greet.go 

इस फ़ाइल में हम कोड लिख सकते हैं जिसे हम अपनी परियोजनाओं में फिर से उपयोग करना चाहते हैं। इस मामले में, हम Hello फ़ंक्शन बनाएंगे, जो पाठ Hello, World! प्रदर्शित करता है Hello, World! ।

टेक्स्ट एडिटर में greet.go खोलें। फाइल को निम्न कोड में जोड़ें:

 package greet import "fmt" func Hello() {    fmt.Println("Hello, World!") } 

आइए इस फ़ाइल की सामग्री का विश्लेषण करें। प्रत्येक फ़ाइल की पहली पंक्ति में उस पैकेज का नाम होना चाहिए जिसमें हम काम करते हैं। चूँकि हम greet package , यहाँ package कीवर्ड का उपयोग किया जाता है, उसके बाद पैकेज का नाम आता है:

 package greet 

यह कंपाइलर को फ़ाइल में सब कुछ स्वीकार करने के लिए greet पैकेज के हिस्से के रूप में बताता है।

अगला, आवश्यक पैकेज import विवरण का उपयोग करके import किए जाते हैं। इस मामले में, हमें केवल एक पैकेज की आवश्यकता है - fmt :

 import "fmt" 

और अंत में, हम Hello फ़ंक्शन बनाते हैं। वह स्ट्रिंग पैकेज की क्षमताओं का उपयोग करने के लिए स्ट्रिंग को प्रदर्शित करेगा Hello, World! :

 func Hello() {    fmt.Println("Hello, World!") } 

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

अर्थात्, हम एक example पैकेज बनाएंगे। ऐसा करने के लिए, हम उन्हीं धारणाओं से आगे बढ़ेंगे जहाँ से हम आगे बढ़े, greet पैकेज बना। सबसे पहले, gopherguides फ़ोल्डर में example फ़ोल्डर बनाएँ:

 └── $GOPATH    └── src        └── github.com            └── gopherguides                    └── example 

अब एक फाइल बनाएं जो पैकेज एंट्री पॉइंट हो। हम इस पैकेज को एक निष्पादन योग्य कार्यक्रम के रूप में मानते हैं, न कि ऐसे पैकेज के रूप में जिसका कोड अन्य पैकेजों में उपयोग करने की योजना है। प्रोग्राम के इनपुट पॉइंट्स वाली फाइलें आमतौर पर main.go :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── example                    └── main.go 

संपादक में main.go फ़ाइल खोलें और main.go निम्न कोड main.go , जो आपको main.go पैकेज की क्षमताओं का उपयोग करने की अनुमति देता है:

 package main import "github.com/gopherguides/greet" func main() {    greet.Hello() } 

हमने main.go फ़ाइल में greet पैकेज आयात किया, जिसका अर्थ है कि इस पैकेज में घोषित फ़ंक्शन को कॉल करने के लिए, हमें डॉट नोटेशन का उपयोग करने की आवश्यकता है। एक डॉट संकेतन एक निर्माण है जिसमें पैकेज नाम और इस पैकेज के संसाधन नाम के बीच एक डॉट का उपयोग किया जाता है। उदाहरण के लिए, greet पैकेज में, Hello फ़ंक्शन एक संसाधन की भूमिका निभाता है। यदि आपको इस फ़ंक्शन को कॉल करने की आवश्यकता है, तो डॉट नोटेशन का उपयोग किया जाता है : greet.Hello() ।

अब आप टर्मिनल खोल सकते हैं और कार्यक्रम चला सकते हैं:

 go run main.go 

ऐसा करने के बाद, टर्मिनल निम्नलिखित प्रदर्शित करेगा:

 Hello, World! 

अब आइए पैकेजों में घोषित चर का उपयोग कैसे करें। ऐसा करने के लिए, वैरिएबल डिक्लेरेशन को greet.go फ़ाइल में जोड़ें।

 package greet import "fmt" var Shark = "Sammy" func Hello() {    fmt.Println("Hello, World!") } 

main.go फ़ाइल खोलें और उसमें एक पंक्ति जोड़ें जहाँ fmt.Println() फ़ंक्शन का उपयोग greet.go में दिए गए Shark चर के मान को प्रदर्शित करने के लिए किया जाता है। अर्थात्, निम्नलिखित रूप में main.go :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark) } 

प्रोग्राम को फिर से चलाएँ:

 go run main.go 

अब वह निम्नलिखित उत्पादन करेगी:

 Hello, World! Sammy 

अब बात करते हैं कि पैकेजों में प्रकारों की घोषणा कैसे करें। Name और Color फ़ील्ड के साथ एक Octopus प्रकार बनाएँ, और एक विधि बनाएँ। यह विधि, जब कहा जाता है, Octopus क्षेत्रों की विशेष रूप से संसाधित सामग्री वापस कर देगा। चलो निम्नलिखित फ़ॉर्म में greet.go करें:

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func Hello() {    fmt.Println("Hello, World!") } 

अब main.go खोलें, इसमें नए प्रकार की संरचना का एक उदाहरण बनाएं और इसके String() विधि को देखें:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String()) } 

आपके द्वारा Octopus का एक उदाहरण बनाने के बाद, जो Octopus की तरह दिखता है oct := greet.Octopus , आप प्रकार के तरीकों और गुणों का उपयोग कर सकते हैं। main.go फाइल main.go । यह, विशेष रूप से, आपको greet सहारा लिए बिना main.go फ़ाइल के अंत में स्थित oct.String() कमांड का उपयोग करने की अनुमति देता है। इसके अलावा, हम, उदाहरण के लिए, oct.Color निर्माण का उपयोग करके Color संरचना के क्षेत्र को संदर्भित कर सकते हैं। उसी समय, हम, जब हम विधि कहते हैं, greet तक नहीं पहुँचते हैं।

Octopus प्रकार की String विधि fmt.Sprintf फ़ंक्शन का उपयोग वाक्य बनाने के लिए करती है और रिटर्न, परिणाम, स्ट्रिंग, विधि कॉल के लिए (इस मामले में, यह स्थान main.go ) का उपयोग करती है।

प्रोग्राम को फिर से चलाएँ:

 go run main.go 

यह कंसोल को निम्न आउटपुट देगा:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange. 

अब जब हमने ऑक्टोपस को String विधि से सुसज्जित कर लिया है, तो हमें एक प्रकार की सूचना उत्पादन प्रणाली मिल गई है जो पुन: उपयोग के लिए उपयुक्त है। यदि भविष्य में आपको इस पद्धति के व्यवहार को बदलने की आवश्यकता है, जिसका उपयोग कई परियोजनाओं में किया जा सकता है, तो यह greet.go में इसके कोड को संपादित करने के लिए पर्याप्त होगा।

इकाई निर्यात

आपने देखा होगा कि greet पैकेज को एक्सेस करने के दौरान हमने जो कुछ भी काम किया था, उसमें ऐसे नाम होते हैं जो एक बड़े अक्षर से शुरू होते हैं। गो में public , private या protected जैसे एक्सेस मॉडिफायर नहीं हैं, जो अन्य भाषाओं में हैं। बाहरी तंत्र के लिए संस्थाओं की दृश्यता इस तथ्य से नियंत्रित होती है कि किस पत्र के साथ, एक छोटे या बड़े के साथ, उनके नाम शुरू होते हैं। परिणामस्वरूप, प्रकार, चर, फ़ंक्शन जिनके नाम एक बड़े अक्षर से शुरू होते हैं, वे वर्तमान पैकेज के बाहर उपलब्ध हैं। पैकेज के बाहर दिखाई देने वाले कोड को निर्यात कहा जाता है।

यदि आप Octopus प्रकार को reset नामक एक नई विधि से लैस करते हैं, तो इस पद्धति को main.go पैकेज से बुलाया जा सकता है, लेकिन main.go फ़ाइल से नहीं, जो main.go पैकेज के बाहर है। यहाँ एक अद्यतन संस्करण है।

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

चलो main.go फ़ाइल से reset कॉल reset का प्रयास करें:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.reset() } 

इसके परिणामस्वरूप निम्नलिखित संकलन त्रुटि होगी:

 oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset) 

Octopus प्रकार reset विधि को निर्यात करने के लिए, आपको इसका नाम बदलने की आवश्यकता है, पहले अक्षर की जगह, लोअरकेस r , पूंजीगत पूंजी के साथ R हम इसे greet.go संपादित करके करते हैं।

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) Reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

यह इस तथ्य को जन्म देगा कि हम Reset को अन्य पैकेजों से और बिना त्रुटि संदेशों के कॉल करने में सक्षम होंगे:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.Reset()    fmt.Println(oct.String()) } 

प्रोग्राम चलाएँ:

 go run main.go 

यहाँ सांत्वना के लिए क्या है:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color . 

Reset विधि को कॉल करके, हमने अपने Octopus उदाहरण का Name और Color फ़ील्ड साफ़ किया। नतीजतन, String कहते समय, जहां पहले Name और Color फ़ील्ड की सामग्री प्रदर्शित की गई थी, अब कुछ भी प्रदर्शित नहीं होता है।

परिणाम

गो पैकेज लिखना नियमित गो कोड लिखने से अलग नहीं है। हालांकि, पैकेज कोड को अपनी निर्देशिकाओं में रखने से कोड को अलग करने की अनुमति मिलती है, जिसका उपयोग किसी भी अन्य गो-प्रोजेक्ट में किया जा सकता है। यहां हमने पैकेजों में फ़ंक्शंस, वेरिएबल्स और प्रकारों को घोषित करने के तरीके के बारे में बात की, इन पैकेजों के बाहर इन संस्थाओं का उपयोग करने के तरीके की जांच की, और यह पता लगाया कि उनके दोहराया उपयोग के लिए डिज़ाइन किए गए पैकेजों को कहाँ स्टोर करना है।

प्रिय पाठकों! आप आमतौर पर गो पर क्या कार्यक्रम लिखते हैं? क्या आप उनमें मालिकाना पैकेज का उपयोग करते हैं?