go1.18 新特性

泛型

    package main

    import "fmt"

    // 泛型 slice
    type MySlice[T int | float32 | string] []T

    // 泛型 map
    type MyMap[KEY comparable, VALUE int | float32 | string] map[KEY]VALUE

    // 泛型结构体
    type MyStruct[T int | float32 | string] struct {
        Name string
        Data T
    }

    // 泛型接口
    type MyInterface[T int | float32 | string] interface {
        Print(data T)
    }

    // 泛型类
    type MyClass[T int | float32 | string] struct {
    }

    func (mc *MyClass[T]) Add(a T, b T) T {
        return a + b
    }

    // 泛型函数
    func MyFunc[T int | float32 | string](a T, b T) T {
        return a + b
    }

    // 泛型联合约束
    type IntUnion interface {
        ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
    }
    type MyUnionSlice[T IntUnion] []T

    func main() {
        mySlice := MySlice[int]{1, 2, 3}
        myMap := MyMap[string, int]{"a": 1, "b": 2}
        myStruct := MyStruct[int]{Name: "lee", Data: 1}
        var myInterface MyInterface[int]
        myClass := MyClass[int]{}
        res1 := myClass.Add(1, 2)
        fmt.Println("res1:", res1)
        myFunc := MyFunc[int]
        res2 := myFunc(1, 2)
        fmt.Println("res2:", res2)
        myUnionSlice := MyUnionSlice[int]{1, 2, 3}
        fmt.Printf("type of MySlice: %T \n", mySlice)
        fmt.Printf("type of MyMap: %T \n", myMap)
        fmt.Printf("type of MyStruct: %T \n", myStruct)
        fmt.Printf("type of MyInterface: %T \n", myInterface)
        fmt.Printf("type of MyClass: %T \n", myClass)
        fmt.Printf("type of MyFunc: %T \n", myFunc)
        fmt.Printf("type of MyUnionSlice: %T \n", myUnionSlice)
    }

模糊测试

1. 应用文件-utils.go：

    package utils
   
    func Add(a, b int) int {
        return a + b
    }

2. 测试文件-utils_test.go：

    package utils
   
    import (
        "testing"
    )
   
    func FuzzAdd(f *testing.F) {
        f.Fuzz(func(t *testing.T, a, b int) {
            num := Add(a, b)
            if num != a+b {
                t.Errorf("a+b != %d", num)
            }
        })
    }

3. 运行：
   go test -fuzz=Add -fuzztime 3s

工作区模式

1. 目录结构：

   |—— work/               // 根目录
   ****|—— mod1/
   ********|—— go.mod      // 子模块1
   ********|—— add.go
   ****|—— mod2/
   ********|—— go.mod      // 子模块2
   ********|—— minus.go
   ****|—— go.work         // 工作区
   ****|—— main.go         // 入口文件

2. 初始化工作区：
   go work init ./mod1 ./mod2

3. work/mod1/add.go：

    package mod1
   
    func Add(a, b int) int {
        return a + b
    }

4. work/mod2/minus.go：

    package mod2
   
    func Minus(a, b int) int {
        return a - b
    }

5. work/main.go：

    package main
   
    import (
        "fmt"
        "mod1"
        "mod2"
    )
   
    func main() {
        fmt.Println(mod1.Add(1, 2))
        fmt.Println(mod2.Minus(2, 1))
    }

6. 运行：
   go run main.go