उदाहरण 1: गोलांग खाली इंटरफ़ेस
खाली इंटरफ़ेस{} से प्रारंभ करें जिसे गो में इंटरफ़ेस कहा जाता है। यह एक प्रकार को इंगित करता है जो किसी भी प्रकार के मूल्य को संग्रहीत कर सकता है। गो में खाली इंटरफ़ेस के लिए स्रोत कोड निम्नलिखित है:
पैकेट मुख्यआयात 'एफएमटी'
प्रकार मार्क्सकैलकुलेटर इंटरफेस {}
समारोह मुख्य () {
था एम मार्क्सकैलकुलेटर
एफएमटी . Println ( एम )
}
यहां, हम वह कोड प्रदान करते हैं जहां 'मार्क्सकैलकुलेटर' इंटरफ़ेस में कोई निर्दिष्ट विधि हस्ताक्षर नहीं है क्योंकि यह खाली है। परिणामस्वरूप, यह कोई कार्यक्षमता प्रदान नहीं करता है। इसके बाद, हमारे पास इस खाली इंटरफ़ेस का मुख्य() फ़ंक्शन है जहां मार्क्सकैलकुलेटर प्रकार का एक चर 'एम' घोषित किया गया है। चूँकि इंटरफ़ेस खाली है, 'एम' किसी भी प्रकार का कोई भी मान रख सकता है। इस मामले में, 'एम' अप्रारंभीकृत है, इसलिए इसके प्रकार के लिए इसका शून्य मान है जो इंटरफेस के लिए 'शून्य' है। जब 'm' को 'fmt.Println' का उपयोग करके प्रिंट किया जाता है तो यह कंसोल पर 'nil' आउटपुट करता है।
जो आउटपुट पुनर्प्राप्त किया गया है वह 'शून्य' है जैसा कि पिछले स्रोत कोड से अपेक्षित था:
उदाहरण 2: इंटरफ़ेस का गोलांग कार्यान्वयन
यह अनुभाग गोलांग इंटरफ़ेस के कार्यान्वयन को प्रदर्शित करता है। गो में इसे लागू करने के लिए एक प्रकार को इंटरफ़ेस में प्रत्येक निर्दिष्ट विधि के लिए कार्यान्वयन की पेशकश करनी चाहिए। इंटरफ़ेस कार्यान्वयन के लिए स्रोत कोड निम्नलिखित है:
पैकेट मुख्य
आयात (
'एफएमटी'
)
प्रकार स्वर वर्ण इंटरफेस {
स्वर खोजें () [] रूण
}
प्रकार MyStr डोरी
समारोह ( सेंट MyStr ) स्वर खोजें () [] रूण {
था स्वर वर्ण [] रूण
के लिए _ , रूण := श्रेणी अनुसूचित जनजाति {
अगर रूण == 'ए' || रूण == 'यह है' || रूण == 'मैं' || रूण == 'ओ' || रूण == 'में' {
स्वर वर्ण = संलग्न ( स्वर वर्ण , रूण )
}
}
वापस करना स्वर वर्ण
}
समारोह मुख्य () {
न्यूस्ट्रिंग := MyStr ( 'गोलांग इंटरफ़ेस' )
था v1 स्वर
v1 = न्यूस्ट्रिंग
एफएमटी . printf ( 'स्वर %c हैं' , v1 . स्वर खोजें ())
}
यहां, कोड 'स्वर' नामक एक इंटरफ़ेस को परिभाषित करता है जो एक एकल विधि SearchVowels() को निर्दिष्ट करता है जो रूण का एक टुकड़ा लौटाता है (प्रकार int32)। एक इंटरफ़ेस किसी भी प्रकार को सक्षम बनाता है जो इस विधि हस्ताक्षर को इंटरफ़ेस प्रकार के एक चर को असाइन करने के लिए लागू करता है। फिर, एक नया 'MyStr' प्रकार घोषित किया जाता है जो अंतर्निहित प्रकार स्ट्रिंग के लिए एक उपनाम है। इसका मतलब यह है कि 'MyStr' को स्ट्रिंग के सभी तरीके विरासत में मिले हैं लेकिन यह एक अलग प्रकार है।
उसके बाद, हम 'MyStr' प्रकार के लिए SearchVowels() विधि लागू करते हैं। यह विधि इनपुट स्ट्रिंग वर्ण को वर्ण द्वारा स्कैन करती है और जांचती है कि क्या प्रत्येक वर्ण एक स्वर है ('ए', 'ई', 'आई', 'ओ', या 'यू')। यदि कोई वर्ण एक स्वर है, तो उसे स्वर खंड में जोड़ा जाता है।
मुख्य() फ़ंक्शन के अंदर, 'MyStr' प्रकार का एक 'न्यूस्ट्रिंग' वेरिएबल 'GoLang Interfaces' मान के साथ बनाया जाता है। इसके बाद, 'स्वर' प्रकार का एक 'v1' वेरिएबल घोषित किया जाता है। चूंकि 'MyStr' SearchVowels() विधि को लागू करता है जिसे 'Vowels' इंटरफ़ेस में परिभाषित किया गया है, 'NewString' को 'v1' को सौंपा जा सकता है।
आउटपुट स्वरों की सभी सारणी प्रदर्शित करता है जो निर्दिष्ट स्ट्रिंग में पाए जाते हैं:
उदाहरण 3: गोलांग स्ट्रिंगर इंटरफ़ेस
इसके अतिरिक्त, गोलंग के पास 'एफएमटी' पैकेज में पूर्वनिर्धारित 'स्ट्रिंगर' इंटरफ़ेस है। यह 'fmt' पैकेज के मुद्रण कार्यों में '%v' क्रिया के साथ स्वरूपित होने पर एक कस्टम प्रकार को इसके स्ट्रिंग प्रतिनिधित्व को नियंत्रित करने की अनुमति देता है। गो के स्ट्रिंगर इंटरफ़ेस के लिए उदाहरण कोड निम्नलिखित है:
पैकेट मुख्यआयात (
'एफएमटी'
)
प्रकार विद्यार्थी struct {
नाम डोरी
डिग्री डोरी
}
समारोह ( का छात्र ) डोरी () डोरी {
वापस करना एफएमटी . स्प्रिंटफ़ ( '%s एक(n) %s है' , एस . नाम , एस . डिग्री )
}
समारोह मुख्य () {
एस 1 := विद्यार्थी { 'ऐलेना गिल्बर्ट' , 'कंप्यूटर विज्ञान' }
एस 2 := विद्यार्थी { 'कैरोलीन कैंडिस' , 'बीबीए' }
एफएमटी . Println ( एस 1 )
एफएमटी . Println ( एस 2 )
}
यहां, कोड पहले आवश्यक पैकेज को आयात करता है जो कंसोल पर प्रिंट करने के लिए 'एफएमटी' है। फिर, हम दो क्षेत्रों के साथ एक संरचना प्रकार 'छात्र' को परिभाषित करते हैं: 'नाम' और 'डिग्री'। यह संरचना एक छात्र की जानकारी का प्रतिनिधित्व करती है। इसके अलावा, 'छात्र' प्रकार के लिए एक स्ट्रिंग() विधि बनाई गई है। इस विधि में 'छात्र' प्रकार का एक रिसीवर होता है और एक स्ट्रिंग लौटाता है। 'स्ट्रिंग ()' विधि गो में एक विशेष विधि है जिसका उपयोग मुद्रित होने पर किसी ऑब्जेक्ट के स्ट्रिंग प्रतिनिधित्व को अनुकूलित करने के लिए किया जाता है। इस मामले में, 'स्ट्रिंग ()' विधि एक स्ट्रिंग को प्रारूपित और लौटाती है जिसमें छात्र का नाम और डिग्री शामिल होती है।
इसके बाद, हमारे पास मुख्य() फ़ंक्शन है जहां 'छात्र' प्रकार के दो चर, s1 और s2, छात्र जानकारी के साथ घोषित और आरंभ किए जाते हैं। अंत में, कोड s1 और s2 के मानों को प्रिंट करने के लिए fmt.Println() फ़ंक्शन का उपयोग करता है। चूंकि स्ट्रिंग() विधि को 'छात्र' प्रकार के लिए परिभाषित किया गया है, गो 'छात्र' ऑब्जेक्ट को प्रिंट करते समय स्वचालित रूप से इस विधि को कॉल करता है। स्ट्रिंग() विधि 'fmt.Sprintf()' फ़ंक्शन का उपयोग करके छात्र की जानकारी को प्रारूपित करती है और स्वरूपित स्ट्रिंग लौटाती है।
निम्नलिखित आउटपुट स्ट्रिंगर इंटरफ़ेस के 'छात्र' प्रकार के ऑब्जेक्ट को प्रिंट करता है:
उदाहरण 4: गोलांग टाइप स्विच इंटरफ़ेस
इसके बाद गो का टाइप स्विच इंटरफ़ेस आता है। एक प्रकार का स्विच एक नियंत्रण संरचना है जो हमें इंटरफ़ेस मान के गतिशील प्रकार का निरीक्षण करने की अनुमति देता है। प्रकार स्विच इंटरफ़ेस के स्रोत कोड का पालन करें:
पैकेट मुख्यआयात 'एफएमटी
func MyFunction(F1 इंटरफ़ेस{}) {
स्विच F1.(प्रकार) {
केस इंट:
fmt.Println(' प्रकार : int यहाँ , कीमत : ', F1.(आप))
केस स्ट्रिंग:
fmt.Println(' \nटाइप करें : डोरी , कीमत : ', F1.(स्ट्रिंग))
केस फ्लोट64:
fmt.Println(' \nटाइप करें : फ्लोट64 , कीमत : ', एफ1.(फ्लोट64))
गलती करना:
fmt.Println(' \nप्रकार मान्य नहीं है ')
}
}
func मुख्य() {
मेराफ़ंक्शन(' गोलांग इंटरफेस ट्यूटोरियल ')
मेराफ़ंक्शन(89.7)
मेराफ़ंक्शन(सही)
}
यहां, प्रदान किया गया कोड एक 'MyFunction' फ़ंक्शन को परिभाषित करता है जो 'इंटरफ़ेस {}' प्रकार का 'F1' पैरामीटर लेता है। यह इंगित करता है कि 'F1' किसी भी प्रकार का मान स्वीकार कर सकता है। फ़ंक्शन के अंदर, 'MyFunction' को दिए गए मान के प्रकार की जांच करने के लिए 'F1.(प्रकार)' के साथ एक स्विच स्टेटमेंट का उपयोग किया जाता है। इंटरफ़ेस मान के अंतर्निहित गतिशील प्रकार को प्राप्त करने के लिए '.(प्रकार)' सिंटैक्स का उपयोग प्रकार स्विच में किया जाता है। ध्यान दें कि यहां स्विच केस तीन विशिष्ट प्रकारों को संभालते हैं: 'इंट', 'स्ट्रिंग', और 'फ्लोट64'। यदि 'F1' प्रकार इनमें से किसी एक मामले से मेल खाता है। यह प्रकार के दावे (F1.(int), F1.(string), F1.(float64)) का उपयोग करके संबंधित प्रकार और मान को प्रिंट करता है। यदि 'F1' प्रकार किसी भी परिभाषित मामले से मेल नहीं खाता है, तो डिफ़ॉल्ट केस निष्पादित होता है जो 'प्रकार मान्य नहीं है' प्रिंट करता है।
इसके बाद, मुख्य() फ़ंक्शन के भीतर, 'माईफ़ंक्शन' को अलग-अलग मानों के साथ तीन बार कॉल किया जाता है: एक स्ट्रिंग, एक फ्लोट64, और एक बूलियन (जिसे स्विच स्टेटमेंट में नियंत्रित नहीं किया जाता है)।
आउटपुट प्रकार के दावे के साथ स्विच इंटरफ़ेस का प्रदर्शन प्रदर्शित करता है:
उदाहरण 5: गोलांग मल्टीपल इंटरफेस
इसके अलावा, गो कई इंटरफेस प्रदान करता है जो इसे संदर्भ के आधार पर व्यवहार के विभिन्न सेट प्रदान करने की अनुमति देता है। इस सुविधा को 'एकाधिक इंटरफ़ेस' या 'इंटरफ़ेस संरचना' कहा जाता है। निम्नलिखित कोड एकाधिक इंटरफ़ेस कार्यान्वयन को प्रदर्शित करता है:
पैकेट मुख्यआयात 'एफएमटी'
प्रकार पक्षियों इंटरफेस {
साँस लेना ()
उड़ना ()
}
प्रकार पक्षी इंटरफेस {
खिलाना ()
}
प्रकार कहाँ struct {
आयु int यहाँ
}
समारोह ( घ कहाँ ) साँस लेना () {
एफएमटी . Println ( 'कबूतर साँस लेता है' )
}
समारोह ( घ कहाँ ) उड़ना () {
एफएमटी . Println ( 'कबूतर उड़ना' )
}
समारोह ( घ कहाँ ) खिलाना () {
एफएमटी . Println ( 'कबूतर बच्चों का पालन-पोषण करता है' )
}
समारोह मुख्य () {
था बी पक्षी
डी := कहाँ {}
बी = डी
बी . साँस लेना ()
बी . उड़ना ()
था एक पक्षी
ए = डी
ए . खिलाना ()
}
यहां, हम दो इंटरफेस परिभाषित करते हैं: 'पक्षी' और 'एवियन'। 'पक्षी' इंटरफ़ेस दो तरीकों की घोषणा करता है: साँस लेना() और उड़ना()। जबकि 'एवियन' इंटरफ़ेस फ़ीड() विधि घोषित करता है। फिर, 'कबूतर' संरचना 'पक्षियों' और 'एवियन' दोनों इंटरफेस के सभी तरीकों को लागू करती है। यह ब्रीद(), फ्लाई() और फीड() के लिए कार्यान्वयन प्रदान करता है।
इसके बाद, हम मुख्य() फ़ंक्शन के भीतर 'पक्षियों' प्रकार के वेरिएबल 'बी' की घोषणा करते हैं। 'कबूतर' का एक उदाहरण बनाया जाता है और b = d असाइनमेंट का उपयोग करके 'b' को सौंपा जाता है। चूंकि 'कबूतर' 'पक्षियों' इंटरफ़ेस के सभी तरीकों को लागू करता है, इसलिए यह असाइनमेंट मान्य है।
फिर, ब्रीद() और फ्लाई() विधियों को 'बी' पर बुलाया जाता है जो 'पक्षी' प्रकार का है। इसी प्रकार, 'एवियन' प्रकार का एक वेरिएबल 'ए' घोषित किया जाता है और 'डी' के 'कबूतर' उदाहरण के साथ असाइन किया जाता है। चूंकि 'कबूतर' 'एवियन' इंटरफ़ेस में परिभाषित फ़ीड() विधि लागू करता है, इसलिए यह असाइनमेंट भी मान्य है। फ़ीड() विधि को 'ए' कहा जाता है जो 'एवियन' प्रकार का है। जैसा कि 'ए' में 'कबूतर' उदाहरण होता है, 'कबूतर' द्वारा कार्यान्वित फ़ीड() विधि निष्पादित की जाती है।
आउटपुट दिखाता है कि इंटरफ़ेस के तरीकों को सही ढंग से निष्पादित किया गया है:
निष्कर्ष
हमने गो इंटरफेस की मूल बातें सीखीं और उनके उपयोग को समझाने के लिए व्यावहारिक उदाहरण प्रदान किए। इंटरफेस को परिभाषित करके और उन्हें विभिन्न प्रकारों के साथ लागू करके, हम लचीले और एक्स्टेंसिबल प्रोग्राम बना सकते हैं।