golang泛型

121 阅读1分钟

泛型

示例1-泛型切片

package main

import "fmt"

func main() {
	list1 := List[int]{3, 5, 8}
	result1 := HasItem(list1, 5)
	fmt.Println("list1 has:", result1)

	list2 := List[string]{"hello", "world"}
	result2 := HasItem(list2, "world2")
	fmt.Println("list2 has:", result2)
}

type List[T any] []T

func HasItem[T comparable](list []T, key T) bool {
	var exists = false

	for _, val := range list {
		if val == key {
			exists = true
		}
	}

	return exists
}

示例2-泛型map

package main

import "fmt"

type m[K string, V any] map[K]V

func main() {
	m1 := m[string, interface{}]{
		"name": "wanghaha",
		"id":   1001,
	}

	fmt.Println(m1)

	m2 := make(m[string, string])
	m2["name"] = "wang"
	fmt.Println(m2)
	fmt.Println(m2["name"])
}

示例-泛型通道

package main

import "fmt"

type C[T any] chan T

func main() {
	c1 := make(C[int], 10)
	c1 <- 1
	c1 <- 66

	c2 := make(C[string], 10)
	c2 <- "xx1"
	c2 <- "xx2"

	fmt.Println(<-c1, <-c2)
}

示例-类型约束

package main

import "fmt"

type NumStr interface {
	Num | Str
}

type Num interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~complex64 | ~complex128
}

type Str interface {
	string
}

type ts[T NumStr] []T

func HasItem[T NumStr](list []T, key T) bool {
	var exists = false

	for _, val := range list {
		if val == key {
			exists = true
		}
	}

	return exists
}

func main() {
	list1 := ts[int]{3, 5, 8, 9}
	result1 := HasItem(list1, 9)
	fmt.Println("list1 result:", result1)

	list2 := ts[string]{"hello", "world"}
	result2 := HasItem(list2, "hello")
	fmt.Println("list2 result:", result2)
}

示例

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

type test interface {
	String() string
}

type t1 int

func (receiver t1) String() string {
	return strconv.Itoa(int(receiver))
}

func TestFunc[T test](s []T) []string {
	result := []string{}
	for _, val := range s {
		result = append(result, val.String())
	}
	return result
}

func main() {
	fmt.Println(reflect.TypeOf(TestFunc([]t1{3, 2})))
}

示例

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

type test interface {
	String() string
	~string | ~int
}

type t1 int

func (receiver t1) String() string {
	return strconv.Itoa(int(receiver))
}

func TestFunc[T test](s []T) []string {
	result := []string{}
	for _, val := range s {
		result = append(result, val.String())
	}
	return result
}

func main() {
	fmt.Println(reflect.TypeOf(TestFunc([]t1{3, 2})))
}

示例

package main

import "fmt"

func main() {
	m1 := make(map[string]int)
	m1["x"] = 3
	m1["y"] = 5
	m1Result := SumFunc(m1)
	fmt.Println("m1Result:", m1Result)

	m2 := make(map[string]float32)
	m2["x"] = 30.22
	m2["y"] = 50.33
	SumFunc(m2)
	m2Result := SumFunc(m2)
	fmt.Println("m1Result:", m2Result)
}

type value interface {
	int | int8 | int16 | int32 | int64 | float32 | float64
}

func SumFunc[K comparable, V value](m map[K]V) V {
	var count V
	for _, val := range m {
		count += val
	}
	return count
}