The core role of generics in Go 1.18 is to adapt multiple types through a single copy of code to reduce duplicate logic. 1. Generics allow the definition of type parameters so that functions or structures can handle different data types; 2. Typical usages such as merging SumInts and SumFloats into a Sum function; 3. Type constraints restrict available types, such as using int | float64 or any to accept any types; 4. Practical scenarios include implementations of general data structures such as stacks; 5. When using them, be careful to avoid over-dependence on any to maintain type safety. Understanding generics can help improve code reusability and maintenance.

Go generics start from scratch: simple usage and practical scenarios

After the introduction of generics in Go 1.18, many people thought it "looks useful", but they didn't know when or how to use them. In fact, the core goal of generics is to write a copy of code and adapt to multiple types . Not all places are required for generics, but using them where they are suitable can significantly reduce duplicate logic.

What is a generic? Why do you need it?

Generics are not a new concept, they have existed in languages such as Java and C#. Go's generic design is relatively concise, mainly to solve a pain point: the repetition problem of functions or structures when dealing with different types .

For example, you wrote a SumInts function to calculate the sum of integer slices, and then wrote a SumFloats to calculate the sum of floating-point slices. They are logically the same, but the types are different. At this time, you can use generics to merge these two functions into one.

How to define a generic function?

The key to defining a generic function is to introduce type parameters, put them after the function name, and wrap them in square brackets.

 func Sum[T int | float64](nums []T) T {
    var total T
    for _, num := range nums {
        total = num
    }
    Return total
}

This code means:

• T is a type parameter
• T can be int or float64
• The function can use T like normal types

The call method is also very intuitive:

 ints := []int{1, 2, 3}
fmt.Println(Sum(ints)) // Output 6

floats := []float64{1.5, 2.5, 3.0}
fmt.Println(Sum(floats)) // Output 7

Note: Go does not support automatic type derivation to all cases, sometimes you may need to explicitly specify type parameters, such as Sum[int](...) .

Type constraints and the use of any

In Go generics, we use "type constraints" to limit the types that are allowed to be passed in. For example, the previous example uses int | float64 , which means that only these two types are accepted.

If you want the function to accept any type, you can use any (actually the alias for interface{} ):

 func PrintAll[T any](items []T) {
    for _, item := range items {
        fmt.Println(item)
    }
}

This function can print any type of slice content.

But be careful that once you use any , you lose control of the specific type, and you cannot do addition, subtraction, multiplication and division operations. It is recommended only when specific behavior is not required.

Example of practical scenarios: general data structure

One of the most common uses of generics is to build common data structures. For example, you can write a general stack structure:

 type Stack[T any] struct {
    Items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() T {
    if len(s.items) == 0 {
        var zero T
        return zero
    }
    last := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return last
}

Then you can use:

 s := Stack[int]{}
s.Push(1)
s.Push(2)
fmt.Println(s.Pop()) // Output 2

The advantage of this writing is that it does not require the logic to be implemented separately for each type.

Basically that's it. Generics are not master keys, but it does solve the problem of duplicate code. It may be a bit tangled when you first contact, especially the type constraint piece. It is recommended to start with simple examples, such as generic functions, and then gradually try generic structures and interfaces. As long as you understand how type parameters work, many problems can be solved easily.

The above is the detailed content of Go generics tutorial. For more information, please follow other related articles on the PHP Chinese website!