Wie können Go-Funktionstypen, die Strukturen zurückgeben, für Schnittstellenimplementierungen verwendet werden?

Go-Funktionstypen, die Strukturen für Schnittstellenimplementierungen zurückgeben

Stellen Sie sich ein Szenario vor, in dem Sie eine Struktur in einem Paket mit zeitaufwändigen Methoden und Factory haben Funktion. Um diese Struktur effektiv zu testen, ist es wünschenswert, sowohl eine Fake-Factory-Funktion als auch eine Fake-Struktur zu verwenden, sobald sie erstellt wurde.

Der folgende Code veranschaulicht dies:

package expensive

import "fmt"

type myStruct struct{}

func (m *myStruct) DoSomething() {
    fmt.Println("In Do something")
}

func (m *myStruct) DoSomethingElse() {
    fmt.Println("In Do something else")
}

// CreateInstance is expensive to call
func CreateInstance() *myStruct {
    return &myStruct{}
}

In einem abhängigen Paket stellen wir eine Schnittstelle her so:

package main

import "play/expensive"

func main() {
    thing := structToConstruct{expensive.CreateInstance}
    thing.performAction()
}

type myInterface interface {
    DoSomething()
}

type structToConstruct struct {
    factoryFunction func() myInterface
}

func (s *structToConstruct) performAction() {
    instance := s.factoryFunction()
    instance.DoSomething()
}

Dieser Code löst jedoch einen Fehler aus:

.\main.go:6: cannot use expensive.CreateInstance (type func() *expensive.myStruct) as type func() myInterface in field value

Trotzdem *expensive.myStruct, das myInterface implementiert, beschwert sich Go über die Typsicherheit.

Laut dem Go-Team ist dieses Verhalten beabsichtigt:

Having a function type in a struct field that returns the underlying concrete type would violate a core principle of interfaces. That principle is that the concrete type can be replaced by any other implementation of the interface type. If the receiver type of a function were the underlying concrete type, the behavior of the function would change if called via an interface.

Die Lösung besteht darin, die Factory-Funktion zu umschließen:

wrapper := func() myInterface {
    return expensive.CreateInstance()
}
thing := structToConstruct{wrapper}

Dieser Wrapper hält sich an myInterface und der Code wird kompiliert.

Das obige ist der detaillierte Inhalt vonWie können Go-Funktionstypen, die Strukturen zurückgeben, für Schnittstellenimplementierungen verwendet werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!