Was bedeutet Generika auf Golang?

Generika bedeuten in Golang, dass bestimmte Variablentypen nur dann definiert werden, wenn sie speziell verwendet werden. Generics ermöglichen es Programmierern, in stark typisierten Programmiersprachen zu schreiben die später angegeben und bei der Instanziierung als Parameter angegeben werden. Wenn Sie Code mit genau derselben Logik für verschiedene Typen schreiben, ist die Verwendung von Generika die am besten geeignete Wahl.

Die Betriebsumgebung dieses Tutorials: Windows 10-System, go1.20.1-Version, Dell G3-Computer.

Was sind Generika?

Generika bedeutet, Vorlagen zu schreiben, die sich an alle Typen anpassen, und bestimmte Variablentypen nur zu definieren, wenn sie gezielt verwendet werden.

Generika sind ein Stil oder Paradigma von Programmiersprachen. Mit Generika können Programmierer Code in einer stark typisierten Programmiersprache schreiben und dabei Typen verwenden, die später angegeben und zum Zeitpunkt der Instanziierung als Parameter angegeben werden.

Die formalen Parameter und tatsächlichen Parameter der Funktion

Die Parameter, wenn die Funktion definiert ist, sind formale Parameter (Parameter), und die Parameter, die übergeben werden, wenn die Funktion tatsächlich verwendet wird, sind tatsächliche Parameter (Argument)

Angenommen, dort ist eine Additionsfunktion. Beide Parameter sind vom Typ int und der Rückgabewert ist ebenfalls int. Die Definition lautet wie folgt:

func Test(a,b int) int {
    return a + b
}

Wenn die beiden übergebenen tatsächlichen Parameter vom Typ int sind, wird die Funktion natürlich ausgeführt normalerweise. Diese Funktion kann jedoch nur zum Ausführen von Additionsoperationen vom Typ int verwendet werden. Wenn wir auch Additionsoperationen vom Typ float64 ausführen müssen, müssen wir eine andere Funktion schreiben.

Es ist nicht mühsam, zwei oder drei Arten von Additionsberechnungen zu schreiben, einfach kopieren und einfügen. Wenn jedoch alle berechenbaren Typen hinzugefügt werden müssen, ist der Code nicht präzise genug und sehr unleserlich. Zu diesem Zeitpunkt werden wir darüber nachdenken, ob eine Funktion alle Berechnungstypen empfangen kann, also nur zwei oder drei Codezeilen Ich habe das Schreiben einer Berechnungsfunktion abgeschlossen. Diese Funktion kann durch einfaches Definieren einer Typkombination oder eines Platzhalters ohne Angabe eines bestimmten Typs beim Definieren von Funktionsparametern erreicht werden. Verwenden Sie beim Definieren von (Typparameter) Typparameter Argument) beim tatsächlichen Aufruf

Die anfängliche Berechnungsfunktion wird wie folgt in eine Typparameterfunktion umgewandelt:

// T 是一个类型形参，在定义函数时类型是不确定的，这里的 any 是 go 泛型定义好的一组类型组合
func Test[T any](a,b T) T {
    return a + b
}
// 调用时传入类型实参，伪代码Test[int](1,2)
Test(1,2)

Durch die Einführung der Konzepte von Typparametern und Typargumenten kann eine Funktion die Fähigkeit, mehrere verschiedene Datentypen zu verarbeiten, diese Programmierung Die Methode wird als generische Programmierung bezeichnet. Warum Generika? Die Funktionen, die Generika erreichen können, können grundsätzlich durch Schnittstellen + Reflexion erreicht werden. Wenn Sie jedoch Reflexion verwendet haben, werden Sie verstehen, dass der Reflexionsmechanismus viele Probleme mit sich bringt:

Die Verwendung ist mühsam und erfordert starkes logisches Denken und Kompilieren. Die Zeittypprüfung ist anfällig für Fehler und schlechte Leistung. Man kann jedoch nicht sagen, dass Generika nicht in allen Szenarien ein Allheilmittel sind. Sie können über den Go-Generika-Designer Ian Lance Taylor lesen Auf der offiziellen Blog-Website wurde ein Artikel „Wann sollten Generika verwendet werden

“ veröffentlicht, um die Verwendungsszenarien von Generika in einem Satz zusammenzufassen: Wenn Sie Code mit genau derselben Logik für verschiedene Typen schreiben, ist die Verwendung von Generika die am besten geeignete Wahl.

Beispiel für Go-GenerikaGenerische Funktionen

// Add sums the values of T. It supports string, int, int64 and float64
//
// @Description A simple additive generic function
// @Description 一个简单的加法泛型函数
// @parameter   a, b    T string | int | int64 | float64    "generics parameter"
// @return      c       T string | int | int64 | float64    "generics return"
func Add[T string | int | int64 | float64](a, b T) T {
    return a + b
}
 
// 使用
Add(1, 2)
Add(1.0,2.0)

Generische Typen

// MyChan Custom generics chan type
// 一个泛型通道，可用类型实参 int 或 string 实例化
type MyChan[T int | string] chan T

Typeinschränkungen deklarieren (Typeinschränkung)

Typeinschränkungen in Go werden über Schnittstellen implementiert

// CustomizationGenerics custom generics
//
// @Description custom generics, which are type restrictions
// @Description ~is a new symbol added to Go 1.18, and the ~ indicates that the underlying type is all types of T. ~ is pronounced astilde in English
// @Description 自定义泛型，即类型限制
// @Desciption ~ 是 Go 1.18 新增的符号，~ 表示底层类型是T的所有类型。~ 的英文读作 tilde
//
// @Example With the addition of ~, MyInt can be used, otherwise there will be type mismatch
// @Example 加上 ~，那么 MyInt 自定义的类型能够被使用，否则会类型不匹配
type CustomizationGenerics interface {
    ~int | ~int64
}

Das obige ist der detaillierte Inhalt vonWas bedeutet Generika auf Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!