इंटरफेस में

इंटरफेस के बारे में

मेथड के समूह के रूप में इंटरफेस

सबसे सरल रूप में, इंटरफेस टाइप मेथड सिग्नेचर का एक समूह होता है। यहाँ एक इंटरफेस की परिभाषा का उदाहरण है, जिसमें Add और Value नाम के दो मेथड हैं:

type Counter interface {
    Add(increment int)
    Value() int
}

इंटरफेस की परिभाषा से increment जैसे पैरामीटर के नाम हटाए जा सकते हैं, लेकिन अक्सर ये नाम पढ़ने में आसानी बढ़ा देते हैं।

Go में इंटरफेस के नाम में Interface या I शब्द नहीं होता। इसके बजाय ये अक्सर er पर खत्म होते हैं, जैसे Reader, Stringer।

इंटरफेस लागू करना

जो भी टाइप इंटरफेस के मेथड बनाता है, वह उस इंटरफेस को अपने आप लागू कर देता है। Go में implements जैसा कोई कीवर्ड नहीं होता।

नीचे दिया गया टाइप ऊपर बताए गए Counter इंटरफेस को लागू करता है।

type Stats struct {
    value int
    // ...
}

func (s Stats) Add(v int) {
    s.value += v
}

func (s Stats) Value() int {
    return s.value
}

func (s Stats) SomeOtherMethod() {
    // The type can have additional methods not mentioned in the interface.
}

इंटरफेस लागू करने के लिए इससे कोई फर्क नहीं पड़ता कि मेथड में वैल्यू रिसीवर है या पॉइंटर रिसीवर। (इनके बारे में पक्का न हो तो मेथड वाले कॉन्सेप्ट फिर से देख लीजिए।)

इंटरफेस टाइप की वैल्यू में वे सारी वैल्यू रखी जा सकती हैं जो इन मेथड को लागू करती हों। ¹

इसका मतलब है कि अब Stats का इस्तेमाल हर उस जगह किया जा सकता है जहाँ Counter इंटरफेस चाहिए।

func SetUpAnalytics(counter Counter) {
    // ...
}

stats := Stats{}
SetUpAnalytics(stats)
// works because Stats implements Counter

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

इंटरफेस अपने आप लागू हो जाते हैं, इसलिए एक टाइप आसानी से कई इंटरफेस लागू कर सकता है। उसे बस अपने सारे ज़रूरी मेथड परिभाषित करने होते हैं।

इंटरफेस को जोड़ना

इंटरफेस की परिभाषा में दूसरे इंटरफेस भी शामिल किए जा सकते हैं। यहाँ मानक लाइब्रेरी से एक उदाहरण है।

type ReadCloser interface {
	Reader
	Closer
}

// Based on these interfaces:

type Reader interface {
	Read(p []byte) (n int, err error)
}

type Closer interface {
	Close() error
}

ReadCloser बनाने के लिए Read और Close के मेथड सिग्नेचर दोबारा लिखने के बजाय, इस परिभाषा में Reader और Closer की मौजूदा परिभाषाओं का इस्तेमाल किया गया है।

खाली इंटरफेस

Go में एक बहुत खास इंटरफेस टाइप है, खाली इंटरफेस, जिसमें एक भी मेथड नहीं होता। खाली इंटरफेस ऐसे लिखा जाता है: interface{}. Go 1.18 या उससे नए वर्शन में any भी इस्तेमाल किया जा सकता है। इसे एक एलियस के तौर पर परिभाषित किया गया था।

चूँकि खाली इंटरफेस में कोई मेथड नहीं होता, इसलिए हर टाइप इसे अपने आप लागू कर देता है। यह ऐसा फंक्शन बनाने में काम आता है जो किसी भी वैल्यू को स्वीकार कर सके। ऐसे में फंक्शन के पैरामीटर के लिए खाली इंटरफेस टाइप इस्तेमाल होता है।

उदाहरण के लिए:

func AnythingGoes(i interface{}) string {
    if i == 0 {
        return "zero"
    }
    if i == "" {
        return "empty string"
    }
    return "something else"
}

1. Tour of Go: Interfaces ↩