go1.18泛型实例学习【待调试版】

视频教程 https://www.bilibili.com/video/BV1ky4y1V7tJ

基本含义
  [泛型标识 泛型约束] 举例[T any]
  注意：1.17版本的泛型方法不允许暴露

泛型方法
  func F[T any](t T)(z T){}

泛型结构体
  type User[T any] struct{
      Name T
  }

泛型map
  注意key必须要定义与页数才可使用

泛型切片
  类似于泛型结构体

创建泛型约束
1、
type MyType interface{
  type int int8
}

2、同样可以通过自己实现接口来实现约束

3、type+接口混合使用

泛型结构体的泛型方法
type MyType(T any) struct {}
func (m MyType(t)) name(t T)(z T) {}
 

package main
import (
    "fmt"
    "strconv"
)

func test(i int)string{
    return strconv.Itoa(i)
}

func main() {
    fmt.Println(test(123))
}

--------方法---------

package main
import (
    "fmt"
    "strconv"
)

func test[T any](i T)T{
    return i
}

func main() {
    fmt.Println(test[string]("123")+"456")
    fmt.Println(test[int](123)+456)
}

-------结构体----------

package main
import "fmt"

func test[T any](i T)T{
    return i
}

func main() {
    fmt.Println(test[string]("123")+"456")
    fmt.Println(test[int](123)+456)
}

-------结构体----------

package main
import "fmt"

type my[A any] struct {
    Name A
}

func main() {
    m := my[string]{
        Name: "jenny",
    }
    fmt.Println(m)
}

-------map----------

package main
import "fmt"

type myC[A any] []A

func main() {
    c := myC[string]{"123","456"}
    fmt.Println(c)
}

-------切片----------

package main
import "fmt"

type MyType interfacce {
    type string,int,bool
}

type myC[K MyType,V any] map[K]V

func main() {
    c := make(myC[string,int])
    c["age"]  = 123
    fmt.Println(c)
}

-------接口-1----------

package main
import "fmt"

type MyType interfacce {
    getValue() string
}

func test[T MYType](t T) {
    fmt.Println(t.getValue())
}

type my struct {
    Name string
}

func (m my) getValue() string {
    return m.Name
}

func main() {
    m := my{Name: "奇妙"}
    z := test[my](m)
    fmt.Println(z.Name)
}

-------接口-type+接口的混合使用----------

package main
import "fmt"

type MyType interfacce {
    type int,string //方法约束为int或string类型
    getValue() string
}

func test[T MYType](t T) {
    fmt.Println(t.getValue())
}

type myStrting string

func (m myStrting) getValue() string {
    return "456"
}

func main() {
    var a string
    a = "123"
    test[myString](a)
    m := my{Name: "奇妙"}
    
}

泛型结构体的泛型方法

type MyType(T any) struct {}
func (m MyType(t)) name(t T)(z T) {}

package main
import "fmt"

type my[T any] struct {
    Name string
}

func (m my[T]) getValue(t T) T {
    return t
}

func main() {
    m := my[int]{Name: "qimiao"}
    fmt.Println(m.getValue(123)+456) //579
}