How to use generics to solve common problems in golang?

Generics in Go can solve common pain points: Type conversion: Use generic functions to simplify conversions of different types. Data structure creation: Use generic types to simplify the creation of common data structures. Function passing: Using generic function declarations allows passing parameters of various types. Practical cases: Demonstrate the application of generics in practical problems through examples such as type safety mapping, thereby improving code versatility, flexibility and type safety.

How to use generics to solve common problems in Go

In the Go 1.18 version, generics were officially introduced. Allows us to write more general and type-safe code without compromising performance. This article explores how to use generics to solve common pain points in Go.

Type Conversion

In Go, type conversion often requires the use of type conversion, which is error-prone and inelegant. Generics allow us to create generic functions to handle different types of conversions, as shown below:

func Convert[T any](i T) T {
  // i 中的值将被转换为 T 类型
  return i
}

func main() {
  i := 5
  j := Convert(i) // j 是 int 类型
  fmt.Println(j) // 输出: 5
}

Data Structure

Creating generic data structures requires writing a lot of boilerplate code . Generics can simplify this process:

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

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

func main() {
  stack := Stack[int]{}
  stack.Push(5)
}

Function passing

Function in Go can only pass parameters of a specific type, which limits the flexibility of the code. Generics allow us to declare functions as generic so that they can handle various types of parameters:

func Sort[T comparable](s []T) {
  sort.Slice(s, func(i, j int) bool {
    return s[i] < s[j]
  })
}

func main() {
  ints := []int{5, 2, 8, 1}
  Sort(ints) // ints 被排序为 [1, 2, 5, 8]
}

Practical Case

The following are practical problems solved with generics Example of:

Type-safe mapping

Create a type-safe map to store key-value pairs of different types:

type Map[K comparable, V any] map[K]V

func main() {
  m := Map[string, int]{
    "one": 1,
    "two": 2,
  }

  // 编译时检查类型安全性
  fmt.Println(m["one"]) // 1
  fmt.Println(m[1])    // 编译错误，类型不匹配
}

By using generics , we can write more general and flexible code in Go while maintaining type safety and performance.

The above is the detailed content of How to use generics to solve common problems in golang?. For more information, please follow other related articles on the PHP Chinese website!