Go generics are supported since 1.18 and are used to write generic code for type-safe. 1. The generic function PrintSlice[T any](s []T) can print slices of any type, such as []int or []string. 2. Through type constraint Number limits T to numeric types such as int and float, implement Sum[T Number](slice []T) T safe summation. 3. Generic structure type Box[T any] struct { Value T } can encapsulate any type value and be used with the NewBox[T any](v T) *Box[T] constructor. 4. Add Set(v T) and Get() T methods to Box[T], without repeatedly declaring [T] in the method. 5. Multi-type parameter function ContainsValue[K comparable, V any](m map[K]V, value V) bool determines whether there is a certain value in the map, and K needs to be compared. 6. Practical applications such as the general cache type Cache[K comparable, V any] struct { data map[K]V }, providing Set and Get operations to implement type-safe key-value storage. Generics improve code reusability and security through type parameters, constraints, and union types, and the syntax is concise and practical.

Generics for Go have been officially supported since Go 1.18, which allows you to write common functions and data structures that can handle multiple types. The following are several typical Go generic examples to help you quickly understand how to use generics in practice.

? 1. Generic function: PrintSlice[T any]

If you want to print any type of slice content, such as []int and []string , you can write a generic function:

 func PrintSlice[T any](s []T) {
    for _, v := range s {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

// Use example PrintSlice([]int{1, 2, 3}) // Output: 1 2 3
PrintSlice([]string{"a", "b"}) // Output: ab

• [T any] means that the type parameter T can be of any type.
• any is an alias for interface{} , indicating no constraints.

? 2. Generic functions: with type constraints (Constraint)

If you want to restrict types, such as only numeric types are allowed, you can define constraints:

 type Number interface {
    int | int32 | int64 | float32 | float64
}

func Sum[T Number](slice []T) T {
    var total T
    for _, v := range slice {
        total = v
    }
    Return total
}

// Use fmt.Println(Sum([]int{1, 2, 3})) // 6
fmt.Println(Sum([]float64{1.1, 2.2})) // 3.3

• Number is an interface type, which uses | to represent union type (union), and limit T must be one of the listed types.
• This prevents you from passing string or struct etc. from not supporting Type of operation.

? 3. Generic structure

Define a common Box container that can hold any type of value:

 type Box[T any] struct {
    Value T
}

func NewBox[T any](v T) *Box[T] {
    return &Box[T]{Value: v}
}

// Use intBox := NewBox(42)
strBox := NewBox("hello")

fmt.Println(intBox.Value) // 42
fmt.Println(strBox.Value) // hello

• Box[T] is a generic structure.
• NewBox is a generic constructor that automatically deduces types.

? 4. Generic Methods

Add methods to generic structures:

 func (b *Box[T]) Set(v T) {
    b.Value = v
}

func (b *Box[T]) Get() T {
    return b.Value
}

// Use box := NewBox(100)
box.Set(200)
fmt.Println(box.Get()) // 200

The method itself does not need to declare [T] because it already belongs to Box[T] type.

? 5. Generics and Map: Find key values

Write a general function to find if a value exists in the map:

 func ContainsValue[K comparable, V any](m map[K]V, value V) bool {
    for _, v := range m {
        if v == value {
            return true
        }
    }
    return false
}

// Use m := map[string]int{"a": 1, "b": 2}
fmt.Println(ContainsValue(m, 2)) // true
fmt.Println(ContainsValue(m, 3)) // false

• K comparable : The key type must be comparable (such as string, int, struct, etc.).
• V any : The value can be of any type.
• Multiple type parameters are separated by commas.

? 6. Practical application scenarios: general cache

You can implement a simple cache structure using generics:

 type Cache[K comparable, V any] struct {
    data map[K]V
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        data: make(map[K]V),
    }
}

func (c *Cache[K, V]) Set(key K, value V) {
    c.data[key] = value
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    v, ok := c.data[key]
    return v, ok
}

use:

 cache := NewCache[string, int]()
cache.Set("users", 100)
if val, ok := cache.Get("users"); ok {
    fmt.Println("Count:", val)
}

Summary: Key points of generics

• Use [T any] or [T Constraint] to define type parameters.
• comparable is a predefined constraint for comparable types (for map key, == judgment, etc.).
• Union types ( | ) can restrict type collections.
• Generics make functions and structures more general, type-safe, and reduce duplicate code.

Basically that's it. Go generics do not pursue complexity, but emphasize practicality and clarity. When you first use it, you will feel that the grammar is a bit new, but after writing a few examples, you will feel quite natural.

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