go 泛型

Go泛型语法

符号 ~

~int 代表泛型参数支持底层是int类型的所有类型 如: type Int int 中的Int
go定义类型type Type 类型，构建出新类型
go定义别名type Type = 类型，和原有的类型一致

符号 |

取并集的意思

method

package main

import "fmt"

func Sum[T uint | ~int | ~float64 | ~string](args []T) T {
	var sum T
	for _, v := range args {
		sum += v
	}
	return sum
}

type Int int

func main() {
	fmt.Println(Sum[uint]([]uint{1, 2, 3, 4, 5}))
	fmt.Println(Sum[int]([]int{1, 2, 3, 4, 5}))
	fmt.Println(Sum[int]([]int{1, 2, 3, 4, 5}))
	fmt.Println(Sum([]Int{1, 2, 3, 4, 5, 6})) // 支持简单的类型推断,Sum后不用写[Int]
	fmt.Println(Sum([]string{"hello", " ", "world"}))
}

泛型约束 与 约束组合

go支持interface嵌套，struct嵌套，新加入的any接口是interface{}接口的别名

type i1 interface {}
type i2 interface {}
type i3 interface {
	i1
	i2
}

package main

import "fmt"

type Int8 interface {
	~uint8 | ~int8
}

type Addable interface {
	Int8 | ~int32 | ~int64 | ~int
}

func Sum[T Addable](args []T) T {
	var sum T
	for _, v := range args {
		sum += v
	}
	return sum
}

func main() {
	fmt.Println(Sum([]int{1, 2, 3, 4, 5, 6}))
}

type Tmp[T ~int | ~string] int	
var t Tmp[string] //这里只是约束
//t = "hello" //已经确定了int类型，那么赋值string
t = 123     //可正常赋值
fmt.Println(t)

interface

package main

import "fmt"

type TalkAble[IN, OUT any] interface {
	Talk(data IN) OUT
}

type Person[IN, OUT any] struct {
	Name string
}

func (a *Person[IN, OUT]) Talk(data IN) string {
	return fmt.Sprint(a.Name, "说: ", data)
}

func main() {
	var p TalkAble[string, string] = &Person[string, string]{Name: "张三"}
	fmt.Println(p.Talk("hello"))
}

//(a *Person[IN, OUT]) IN 和 OUT只是一个类型标记，在符合变量命名规则的前提下，可以任意命名

struct & function

package main

import (
	"fmt"
	"time"
)

type Student[T1 ~string | ~int64, IN, OUT any] struct {
	Name string
	ID   T1
	Task IN
}

func (s *Student[T1, IN, OUT]) SetTask(task IN) int64 {
	s.Task = task
	return time.Now().Unix()
}

func (s *Student[T1, IN, OUT]) GetTask() IN {
	return s.Task
}

func main() {
	s := &Student[string, func() int64, int64]{Name: "张三"}
	s.SetTask(func() int64 {
		fmt.Println("擦黑板")
		return time.Now().Unix()
	})
	s.GetTask()()
}

channel

package main

import "fmt"

type Channel[T any] chan T

func main() {
	ch := make(Channel[int], 10)
	ch <- 1
	fmt.Println(<-ch)
	close(ch)
}

map

comparable接口，限制为可比较的

package main

import "fmt"

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

func main() {

	m := Map[int, string]{}
	m[1] = "hello"
	m[2] = "world"
	fmt.Println(m)
	
}

slice

package main

import "fmt"

type Slice[T any] []T

func main() {
	s := make(Slice[string], 2)
	s[0] = "hello"
	s[1] = "world"
	fmt.Println(s)
}

array

package main

import "fmt"

type Array[T any] [10]T

func main() {
	array := Array[float64]{}
	array[0] = 1.23
	array[1] = 2.34
	array[2] = 3.45
	fmt.Println(array)
}

pointer

package main

import "fmt"

type Pointer[T any] *T

func main() {
	var p Pointer[int]
	p = new(int)
	*p = 10000
	fmt.Println(p, *p)
}

得到一个泛型的变量的零值作为返回值

func F[T any]() T {
  //var tmp T   // 1
  //return tmp
  
  //return make([]T,1)[0] // 2
  return *new(T)  //3
}