golang 泛型

GO1.8 之前 只支持 内置泛型，GO1.8 开始 也支持 自定义泛型。

//复杂的组合类型
matrix:=[3][4]int{
   {1,0,0,1},
   {0,1,0,1},
   {0,0,1,0},
}
matrix[1][1]=3
a:=matrix[1] //变量 a 的类型为[4]int
fmt.Println(a) // [0 3 0 1]

• **bool 是一个基类型为 另一个 指针类型*bool 的指针类型
• chan chan int 是一个元素类型 为另一个普通通道类型chan int 的通道类型
• map[int]map[int]string 是一个元素类型 为 另一个映射类型map[int]string的映射类型，键值类型都是 int
• func(int32)func(int32) 是一个输入参数和一个返回参数,键值类型都是 int
• //自定义类型
• chan *[16]byte //指针类型，数组类型，内置类型为 byte

//通道的类型例子
cy:=make(chan *[16]byte)

//go func() {}()// 三个括号
go func() {
   //使用两个数组，避免数据竞争 var dataA1,dataB1 = new([16]byte),new([16]byte) //通过 new 创建指针 for{
      _,err:=rand.Read(dataA1[:])
      if err!=nil{
         close(cy) //遍历之前需要 关闭 通道
      }else {
         cy <- dataA1 //数据推入 通道
         dataA1,dataB1=dataB1,dataA1
      }

   }

}() //这个 小口号 注意别丢了
for data:=range  cy{
   fmt.Println((*data)[:])
   time.Sleep(time.Second/2)
}

//复杂的类型
[]map[struct{
   a intb struct{
      x stringy bool
   }
}]interface{
   Build([]byte,struct{x string;y bool}) error
   Update(dt float64)Destroy()
}
// 拆解
type B= struct {
   x string
   y bool
}

type K= struct {
   a int
   b B
}
type E= interface {
   Build([]byte,B)error
   Update(dt float64)Destroy()
}
type T=[]map[K]E // 合在一起

自定义泛型

type My interface {

   int | float64 | int64 | int16 | string | bool
}
//泛型的引用
func GetMy[T My](a,b T) T{ //[T My] 自定义类型 ， (a,b T) 数据是自定义的类型，返回也是 T 自定义类型
}
//泛型的调用
var aa int =10
var bb int =20
GetMy(a,b) //编译器自动 推断传入的类型是 int
GetMy[int](a,b) //显式，告诉 传入的是 int

泛型到底是干嘛的 旨在为程序员生成代码，减少重复代码的编写

golang 无敌内置泛型

type any=interface{}  //any 表示 go 中 所有内置基本类型

type comparable interface{comparable} //comparable: 表示 go 里面所有内置的可比较类型：int、uint、float、bool、struct、指针

泛型 与 结构体 结合

type getA interface{
   int8|int16
}
   type getB interface{
   string
    }

    type User[T getA,E getB] struct{ //通过 struct 包裹
       geta T
       getb E
 }
 //方法函数  获取 getafunc(u *User[T,E])Geta()T{ //注意返回类型 T，结构体*User[T,E]的函数  return u.geta
 }
    //方法函数  获取 getbfunc(u *User[T,E])Getb()E{ //注意返回类型 E, 结构体*User[T,E]的函数
     return u.getb
     }
     //调用和使用 var uu User[int8,string] //显式给出 定义和使用
    uu.geta=18
    uu.getb="hello"

    geta:=uu.Geta()
    getb:=uu.Getb()
  
    fmt.println(geta,getb)