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

मान लीजिए कि आपको परस्पर विरोधी विधि हस्ताक्षरों के साथ अलग-अलग पैकेजों में परिभाषित इंटरफेस लागू करने की आवश्यकता है . यह चुनौतीपूर्ण हो सकता है, लेकिन गो एक समाधान प्रदान करता है।

आइए एक उदाहरण पर विचार करें:

• पैकेज ए में:

  package A
  
  type Doer interface {
    Do() string
  }
  
  func FuncA(doer A.Doer) {
    // Use doer.Do() here to implement functionality
  }

• पैकेज बी में:

  package B
  
  type Doer interface {
    Do() string
  }
  
  func FuncB(doer B.Doer) {
    // Use doer.Do() here to implement functionality
  }

आपके मुख्य पैकेज में:

package main

import (
    "path/to/A"
    "path/to/B"
)

type C int

// C implements both A.Doer and B.Doer, but the implementation of Do() aligns with A.
func (c C) Do() string {
    return "C implements both A and B"
}

func main() {
    c := C(0)
    A.FuncA(c) // Acceptable as C implements A.Doer
    B.FuncB(c) // Error, as the Do() implementation in C doesn't meet B.Doer requirements
}

समाधान:

इस संघर्ष को हल करने के लिए, गो एक संक्षिप्त दृष्टिकोण प्रदान करता है:

if _, ok := obj.(A.Doer); ok {
}

यह आपको यह सत्यापित करने की अनुमति देता है कि कोई ऑब्जेक्ट (इंटरफ़ेस प्रकार का) रनटाइम पर किसी अन्य इंटरफ़ेस प्रकार (उदाहरण के लिए, ए.डॉयर) के अनुरूप है या नहीं।

हालांकि, ओपी एक और जटिलता पर प्रकाश डालता है : पैकेज ए और पैकेज बी में डू() के लिए लागू तर्क अलग है। इसे संबोधित करने के लिए, अपने ऑब्जेक्ट के चारों ओर रैपर बनाएं:

• DoerA को C के साथ एक फ़ील्ड के रूप में लागू करें, A.Do() को तार्किक रूप से लागू करें।
• DoerB को C के साथ एक फ़ील्ड के रूप में लागू करें, B को लागू करें। Do() तार्किक रूप से करें।

अलग-अलग रैपर लागू करके, आप अपेक्षित इंटरफ़ेस प्रकार (A.Doer या B.Doer) के आधार पर उपयोग करने के लिए किस विधि को नियंत्रित कर सकते हैं। यह मूल C ऑब्जेक्ट पर एकल Do() विधि की आवश्यकता को समाप्त कर देता है, जो दोनों तर्कों को लागू करने के लिए संघर्ष करेगा।