What does generics mean in golang?

Generics in golang means writing templates to adapt to all types. Specific variable types are only defined when used specifically. Generics are a style or paradigm of programming languages. Generics allow programmers to use strongly typed programs in Code is written in a design language using types that are specified later and are specified as parameters during instantiation. When writing code with exactly the same logic for different types, using generics is the most appropriate choice.

The operating environment of this tutorial: Windows 10 system, go1.20.1 version, Dell G3 computer.

What are generics?

Generics means writing templates to adapt to all types, and defining specific variable types only when used specifically.

Generics are a style or paradigm of programming languages. Generics allow programmers to write code in a strongly typed programming language using types that are specified later and specified as parameters at instantiation time.

The formal parameters and actual parameters of the function

The parameters when the function is defined are formal parameters (parameter), and the parameters passed in when the function is actually used are actual parameters (argument) )

Suppose there is an addition function. The two parameters of this function are both int types, and the return value is also int; the definition is as follows:

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

If the two actual parameters passed in are int type, then the function can naturally execute normally. However, this function can only be used to perform int type addition operations. Assuming that float64 type addition operations are also needed, we need to write another function.

It’s not troublesome to write two or three types of addition calculations, just copy and paste. But if all computable types need to be added, the code will not be concise enough and will be unfriendly to read.

At this time, we will think about if a function can receive all calculation types, so that A calculation function has been written in two or three lines of code. This function can be achieved by simply defining a type combination or a placeholder without specifying a specific type when defining a function parameter.

This type combination or placeholder is the type parameter. When defining Use type parameter (type parameter), and use type argument (type argument) when actually calling

The calculation function at the beginning is converted into a type parameter function as follows:

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

By introducing the type parameter The concepts of parameters and type arguments allow a function to handle multiple different types of data. This programming method is called generic programming

Why is it generic?

In the previous addition example, in addition to using generics, dynamic data type processing can also be implemented through Go's interface reflection. The functions that generics can achieve can also be basically achieved through interface reflection. However, if you have used reflection, you will understand that the reflection mechanism has many problems:

It is troublesome to use and requires strong logical thinking to lose compilation time. Type checking, prone to bugs and poor performance

But it cannot be said that all scenarios use generics. Generics are not a panacea. Generics have corresponding applicable scenarios. You can read about Go generic designer Ian Lance Taylor published an article on the official blog website when to use generics

Summarizes the usage scenarios of generics in one sentence: When you write code with exactly the same logic for different types, then using generics is the best option. Suitable choice.

Example of Go generics

Generic functions

// 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)

Generic types

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

Declaration type restrictions ( type constraint)

Type constraints in Go are implemented through interfaces

// 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
}

The above is the detailed content of What does generics mean in golang?. For more information, please follow other related articles on the PHP Chinese website!