Warum sind aufgrund der fehlenden Array-/Slice-Kovarianz in Go Problemumgehungen für den Umgang mit verschiedenen Sammlungstypen erforderlich?

Behebung der fehlenden Array-/Slice-Kovarianz in Go

In Go kann das Fehlen einer Array- oder Slice-Kovarianz bei der Arbeit mit zu Herausforderungen führen Sammlungen unterschiedlicher Art. Stellen Sie sich das folgende Szenario vor:

func printItems(header string, items []interface{}, fmtString string) {
  // ...
}

func main() {
  var iarr = []int{1, 2, 3}
  var farr = []float{1.0, 2.0, 3.0}
  printItems("Integer array:", iarr, "")
  printItems("Float array:", farr, "")
}

Das Fehlen von Generika in Go hindert uns daran, eine generische printItems-Funktion zu definieren, die Sammlungen jeglicher Art akzeptiert. Stattdessen stoßen wir auf den folgenden Fehler:

prog.go:26: cannot use iarr (type []int) as type []interface { } in function argument      
prog.go:27: cannot use farr (type []float) as type []interface { } in function argument

Schnittstellenbasierte Lösung

Ein gängiger Ansatz zur Überwindung dieser Einschränkung besteht darin, eine Schnittstelle zu verwenden, die das erforderliche Verhalten definiert für unsere Sammlung. In diesem Fall definieren wir eine List-Schnittstelle mit zwei Methoden, At (um ein Element an einem bestimmten Index abzurufen) und Len (um die Länge der Liste zu ermitteln):

type List interface {
    At(i int) interface{}
    Len() int
}

Wir erstellen dann konkrete Implementierungen dieser Schnittstelle für unsere Integer- und Float-Listen:

type IntList []int
type FloatList []float64

func (il IntList)   At(i int) interface{} { return il[i] }
func (fl FloatList) At(i int) interface{} { return fl[i] }

func (il IntList)   Len() int { return len(il) }
func (fl FloatList) Len() int { return len(fl) }

Mit diesen Implementierungen können wir jetzt unsere printItems-Funktion so ändern, dass sie eine Liste als Argument akzeptiert, sodass wir sowohl Integer- als auch Float-Listen drucken können Arrays:

import "fmt"

func printItems(header string, items List) {
    for i := 0; i < items.Len(); i++ {
        fmt.Print(items.At(i), " ")
    }
    fmt.Println()
}

In unserer Hauptfunktion können wir dann printItems mit unseren Integer- und Float-Listen aufrufen und so unser gewünschtes Ergebnis erzielen:

func main() {
    var iarr = []int{1, 2, 3}
    var farr = []float64{1.0, 2.0, 3.0}
    printItems("Integer array:", IntList(iarr))
    printItems("Float array:", FloatList(farr))
}

Indem wir eine Schnittstelle verwenden, um ein Common zu definieren Durch die vielen Operationen für unsere Sammlungen können wir ein gewisses Maß an Flexibilität und Wiederverwendbarkeit des Codes erreichen, obwohl es in Go keine Generika gibt.

Das obige ist der detaillierte Inhalt vonWarum sind aufgrund der fehlenden Array-/Slice-Kovarianz in Go Problemumgehungen für den Umgang mit verschiedenen Sammlungstypen erforderlich?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!