Hoe controleer je of een structuur voldoet aan een interface in Go?

In Go wordt de overeenstemming van een structuur met een interface impliciet gecontroleerd tijdens de compilatie. Als de structuur alle methoden implementeert die door de interface vereist zijn, wordt deze automatisch als compatibel met die interface beschouwd. Het is niet nodig om expliciet de overeenstemming aan te geven.

Je kunt de volgende methoden gebruiken om de compatibiliteit tijdens de compilatie te controleren:

1. Toewijzen van de structuur aan een variabele van het type interface.
2. De structuur doorgeven aan een functie die een argument van het type interface verwacht.

Voorbeeld met toewijzing:

// Definieer de interface
type MyInterface interface {
	DoSomething()
	GetValue() int
}

// Definieer de structuur die aan de interface moet voldoen
type MyStruct struct {
	value int
}

// Methoden van de structuur die de interface implementeren
func (s MyStruct) DoSomething() {
	// logica
}

func (s MyStruct) GetValue() int {
	return s.value
}

// Controleer de compatibiliteit tijdens de compilatie:
// Wijs een instantie van de structuur toe aan een variabele van het interface-type.
// Als MyStruct de MyInterface niet implementeert, geeft de compiler een fout.
var _ MyInterface = MyStruct{}

Voorbeeld met doorgeven aan een functie:

// Functie die een argument van het type interface MyInterface accepteert
func Process(item MyInterface) {
	item.DoSomething()
	_ = item.GetValue() // gebruik de waarde
}

// Op een andere plek in de code:
// Maak een instantie van MyStruct
myInstance := MyStruct{value: 42}

// Geef de structuur door aan een functie die de interface verwacht.
// Als MyStruct de MyInterface niet implementeert, geeft de compiler een fout.
Process(myInstance)

Deze benaderingen garanderen dat de structuur voldoet aan de gedefinieerde interface nog voordat het programma wordt uitgevoerd, wat een belangrijk aspect is van typeveiligheid in Go.