Eine vorläufige Untersuchung von Generika in Go1.18

Die Funktion, die wir heute implementieren möchten, ist: Summieren Sie alle Werte in der Karte.

Nicht-generische Funktion

Wie implementiert man sie ohne Generika? Da der Wert ohne Generika unterschiedliche Typen haben kann, z. B. int64, float64 usw., müssen unterschiedliche Typen über unterschiedliche Funktionen implementiert werden. Daher implementieren wir ihn im Allgemeinen wie folgt:

func SumInts(m map[string]int64) int64 {
    var s int64
    for _, v := range m {
        s += v
    }
    return s
}

func SumFloats(m map[string]float64) float64 {
    var s float64
    for _, v := range m {
        s += v
    }
    return s
}

Im obigen Code definieren wir Es gibt zwei Funktionen:

1. SumInts() berechnet die Summe des Wertes als Typ int64;

Die obige Funktion ist nur auf die Typen int64 und float64 anwendbar, wenn wir Ich möchte immer noch Um int, float32 usw. zu berechnen, müssen Sie die obige Funktion erneut kopieren und den Typ ändern.

Ist das nicht etwas mühsam und der Code ist sehr aufgebläht? Ganz zu schweigen davon, dass es im vorherigen Standardpaket viele ähnliche Codes gibt, wie zum Beispiel das Sort-Paket (sort.go) der Standardbibliothek. Um die Sortierung verschiedener Arten von Slices zu erreichen, werden IntSlice, Float64Slice und StringSlice definiert.

Da die vorherige Go-Version keine Generika unterstützte, kann sie nur auf diese Weise implementiert werden, was auch die einfachste Methode ist.

Wie können wir mit Generika eine Funktion implementieren, um die Summe der Werte für verschiedene Typen von int64 und float64 zu berechnen?

Generische Funktion

In diesem Abschnitt verwenden wir eine generische Funktion, um eine Karte zu implementieren, deren Wert als Parameter vom Typ int64 ist, oder eine Karte, deren Wert als Parameter vom Typ float64 ist.

Der vollständige Code lautet wie folgt:

func Sum[K comparable, V int64 | float64](m map[K]V "K comparable, V int64 | float64") V {
 var s V
 for _, v := range m {
  s += v
 }
 return s
}

func main() {
 ints := map[string]int64{
  "first":  1,
  "second": 2,
 }
 fmt.Println(Sum[string, int64](ints "string, int64"))

 floats := map[string]float64{
  "first":  35.98,
  "second": 26.99,
 }
 fmt.Println(Sum[string, float64](floats "string, float64"))
}

Im obigen Code haben wir die Sum()-Funktion definiert, bei der es sich um eine generische Funktion handelt. Sie können sehen, dass der Unterschied zu gewöhnlichen Funktionen darin besteht, dass es eine Reihe von Methoden gibt In den eckigen Klammern befinden sich neben dem Funktionsnamen und der Funktionsparameterliste auch die beiden Parameter K und V, die in der Go-Sprache als „Typparameter“ bezeichnet werden wird von der Go-Sprache vordeklariert und stellt jeden A-Typ dar, der die Operationen == und != ausführt. Die Typbeschränkung von V ist eine von int64 und float64. Der Funktionsparameter ist m, der Typ ist map[K]V und der Rückgabetyp ist V. Der Aufruf einer Funktion unterscheidet sich auch ein wenig vom Aufruf einer normalen Funktion. Zwischen dem Funktionsnamen und den tatsächlichen Parametern steht eine Reihe eckiger Klammern [], die den Typnamen angeben. Wenn beispielsweise die Funktion Sum() zum ersten Mal aufgerufen wird, lauten die Typnamen string und int64. Wenn die Funktion ausgeführt wird, lauten die entsprechenden Typen von K und V jeweils string und int64.

第二次调用该 Sum() 函数时，K、V 的类型分别是 string 和 float64。

通过泛型编程，我们就可以实现一个函数处理多种数据类型。

执行上面的代码输出：

3
62.97

Das obige ist der detaillierte Inhalt vonEine vorläufige Untersuchung von Generika in Go1.18. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!