What are generics in go language

In the Go language, generics means writing templates to adapt to all types, and defining specific variable types only when they are specifically used; by introducing the concepts of type formal parameters and type actual parameters, a function can handle a variety of The ability to program data of different types is called generic programming.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

Go 1.18 version adds a new feature: support for generic programming.

If you are a developer from other languages ​​to Go language, can you understand what generics are and how to use them?

But for those who are just beginners of Go language and have not been exposed to generic programming, this function may be confusing.

This article hopes that people who are not familiar with generic programming can also understand and use Go's generics well

A general guideline for programming Go: write Go programs by writing code, not by defining types
General principles of Go programming: write Go programs by writing code, not by defining types

What are generics?

---

Generics are to write templates to adapt to all types, and only define specific variable types when used specifically

Function The formal parameters and actual parameters

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 a Addition function, this function has two parameters that are both of type int, and the return value is also int; it is defined as follows:

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

If the two actual parameters passed in are both It is of type int, then the function can naturally execute normally. However, this function can only be used to perform addition operations of type int. If we also need to perform addition operations of type float64, we need to write another function. [Related recommendations: Go video tutorial, Programming teaching]

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

At this time, we will think about if a function can receive all calculation types, then it will only take two or three lines of code to write a calculation function. This function can be achieved by simply defining a type combination or a placeholder without specifying a specific type when defining function parameters.

This type combination or placeholder is the type parameter. The type parameter is used when defining, and the type argument is used when actually calling.

The initial calculation function 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 concepts of type parameter and type actual parameter, The ability to allow a function to handle multiple different types of data is called Generic programming

Why are they 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.
• Loss of compile-time type checking, prone to bugs
• Poor performance

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

## To summarize the usage scenarios of generics: When you write code with exactly the same logic for different types, then using generics is the most appropriate choice

Go Generics Type example

---

##Generic function

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

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

Declaration of type constraints (type constraint)Type constraints in Go are passed Interface Implementation

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

For more programming-related knowledge, please visit:

Programming Video

! !

The above is the detailed content of What are generics in go language. For more information, please follow other related articles on the PHP Chinese website!