गो में सार डेटा प्रकार के रूप में इंटरफेस

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

ऊपर वर्णित लेख में, लेखक मानक पुस्तकालय के सॉर्ट पैकेज से एक सार डेटा प्रकार के उदाहरण के रूप में इंटरफ़ेस का हवाला देता है। हालाँकि, मुझे ऐसा लगता है कि इस तरह के उदाहरण से वास्तविक अनुप्रयोगों के बारे में पता नहीं चलता है। विशेष रूप से उन अनुप्रयोगों के बारे में जो एक व्यावसायिक क्षेत्र के तर्क को लागू करते हैं या वास्तविक दुनिया की समस्याओं को हल करते हैं।

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

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

मूल का संदर्भ लें

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

package animal type Animal interface { Speaks() string } // implementation of Animal type Dog struct{} func (a Dog) Speaks() string { return "woof" } 

 package circus import "animal" func Perform(a animal.Animal) string { return a.Speaks() } 

लेखक इस दृष्टिकोण को "जावा-शैली इंटरफ़ेस उपयोग" कहता है। जब हम एक इंटरफ़ेस घोषित करते हैं, तो हम एकमात्र प्रकार और विधियों को लागू करते हैं जो इस इंटरफ़ेस को संतुष्ट करेंगे। मैं लेखक से सहमत हूं, दृष्टिकोण बहुत-सा है। मूल लेख में अधिक मुहावरेदार कोड इस प्रकार है:

 package animal // implementation of Animal type Dog struct{} func (a Dog) Speaks() string { return "woof" } 

 package circus type Speaker interface { Speaks() string } func Perform(a Speaker) string { return a.Speaks() } 

यहां, सामान्य तौर पर, सब कुछ स्पष्ट और समझने योग्य है। मूल विचार: "पहले प्रकारों की घोषणा करें, और उसके बाद ही उपयोग के बिंदु पर इंटरफेस की घोषणा करें । " यह सही है। लेकिन आइए अब थोड़ा सा विचार विकसित करें कि कैसे आप इंटरफेस को अमूर्त डेटा प्रकारों के रूप में उपयोग कर सकते हैं। लेखक, संयोग से, बताते हैं कि ऐसी स्थिति में इंटरफ़ेस "अपफ्रंट" घोषित करने में कुछ भी गलत नहीं है। हम एक ही कोड के साथ काम करेंगे।

चलिए सार के साथ खेलते हैं

तो हमारे पास एक सर्कस है और जानवर हैं। सर्कस के अंदर `परफॉर्म` नाम की एक अमूर्त पद्धति है, जो` स्पीकर` इंटरफेस लेती है और पालतू जानवरों को आवाज़ देती है। उदाहरण के लिए, वह ऊपर दिए गए उदाहरण से कुत्ते की छाल बनाएगा। एक जानवर इमली बनाएँ। चूंकि वह यहां गूंगा नहीं है, इसलिए हम आम तौर पर उसे आवाजें भी दे सकते हैं। हमारा इंटरफ़ेस काफी सार है। :)

 package circus type Tamer struct{} func (t *Tamer) Speaks() string { return "WAT?" } 

