इससे भी महत्वपूर्ण बात यह है कि जेनेरिक गो की मजबूत प्रकार की सुरक्षा को बनाए रखता है जो संकलन-समय पर स्थैतिक प्रकार की जाँच को सक्षम बनाता है और प्रकार की शुद्धता सुनिश्चित करता है। वे जेनेरिक कोड के भीतर एक मानकीकृत त्रुटि प्रबंधन प्रदान करते हैं जो स्पष्टता और रखरखाव में सुधार करता है। इसके अतिरिक्त, वे जेनेरिक कोड के भीतर एक मानकीकृत त्रुटि प्रबंधन प्रदान करते हैं जो स्पष्टता और रखरखाव में सुधार करता है। इस पोस्ट में, हम कई वास्तविक दुनिया के गो जेनरिक अनुप्रयोगों और उदाहरणों की जांच करेंगे।
उदाहरण 1: गोलांग जेनेरिक फ़ंक्शन का उपयोग करना
जेनेरिक के लिए प्राथमिक उपयोग के मामलों में से एक ऐसे फ़ंक्शन बनाना है जो विभिन्न प्रकारों पर काम कर सकते हैं। यहां, हम उन उदाहरणों में से एक के साथ जाते हैं जहां सामान्य परिधि फ़ंक्शन का उपयोग किया जाता है।
पैकेट मुख्य
आयात 'एफएमटी'
समारोह परिधि [ आर int यहाँ | फ्लोट32 ]( त्रिज्या आर ) {
सी := 3 * 2 * RADIUS
एफएमटी . Println ( 'सामान्य परिधि है:' , सी )
}
समारोह मुख्य () {
था आर 1 int यहाँ = 7
था आर2 फ्लोट32 = 7 . 5
परिधि ( आर 1 )
परिधि ( आर2 )
}
पिछले कोड की शुरुआत में, लाइन 'एफएमटी' पैकेज आयात करती है जो कंसोल पर आउटपुट प्रिंट करने सहित स्वरूपित I/O के लिए फ़ंक्शन प्रदान करती है। फिर, हम 'परिधि' नामक एक सामान्य फ़ंक्शन को परिभाषित करते हैं जो सामान्य प्रकार 'आर' का पैरामीटर त्रिज्या लेता है जो या तो 'इंट' या 'फ्लोट32' हो सकता है। फ़ंक्शन के अंदर, यह त्रिज्या को '3' के स्थिर मान से गुणा करके और फिर इसे '2' से गुणा करके परिधि की गणना करता है। अंत में, यह 'fmt.Println' का उपयोग करके गणना की गई परिधि को प्रिंट करता है।
इसके बाद, हमारे पास मुख्य फ़ंक्शन है जहां दो चर, r1 और r2, क्रमशः 7 और 7.5 के मानों के साथ घोषित और निर्दिष्ट किए जाते हैं। उसके बाद, 'परिधि' फ़ंक्शन को तर्क के रूप में r1 और r2 पास करते हुए दो बार लागू किया जाता है।
आउटपुट निम्नलिखित में वृत्तों की परिधि को प्रिंट करके गणना प्रदर्शित करता है:
उदाहरण 2: गोलंग जेनेरिक इंटरफ़ेस का उपयोग करना
इसके अलावा, गोलांग जेनेरिक अपने इंटरफेस के साथ हमारी सहायता करते हैं। कोड के पुन: उपयोग और बहुरूपता को सुविधाजनक बनाने के लिए गो में इंटरफेस एक महत्वपूर्ण उपकरण है। उन्हें कई प्रकार के साथ कार्य करने में सक्षम करके, जेनरिक इंटरफ़ेस की शक्ति को बढ़ाते हैं। गोलांग जेनेरिक इंटरफ़ेस का स्रोत कोड निम्नलिखित है:
पैकेट मुख्य
आयात 'एफएमटी'
प्रकार एम्पएज इंटरफेस {
int64 | int32 | फ्लोट32 | फ्लोट64
}
समारोह newGenericFunc [ उम्र उम्र ]( emp_आयु आयु ) {
वैल := int यहाँ ( emp_आयु ) + 1
एफएमटी . Println ( वैल )
}
समारोह मुख्य () {
एफएमटी . Println ( 'कर्मचारियों की आयु' )
था आयु1 int64 = 24
था आयु2 फ्लोट64 = 25 . 5
newGenericFunc ( आयु1 )
newGenericFunc ( आयु2 )
}
पिछले स्रोत कोड में, हमने 'एम्पएज' नामक एक इंटरफ़ेस परिभाषित किया था जो किसी कर्मचारी की उम्र के लिए संभावित प्रकार निर्दिष्ट करता है। इंटरफ़ेस में int64, int32, फ्लोट32 और फ्लोट64 प्रकार शामिल हैं। यह इंटरफ़ेस 'जेनेरिक' फ़ंक्शन को इनमें से किसी भी प्रकार को तर्क के रूप में स्वीकार करने की अनुमति देता है। उसके बाद, हम newGenericFunc नाम का एक सामान्य फ़ंक्शन नियोजित करते हैं जो सामान्य प्रकार की आयु का emp_Age पैरामीटर लेता है जो कि किसी भी प्रकार का हो सकता है जो EmpAge इंटरफ़ेस को संतुष्ट करता है। फ़ंक्शन के अंदर, यह emp_Age को एक int में परिवर्तित करता है और दिखाए गए अनुसार इसे 1 से बढ़ाता है।
इसके बाद, हम दो चर, Age1 और Age2 घोषित करते हैं, और मुख्य फ़ंक्शन में क्रमशः 24 और 25.5 के मान निर्दिष्ट करते हैं। इसके बाद, Age1 और Age2 को newGenericFunc फ़ंक्शन के पैरामीटर के रूप में पारित किया जाता है, जो दो बार निष्पादन से गुजरता है। इसके साथ, उम्र 1 बढ़ जाती है और अद्यतन मान उत्पन्न होते हैं।
निम्नलिखित में जो आउटपुट प्राप्त होता है वह इंटरफ़ेस का उपयोग करने वाले सामान्य फ़ंक्शन की आयु है:
उदाहरण 3: गोलांग जेनेरिक डेटा संरचना का उपयोग करना
इसके अलावा, गो जेनरिक हमें स्टैक, क्यू और लिंक्ड सूचियों जैसी सामान्य डेटा संरचनाएं बनाने की क्षमता भी देता है। निम्नलिखित में सामान्य स्टैक के कार्यान्वयन पर विचार करें:
आयात 'एफएमटी'प्रकार ढेर [ टी कोई भी ] [] टी
समारोह ( अनुसूचित जनजाति * ढेर [ टी ]) धकेलना ( आइटम टी ) {
अनुसूचित जनजाति = संलग्न ( * अनुसूचित जनजाति , वस्तु )
}
समारोह ( अनुसूचित जनजाति * ढेर [ टी ]) जल्दी से आना () टी {
अगर केवल ( * अनुसूचित जनजाति ) == 0 {
घबड़ाहट ( 'स्टैक में कुछ भी नहीं' )
}
अनुक्रमणिका := केवल ( * अनुसूचित जनजाति ) - 1
वस्तु := ( * अनुसूचित जनजाति )[ अनुक्रमणिका ]
* अनुसूचित जनजाति = ( * अनुसूचित जनजाति )[: अनुक्रमणिका ]
वापस करना वस्तु
}
समारोह मुख्य () {
ढेर := नया ( ढेर [ int यहाँ ])
ढेर . धकेलना ( 1 )
ढेर . धकेलना ( 2 )
ढेर . धकेलना ( 3 )
एफएमटी . Println ( ढेर . जल्दी से आना ())
एफएमटी . Println ( ढेर . जल्दी से आना ())
एफएमटी . Println ( ढेर . जल्दी से आना ())
}
पिछले कोड में, 'स्टैक' नामक एक सामान्य प्रकार को परिभाषित किया गया है जो स्टैक का प्रतिनिधित्व करता है। 'टी' प्लेसहोल्डर स्टैक को किसी भी प्रकार के तत्वों को रखने की अनुमति देता है। 'स्टैक' प्रकार को 'टी' प्रकार के तत्वों के एक स्लाइस के रूप में कार्यान्वित किया जाता है। यहां, 'स्टैक' प्रकार के लिए दो फ़ंक्शन तैनात किए गए हैं: 'पुश' और 'पॉप।' पुश() फ़ंक्शन तत्वों को स्टैक में जोड़ने के लिए ज़िम्मेदार है। यह 'T' प्रकार का एक तर्क आइटम लेता है और इसे एपेंड() फ़ंक्शन का उपयोग करके अंतर्निहित स्लाइस में जोड़ता है।
जबकि पॉप() फ़ंक्शन स्टैक से प्रारंभिक घटक लेता है और उसे लौटाता है, यह पहले अंतर्निहित स्लाइस के आकार का मूल्यांकन करके यह निर्धारित करता है कि स्टैक खाली है या नहीं। यदि स्टैक खाली दिखाई देता है तो एक त्रुटि सूचना भेजी जाती है जिससे घबराहट होती है। अन्यथा, यह स्लाइस से अंतिम तत्व को पुनः प्राप्त करता है, स्लाइस को दूसरे से अंतिम तत्व तक स्लाइस करके स्टैक से हटा देता है, और हटाए गए आइटम को वापस कर देता है।
इसके बाद, इस कोड के मुख्य फ़ंक्शन के भीतर स्टैक[int] सिंटैक्स का उपयोग करके पूर्णांकों का नया स्टैक बनाया जाता है। उसके बाद, स्टैक में पूर्णांक 1, 2 और 3 जोड़ने के लिए 'पुश' विधि को तीन बार बुलाया जाता है। हालाँकि, स्टैक से तत्वों को पुनः प्राप्त करने और प्रिंट करने के लिए 'पॉप' विधि को बाद में तीन बार बुलाया जाता है।
निम्नलिखित आउटपुट इंगित करता है कि तत्वों को स्टैक से उल्टे क्रम में हटा दिया गया है:
उदाहरण 4: गोलांग जेनेरिक बाधाओं का उपयोग करना
गो कस्टम बाधाएं भी प्रदान करता है जो काफी लचीलेपन को सक्षम बनाता है और उनकी एप्लिकेशन आवश्यकताओं के आधार पर सामान्य निर्माणों के लिए विशिष्ट आवश्यकताओं को परिभाषित करता है। कस्टम जेनेरिक बाधाओं का कोड प्रदर्शन के लिए निम्नलिखित में प्रदान किया गया है:
पैकेट मुख्यआयात 'एफएमटी'
प्रकार अंकीय इंटरफेस {
int64 | फ्लोट64
}
समारोह मुख्य () {
फ्लोटवैल्यू := [] फ्लोट64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
पूर्णांक मूल्य := [] int64 { 2 , 4 , 6 , 8 , 10 }
योग1 := जेनेरिकसम ( फ्लोटवैल्यू )
योग2 := जेनेरिकसम ( पूर्णांक मूल्य
एफएमटी . Println ( 'फ़्लोट64 का योग:' , योग1 )
एफएमटी . Println ( 'int64 का योग:' , योग2 )
}
समारोह जेनेरिकसम [ n अंकगणित ]( nums [] एन ) एन {
था मैं n हूँ
के लिए _ , एक पर := श्रेणी nums {
जोड़ += एक पर
}
वापस करना जोड़
}
पिछले स्रोत कोड में, हम न्यूमेरिक्स इंटरफ़ेस को 'Sum' विधि से परिभाषित करते हैं। फिर, हम दो कस्टम प्रकार, 'फ्लोटवैल्यू' और 'इंटेगरवैल्यू' बनाते हैं, जो अपने संबंधित 'सम' तरीकों को प्रदान करके न्यूमेरिक्स इंटरफ़ेस को कार्यान्वित करते हैं। जेनेरिकसम फ़ंक्शन अब न्यूमेरिक्स इंटरफ़ेस को संतुष्ट करने वाले किसी भी प्रकार के स्लाइस को स्वीकार करने में सक्षम है। फ़ंक्शन के अंदर, हम तत्वों पर पुनरावृति करते हैं और योग की गणना करने के लिए 'Sum' विधि को कॉल करते हैं। अंत में, मुख्य फ़ंक्शन में, हम फ़्लोटवैल्यू और इंटेगरवैल्यू के स्लाइस बनाते हैं और उन्हें जेनेरिकसम() फ़ंक्शन में पास करते हैं जो प्रत्येक स्लाइस में तत्वों के योग की सही गणना करता है।
अपेक्षित आउटपुट अब निम्न स्क्रीन पर दिखाई दे रहा है:
निष्कर्ष
हमने गो जेनरिक के कुछ व्यावहारिक उदाहरणों की खोज की जिसमें एक सामान्य डेटा संरचना और सामान्य फ़ंक्शन का निर्माण, एक सामान्य इंटरफ़ेस को परिभाषित करना और कस्टम प्रकार की बाधा का उपयोग करना शामिल है। ये उदाहरण उस शक्ति और लचीलेपन को प्रदर्शित करते हैं जो जेनेरिक गो प्रोग्रामिंग भाषा में लाते हैं। ध्यान दें कि संकलन के दौरान जेनेरिक कोड जनरेशन कुशल बाइनरी आकार और संकलन समय सुनिश्चित करता है।