泛型函数

定义一个加法函数，如果调用传参类型不符会报错

go
func plus(n1, n2 int) int {
  return n1 + n2
}
func main() {
  res := plus(1, 2)
  println(res)
  var u1 ,u2 =uint(2), uint(3)
  plus(u1,u2)
}
image-20260420171435323

使用泛型，这里的T是占位符

go
func plus[T int | uint](n1, n2 T) T {
  return n1 + n2
}

多个泛型

go
func myPrint[T int, K string | int](n1 T, n2 K) {


}

如果比较多的情况使用interface

go
type Number interface {
  int | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | uint
}
func myPrint[T int, K string | Number](n1 T, n2 K) {


}

泛型结构体

假设一个响应的结构体序列化

go
type Response struct {
  Code int    `json:"code"`
  Msg  string `json:"msg"`
  Data any    `json:"data"`
}
type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
  }


  res := Response{
    Code: 1001,
    Msg:  "成功",
    Data: User{
      Name: "张三",
      Age:  18,
    },
  }
  byteData, _ := json.Marshal(res)
  fmt.Println(string(byteData))
bash
{"code":1001,"msg":"成功","data":{"name":"张三","age":18}}

假设两个json序列化

go
  type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
  }
  type UserInfo struct {
    Name   string `json:"name"`
    Gender string `json:"gender"`
  }


  user := Response{
    Code: 1001,
    Msg:  "成功",
    Data: User{
      Name: "张三",
      Age:  18,
    },
  }
  //json序列化
  byteData, _ := json.Marshal(user)
  fmt.Println(string(byteData))
  userInfo := Response{
    Code: 1001,
    Msg:  "成功",
    Data: UserInfo{
      Name:   "张三",
      Gender: "男",
    },
  }
  //json序列化
  byteData, _ = json.Marshal(userInfo)
  fmt.Println(string(byteData))
bash
{"code":1001,"msg":"成功","data":{"name":"张三","age":18}}
{"code":1001,"msg":"成功","data":{"name":"张三","gender":"男"}}

反序列化

go
var user Response
json.Unmarshal([]byte(`{"code":1001,"msg":"成功","data":{"name":"张三","age":18}}`), &user)
fmt.Println(user)
bash
{1001 成功 map[age:18 name:张三]}

注意：json.Unmarshal的第二个参数要带指针

可以看到，此时data是map，并不能使用.语法

image-20260421145945226

解决办法，Response的Data就不能写成any类型了

go
type Response[T any] struct {
  Code int    `json:"code"`
  Msg  string `json:"msg"`
  Data T      `json:"data"`
}

指定反序列化的类型

go
var user Response[User]
  json.Unmarshal([]byte(`{"code":1001,"msg":"成功","data":{"name":"张三","age":18}}`), &user)
fmt.Println(user) //{1001 成功 {张三 18}}

此时就能使用.语法了

image-20260421150738896
go
  var user Response[User]
  json.Unmarshal([]byte(`{"code":1001,"msg":"成功","data":{"name":"张三","age":18}}`), &user)
  fmt.Println(user) //{1001 成功 {张三 18}}
  var userInfo Response[UserInfo]
  json.Unmarshal([]byte(`{"code":1001,"msg":"成功","data":{"name":"张三","gender":"男"}}`), &userInfo)
  fmt.Println(userInfo) //{1001 成功 {张三 男}}

泛型切片

go
  type MySlice[T int | string] []T
  var mySlice = MySlice[int]{1, 2, 3}

泛型map

go
  type MyMap[K string, V int | string] map[K]V
  var myMap = MyMap[string, int]{"a": 1, "b": 2}