विभिन्न पैकेजों में समान विधि हस्ताक्षरों के साथ इंटरफेस को संभालना

गो में, एक ही विधि हस्ताक्षर के साथ लेकिन अलग-अलग पैकेजों में परिभाषित कई इंटरफेस के साथ काम करते समय, ऐसी स्थितियां उत्पन्न हो सकती हैं जहां दोनों इंटरफेस को लागू करने वाला एक प्रकार अप्रत्याशित व्यवहार की ओर ले जाता है। Doer इंटरफ़ेस टाइप करें { Do() स्ट्रिंग } func FuncA(कर्ता कर्ता) // पैकेज बी Doer इंटरफ़ेस टाइप करें { Do() स्ट्रिंग } func FuncB(कर्ता कर्ता)

यदि एक प्रकार सी दोनों पैकेजों से कर्ता को लागू करता है और कार्यान्वयन भिन्न होता है:

// Package A
type Doer interface { Do() string }
func FuncA(doer Doer)

// Package B
type Doer interface { Do() string }
func FuncB(doer Doer)

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

// Package main
type C int
func (c C) Do() string { return "A-specific implementation" }

func main() {
    cA := C(0); A.FuncA(cA)
    cB := C(0); B.FuncB(cB) // Behavior differs due to varying `Do()` implementations
}

// पैकेज मुख्य DoerA संरचना टाइप करें { C C } func (d DoerA) Do() स्ट्रिंग {वापसी "ए-विशिष्ट कार्यान्वयन" } DoerB संरचना टाइप करें { C C } func (d DoerB) Do() स्ट्रिंग {वापसी "बी-विशिष्ट कार्यान्वयन" } func मुख्य() { cA := DoerA{C(0)}; A.FuncA(cA) cB := DoerB{C(0)}; B.FuncB(cB) // अलग-अलग कार्यान्वयन के साथ सही व्यवहार }

इन रैपर्स को बनाकर, आप संबंधित पैकेज संदर्भों में स्थिरता सुनिश्चित करते हुए, इच्छित इंटरफ़ेस उपयोग के आधार पर Do() के कार्यान्वयन को नियंत्रित कर सकते हैं।