Generika in Go erklärt. | Komentor

Beginnen Sie hier mit dem Schreiben… In der Programmierung bezieht sich der Begriff Generika auf die Fähigkeit, eine Variable, Methode, Funktion oder einen Typ, der normalerweise für einen einzelnen Datentyp bestimmt wäre, für mehrere Typen zu verwenden.

Ab März 2022 unterstützt die Go-Version 1.18 jetzt Generika. Dies ist eine Funktion, von der viele Go-Entwickler gehofft hatten, dass sie zu Go kommen würde, und es muss eine festliche Jahreszeit für uns gewesen sein, als sie angekündigt wurde. Vor dieser monumentalen Ankündigung gab es verschiedene Techniken, mit denen kluge Leute Generika in Go implementiert hatten; Fühlen Sie sich frei, andere Ressourcen zu verwenden, wenn es darum geht, mehr Verständnis zu erlangen. Am Ende dieses Beitrags verstehen Sie die grundlegenden Techniken zur Implementierung von Generika in Go.

Voraussetzung

Vorerfahrungen mit Go sind hilfreich, um diesem Beitrag zu folgen.

Generische Implementierung

Generics in Go können auf Funktionen und Typen implementiert werden. Bei Funktionen sehen Personen mit vorherigem Verständnis von Methodenempfängern möglicherweise eine strukturelle Ähnlichkeit mit der Definition generischer Funktionen.

func Index[T comparable](s []T, x T) int

Abbildung A – Implementierung einer generischen Funktion

func (st SomeType) Index(pts []ParamType, pt ParamType) int

Abbildung B – Methodenempfängerimplementierung für den Typ SomeType

Bei Methodenempfängern steht der Subjekttyp in Klammern und steht vor dem Methodennamen, während generische Funktionen ihren Subjekttyp in eckigen Klammern und unmittelbar nach dem Namen der Funktion definieren. Ich habe den Begriff „Thementyp“, aber Sie werden feststellen, dass es meistens „Typparameter“.

In Abbildung A ist der Typ „T“ ist der generische Typ, der die eingebaute Einschränkung „vergleichbar“ erfüllt. Diese vorherige Definition des Typparameters ermöglicht es uns, Funktionsparameter zu definieren, die „T“ als Typ. Wir können also sagen, dass s ein Slice vom Typ T und x eine Variable vom Typ T ist.

Obwohl wir unseren generischen Typ definiert haben als „T“, idealerweise kann jedes Großbuchstabe-Alphabet für seine Darstellung verwendet werden.

Die eingebauten Vergleichsbeschränkungen ermöglichen die Verwendung der booleschen Gleichheit (==) oder boolesche Ungleichung (!=). Der folgende Quellcode ist aus einer Tour von go extrahiert:

package main
import “fmt”
// Index returns the index of x in s, or -1 if not found.
func Index[T comparable](s []T, x T) int {
   for i, v := range s {
       // v and x are type T, which has the comparable
       // constraint, so we can use == here.
       if v == x {
          return i
       }
    }
   
   return -1
}
func main() {
   // Index works on a slice of ints
   si := []int{10, 20, 15, -10}
   fmt.Println(Index(si, 15))
  // Index also works on a slice of strings
   ss := []string{“foo”, “bar”, “baz”}
}

Abbildung C – Eine Tour durch das generische Funktionsbeispiel von Go

Parameter für mehrere Funktionstypen

Eine generische Funktion kann auch mehrere Typparameter haben.

func Index[T comparable, K comparable](s []T, x T, y K)

Abbildung D.0 – Generische Funktion mit mehreren Typparametern

package main
import “fmt”
// Index demonstrates multiple type parameters
func Index[T comparable, K comparable](s []T, x T, y K) {
   for _, v := range s {
       fmt.Println(y)
       fmt.Println(v)
       fmt.Println(x)
       fmt.Println(x != v)
       fmt.Println(y)
   }
}
func main() {
   // Index works on a slice of ints and a third
   // parameter of type string
   si := []int{10, 20, 15, -10}
   Index(si, 15, “ — - ”)
   // Index also works on a slice of strings and a third 
   // parameter of type int
   ss := []string{“foo”, “bar”, “baz”}
   Index(ss, “hello”, 4)
}

Abbildung D.1 – Ein Beispiel einer generischen Funktion mit mehreren Typparametern

Eine weitere eingebaute Einschränkung, die wir verwenden können, ist „irgendein“. Es wird meistens verwendet, wenn Sie keine boolesche Gleichheit ausführen müssen (==) oder boolesche Ungleichung (!=) Operationen für den generischen Typ.

func Index[T any](s []T, x T) int

Abbildung E.0 – Funktionsgenerika mit eingebauter „beliebiger“ Einschränkung

Generische implizite Typen

Go unterstützt auch das Erstellen generischer Typen. Ein Typ kann wie unten gezeigt mit einem Typparameter parametriert werden.

package main
import "fmt"
type SomeType[T any] struct {
   next *SomeType[T]
   value T
}
func main() {
   // SomeType works on a singly-linked list of integers  
   sti := &SomeType[int]{ value: 5};
   fmt.Println(sti)
   // SomeType works on a singly-linked list of strings
   sts := &SomeType[string]{value: "John Doe"}
   fmt.Println(sts)
}

Zusammenfassung

In diesem Beitrag haben wir Funktions- und Typ-Generika in Go besprochen. Wir haben gesehen, wie „vergleichbarDie eingebaute Einschränkung bietet boolesche Operationen für Typen.

Wenn diese Unterrichtsmethode nützlich war, können Sie sie zum Nutzen Ihrer Freunde über Ihre Social-Media-Konten teilen. Um Kontakt aufzunehmen, besuchen Sie

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *