What are generics in golang

In golang, generics is a style or paradigm of programming language, which means writing templates to adapt to all types, and defining specific variable types only when used specifically. 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 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 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 (parameters). When the function is actually used, the parameters passed in The parameters are actual parameters (argument)

Assume there is an addition function. This function has two parameters that are both of type int, 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 of type int, then the function will 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

It is not troublesome to write out the 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), use type argument (type argument) 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 formal parameters and type actual parameters allow a function to handle multiple different types of data. This programming method is called generic programming

Why are they generics?

In the previous addition example, in addition to using generics, you can also implement dynamic data type processing 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

Example of Go generics

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 type constraint )Type restrictions 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
}

[Related recommendations:

Go video tutorial

, Programming teaching】

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