अब तक, इतना अच्छा। हम और आगे जा रहे हैं। आइए पालतू जानवरों को कमांड देने के लिए हमारा टैमर सिखाएं? अब तक, हमारे पास एक वॉइस कमांड होगी। :)

 package circus const ( ActVoice = iota ) func (t *Tamer) Command(action int, a Speaker) string { switch action { case ActVoice: return a.Speaks() } return "" } 

 package main import ( "animal" "circus" ) func main() { d := &animal.Dog{} t := &circus.Tamer{} t2 := &circus.Tamer{} t.Command(circus.ActVoice, d) // woof t.Command(circus.ActVoice, t2) // WAT? } 

मम्म, दिलचस्प है ना? ऐसा लगता है कि हमारा सहयोगी खुश नहीं है कि वह इस संदर्भ में एक पालतू जानवर बन गया? : डी क्या करना है? अध्यक्ष को लगता है कि एक अमूर्त यहाँ बहुत उपयुक्त नहीं है। हम एक अधिक उपयुक्त एक (या बल्कि, हम "गलत उदाहरण" से पहले संस्करण) में वापस आएंगे, जिसके बाद हम विधि संकेतन को बदलते हैं।

 package circus type Animal interface { Speaker } func (t *Tamer) Command(action int, a Animal) string { /* ... */ } 

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

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

वैसे, टैमर को "वॉयस" कमांड निष्पादित नहीं करने के लिए मजबूर करने के तरीकों में से एक बस एक विधि जोड़ना है जो उसके पास नहीं होना चाहिए। आइए ऐसी विधि जोड़ते हैं, यह इस बारे में जानकारी देगा कि क्या पालतू प्रशिक्षित है।

 package circus type Animal interface { Speaker IsTrained() bool } 

अब एक पालतू जानवर के स्थान पर टैमर को नहीं छोड़ा जा सकता है।

व्यवहार का विस्तार करें

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

 package animal type Dog struct{} func (d Dog) IsTrained() bool { return true } func (d Dog) Speaks() string { return "woof" } func (d Dog) Jump() string { return "jumps" } func (d Dog) Sit() string { return "sit" } type Cat struct{} func (c Cat) IsTrained() bool { return false } func (c Cat) Speaks() string { return "meow!" } func (c Cat) Jump() string { return "meow!!" } func (c Cat) Sit() string { return "meow!!!" } 

 package circus const ( ActVoice = iota ActSit ActJump ) type Animal interface { Speaker IsTrained() bool Jump() string Sit() string } func (t *Tamer) Command(action int, a Animal) string { switch action { case ActVoice: return a.Speaks() case ActSit: return a.Sit() case ActJump: return a.Jump() } return "" } 

महान, अब हम अपने जानवरों को अलग-अलग कमांड दे सकते हैं, और उन्हें बाहर ले जाएंगे। एक डिग्री या किसी अन्य के लिए ...: डी

 package main import ( "animal" "circus" ) func main() { t := &circus.Tamer{} d := &animal.Dog{} t.Command(circus.ActVoice, d) // "woof" t.Command(circus.ActJump, d) // "jumps" t.Command(circus.ActSit, d) // "sit" t2 := &circus.Tamer{} c := &animal.Cat{} t2.Command(circus.ActVoice, c) // "meow" t2.Command(circus.ActJump, c) // "meow!!" t2.Command(circus.ActSit, c) // "meow!!!" } 

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

 package circus func (t *Tamer) Command(action int, a Animal) string { if !a.IsTrained() { panic("Sorry but this animal doesn't understand your commands") } // ... } 

यही बेहतर है। प्रारंभिक पशु इंटरफ़ेस के विपरीत, जो स्पीकर को डुप्लिकेट करता है, अब हमारे पास `Animal` इंटरफ़ेस (जो अनिवार्य रूप से एक सार डेटा प्रकार है) जो काफी सार्थक व्यवहार को लागू करता है।

आइए इंटरफ़ेस आकारों पर चर्चा करें

अब हम व्यापक इंटरफेस का उपयोग करने जैसी समस्या पर विचार करते हैं।

यह एक ऐसी स्थिति है जिसमें हम बड़ी संख्या में तरीकों के साथ इंटरफेस का उपयोग करते हैं। इस मामले में, सिफारिश कुछ इस तरह है: "कार्यों को उन तरीकों से इंटरफेस को स्वीकार करना चाहिए जिनकी आवश्यकता है । "

सामान्य तौर पर, मैं मानता हूं कि इंटरफेस छोटा होना चाहिए, लेकिन इस मामले में, संदर्भ फिर से मायने रखता है। आइए अपने कोड पर वापस जाएं और अपने पालतू जानवरों को " पालतू " की प्रशंसा करें ।

प्रशंसा के जवाब में, पालतू एक आवाज डालेगा।

 package circus func (t *Tamer) Praise(a Speaker) string { return a.Speaks() } 

ऐसा लगता है कि सब कुछ ठीक है, हम न्यूनतम आवश्यक इंटरफ़ेस का उपयोग करते हैं। अतिशय कुछ भी नहीं है। लेकिन यहाँ फिर से समस्या है। लानत है, अब हम दूसरे कोच की "प्रशंसा" कर सकते हैं और वह "आवाज देगा" । : D इसे पकड़ो? .. संदर्भ हमेशा मायने रखता है।

 package main import ( "animal" "circus" ) func main() { t := &circus.Tamer{} t2 := &circus.Tamer{} d := &animal.Dog{} c := &animal.Cat{} t.Praise(d) // woof t.Praise(c) // meow! t.Praise(t2) // WAT? } 

मैं क्यों हूँ? इस मामले में, सबसे अच्छा समाधान अभी भी एक व्यापक इंटरफ़ेस ( "पालतू" सार डेटा प्रकार का प्रतिनिधित्व) का उपयोग करना होगा। चूंकि हम सीखना चाहते हैं कि किसी पालतू जानवर की प्रशंसा कैसे करें, न कि कोई प्राणी जो आवाज लगा सकता है।

 package circus // Now we are using Animal interface here. func (t *Tamer) Praise(a Animal) string { return a.Speaks() } 

इतना बेहतर है। हम पालतू पशु की प्रशंसा कर सकते हैं, लेकिन हम ताम्र की प्रशंसा नहीं कर सकते। कोड फिर से सरल और अधिक स्पष्ट हो गया।

अब थोड़ा बेड के कानून के बारे में

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

लेखक खुद कानून का हवाला देता है:।

"आप जो करते हैं, उसके साथ रूढ़िवादी रहें, स्वीकार करने के साथ उदार बनें"

और इसे गो भाषा के संबंध में व्याख्या करता है

"जाओ": "इंटरफेस स्वीकार करें, वापसी संरचना"

func funcName(a INTERFACETYPE) CONCRETETYPE

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

यहाँ एक छोटा सा उदाहरण है। एक हाथी पास के "अफ्रीकी" सर्कस में दिखाई दिया, और आपने सर्कस मालिकों को एक नए शो में एक हाथी को उधार देने के लिए कहा। आपके लिए, इस मामले में यह महत्वपूर्ण है, केवल यह है कि हाथी अन्य पालतू जानवरों के समान सभी आदेशों को निष्पादित कर सकता है। एक हाथी का आकार या इस संदर्भ में एक ट्रंक की उपस्थिति कोई फर्क नहीं पड़ता।

 package african import "circus" type Elephant struct{} func (e Elephant) Speaks() string { return "pawoo!" } func (e Elephant) Jump() string { return "o_O" } func (e Elephant) Sit() string { return "sit" } func (e Elephant) IsTrained() bool { return true } func GetElephant() circus.Animal { return &Elephant{} } 

 package main import ( "african" "circus" ) func main() { t := &circus.Tamer{} e := african.GetElephant() t.Command(circus.ActVoice, e) // "pawoo!" t.Command(circus.ActJump, e) // "o_O" t.Command(circus.ActSit, e) // "sit" } 

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

संक्षेप में देना

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

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

मुख्य बात, दोस्तों, यह है कि आप लगातार विकास करते हैं और काम से सच्चा आनंद प्राप्त करते हैं। सभी को अच्छा!

पुनश्च। नमूना कोड और अंतिम संस्करण GitHub पर पाया जा सकता है ।