Go 1.18 版本新特性详解！

# 查看当前go版本和位置go version && which go# go version go1.17.7 linux/amd64# /usr/bin/go# 之前是直接使用的yum install go安装的
# 下载1.18版本wget https://go.dev/dl/go1.18.3.linux-amd64.tar.gz
# 解压&移动tar -C /tmp/ -xzf go1.18.3.linux-amd64.tar.gzsudo mv /tmp/go /usr/local/go18
# 往文件写入命令cat << EOF >/usr/local/go18/bin/go18unset GOROOTgo env -w GOROOT="/usr/local/go18/"/usr/local/go18/bin/go \$@EOF
# 查看文件里面的命令内容cat /usr/local/go18/bin/go18# unset GOROOT# go env -w GOROOT="/usr/local/go18/"# /usr/local/go18/bin/go $@
# 建立软连接sudo ln -s /usr/local/go18/bin/go18 /usr/local/bin/go18
# 查看go版本go18 version && go version#go version go1.18.3 linux/amd64#go version go1.17.7 linux/amd64

func f[T1, T2 any](x int, y T1) T2 {    ...}

var a float64 = f[int, float64](7, 8.0)var b struct{f int} = f[complex128, struct{f int}](3, 1+1i)

func f1(x int, y int) float64 {    ... identical bodies ...}func f2(x int, y complex128) struct{f int} {    ... identical bodies ...}

package main
import (  "fmt"  "time")
// PrtintString 简单的打印func PrtintA(t string) {  return fmt.Println(s)}
// PrtintString 简单的打印func PrtintString[T any](t T) string {  return fmt.Sprintf("%v", t)}
func main() {  PrtintA("test")  PrtintString(0)  PrtintString(int32(0))  PrtintString(uint32(0))  PrtintString(uint64(0))  PrtintString("hello")  PrtintString(struct{}{})  PrtintString(time.Now())}

  ...  0x0024 00036 (main.go:19)  CALL  "".PrtintA(SB)  0x0029 00041 (main.go:20)  LEAQ  ""..dict.PrtintString[int](SB), AX  0x0030 00048 (main.go:20)  XORL  BX, BX  0x0032 00050 (main.go:20)  CALL  "".PrtintString[go.shape.int_0](SB)  0x0037 00055 (main.go:21)  LEAQ  ""..dict.PrtintString[int32](SB), AX  0x003e 00062 (main.go:21)  XORL  BX, BX  0x0040 00064 (main.go:21)  CALL  "".PrtintString[go.shape.int32_0](SB)  0x0045 00069 (main.go:22)  LEAQ  ""..dict.PrtintString[uint32](SB), AX  0x004c 00076 (main.go:22)  XORL  BX, BX  0x004e 00078 (main.go:22)  CALL  "".PrtintString[go.shape.uint32_0](SB)  0x0053 00083 (main.go:23)  LEAQ  ""..dict.PrtintString[uint64](SB), AX  0x005a 00090 (main.go:23)  XORL  BX, BX  0x005c 00092 (main.go:23)  NOP  0x0060 00096 (main.go:23)  CALL  "".PrtintString[go.shape.uint64_0](SB)  0x0065 00101 (main.go:24)  LEAQ  ""..dict.PrtintString[string](SB), AX  0x006c 00108 (main.go:24)  LEAQ  go.string."hello"(SB), BX  0x0073 00115 (main.go:24)  MOVL  $5, CX  0x0078 00120 (main.go:24)  CALL  "".PrtintString[go.shape.string_0](SB)  0x007d 00125 (main.go:25)  LEAQ  ""..dict.PrtintString[struct {}](SB), AX  0x0084 00132 (main.go:25)  CALL  "".PrtintString[go.shape.struct {}_0](SB)  ...

// 自定义类型约束接口StringableFloattype MyFloat interface {    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束}
func Max[T MyFloat](s []T) T {    var zero T    if len(s) == 0 {        return zero    }        var max T    max = s[0]    for _, v := range s[1:] {        max = v        if v > max {            max = v        }    }            return max}

type Category struct {    ID int32    Name string    Slug string}
type Post struct {    ID int32    Categories []Category    Title string    Text string    Slug string}
type cacheable interface {    Category | Post    FreshCache() error}
func (c *cache[T]) Set(key string, value T) {    c.data[key] = value}
func (c *cache[T]) Get(key string) (v T) {    if v, ok := c.data[key]; ok {        return v    }
    return}
func New[T cacheable](cacheTicker *time.Ticker) *cache[T]{  c := cache[T]{}  c.data = make(map[string]T)  
  return &c}
package main
import (  "fmt")
func main() {  // create a new category  category := Category{    ID: 1,    Name: "Go Generics",    Slug: "go-generics",  }  // create cache for Category struct  cc := New[Category]()  // add category to cache  cc.Set(category.Slug, category)  fmt.Printf("cp get:%+v\n", cc.Get(category.Slug))    // create a new post  post := Post{    ID: 1,    Categories: []Category{      {ID: 1, Name: "Go Generics", Slug: "go-generics"},    },    Title: "Generics in Golang structs",    Text: "Here go's the text",    Slug: "generics-in-golang-structs",  }  // create cache for blog.Post struct  cp := New[Post]()  // add post to cache  cp.Set(post.Slug, post)
  fmt.Printf("cp get:%+v\n", cp.Get(post.Slug))}

// 这里类型约束使用了空接口，代表的意思是所有类型都可以用来实例化泛型类型 Queue[T] (关于接口在后半部分会详细介绍）type Queue[T interface{}] struct {    elements []T}
// 将数据放入队列尾部func (q *Queue[T]) Put(value T) {    q.elements = append(q.elements, value)}
// 从队列头部取出并从头部删除对应数据func (q *Queue[T]) Pop() (T, bool) {    var value T    if len(q.elements) == 0 {        return value, true    }
    value = q.elements[0]    q.elements = q.elements[1:]    return value, len(q.elements) == 0}
// 队列大小func (q Queue[T]) Size() int {    return len(q.elements)}
func main(){  var q1 Queue[int]  // 可存放int类型数据的队列  q1.Put(1)  q1.Put(2)  q1.Put(3)  q1.Pop() // 1  q1.Pop() // 2  q1.Pop() // 3
  var q2 Queue[string]  // 可存放string类型数据的队列  q2.Put("A")  q2.Put("B")}

# go test -fuzz={FuzzTestName} $ go test -fuzz FuzzFoofuzz: elapsed: 0s, gathering baseline coverage: 0/192 completedfuzz: elapsed: 0s, gathering baseline coverage: 192/192 completed, now fuzzing with 8 workersfuzz: elapsed: 3s, execs: 325017 (108336/sec), new interesting: 11 (total: 202)fuzz: elapsed: 6s, execs: 680218 (118402/sec), new interesting: 12 (total: 203)fuzz: elapsed: 9s, execs: 1039901 (119895/sec), new interesting: 19 (total: 210)fuzz: elapsed: 12s, execs: 1386684 (115594/sec), new interesting: 21 (total: 212)PASSok      foo 12.692s
# elapsed表示从开始模糊测试到现在经过了多少时间, execs表示执行的用例数

func Reverse(s string) string {    b := []byte(s)    for i, j := 0, len(b)-1; i < len(b)/2; i, j = i+1, j-1 {        b[i], b[j] = b[j], b[i]    }    return string(b)}

package main
import "fmt"
func main() {  input := "The quick brown fox jumped over the lazy dog"  rev := Reverse(input)  doubleRev := Reverse(rev)  fmt.Printf("original: %q\n", input)  fmt.Printf("reversed: %q\n", rev)  fmt.Printf("reversed again: %q\n", doubleRev)}

fuzz_demo.├── main.go├── reverse.go└── reverse_test.go

go run ../fuzz_demo/original: "The quick brown fox jumped over the lazy dog"reversed: "god yzal eht revo depmuj xof nworb kciuq ehT"reversed again: "The quick brown fox jumped over the lazy dog"

package main
import (    "testing")
func TestReverse(t *testing.T) {    testcases := []struct {        in, want string    }{        {"Hello, world", "dlrow ,olleH"},        {" ", " "},        {"!12345", "54321!"},    }    for _, tc := range testcases {        rev := Reverse(tc.in)        if rev != tc.want {                t.Errorf("Reverse: %q, want %q", rev, tc.want)        }    }}

$ go testPASSok      example/fuzz  0.013s

func FuzzReverse(f *testing.F) {    testcases := []string{"Hello, world", " ", "!12345"}    for _, tc := range testcases {        f.Add(tc)  // Use f.Add to provide a seed corpus    }    f.Fuzz(func(t *testing.T, orig string) {        rev := Reverse(orig)        doubleRev := Reverse(rev)        if orig != doubleRev {            t.Errorf("Before: %q, after: %q", orig, doubleRev)        }        if utf8.ValidString(orig) && !utf8.ValidString(rev) {            t.Errorf("Reverse produced invalid UTF-8 string %q", rev)        }    })}

[root]# go18 test -fuzz=Fuzzfuzz: elapsed: 0s, gathering baseline coverage: 0/3 completedfuzz: elapsed: 0s, gathering baseline coverage: 3/3 completed, now fuzzing with 8 workersfuzz: elapsed: 0s, execs: 526 (7126/sec), new interesting: 3 (total: 6)--- FAIL: FuzzReverse (0.07s)    --- FAIL: FuzzReverse (0.00s)        reverse_test.go:36: Reverse produced invalid UTF-8 string "\xbb\xac\xe7"        Failing input written to testdata/fuzz/FuzzReverse/a9d86b0e4e93269adeeaa8df903415915f5979f1c2d2b8bb02311f0a72e6c8fb    To re-run:    go test -run=FuzzReverse/a9d86b0e4e93269adeeaa8df903415915f5979f1c2d2b8bb02311f0a72e6c8fbFAILexit status 1FAIL    generic_test    0.082s

# 我们查看一下用例的内容, 看一下具体时哪个用例有问题[root@VM-74-225-centos ~/go/src/generic_test]# cat testdata/fuzz/FuzzReverse/a9d86b0e4e93269adeeaa8df903415915f5979f1c2d2b8bb02311f0a72e6c8fbgo test fuzz v1string("笻")

func Reverse(s string) string {    r := []rune(s)    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {        r[i], r[j] = r[j], r[i]    }    return string(r)}

[root@VM-74-225-centos ~/go/src/generic_test]# go18 test -fuzz=Fuzzfuzz: elapsed: 0s, gathering baseline coverage: 0/7 completedfuzz: minimizing 38-byte failing input filefuzz: elapsed: 0s, gathering baseline coverage: 4/7 completed--- FAIL: FuzzReverse (0.03s)    --- FAIL: FuzzReverse (0.00s)        reverse_test.go:33: Before: "\xd8", after: "�"    
    Failing input written to testdata/fuzz/FuzzReverse/5f644fdcef1c73a8103274829865beba68d8087129b886a825d1bba632f4358e    To re-run:    go test -run=FuzzReverse/5f644fdcef1c73a8103274829865beba68d8087129b886a825d1bba632f4358e
FAILexit status 1FAIL    generic_test    0.029s

func Reverse(s string) (string, error) {    if !utf8.ValidString(s) {        return s, errors.New("input is not valid UTF-8")    }    r := []rune(s)    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {        r[i], r[j] = r[j], r[i]    }    return string(r), nil}

package main
import (  "testing"  "unicode/utf8")
func TestReverse(t *testing.T) {  testcases := []struct {    in, want string  }{    {"Hello, world", "dlrow ,olleH"},    {" ", " "},    {"!12345", "54321!"},  }  for _, tc := range testcases {    rev, _ := Reverse(tc.in)    if rev != tc.want {      t.Errorf("Reverse: %q, want %q", rev, tc.want)    }
  }}
func FuzzReverse(f *testing.F) {  testcases := []string{"Hello, world", " ", "!12345"}  for _, tc := range testcases {    f.Add(tc) // Use f.Add to provide a seed corpus  }  f.Fuzz(func(t *testing.T, orig string) {    rev, err1 := Reverse(orig)    if err1 != nil {      return    }    doubleRev, err2 := Reverse(rev)    if err2 != nil {      return    }    if orig != doubleRev {      t.Errorf("Before: %q, after: %q", orig, doubleRev)    }    if utf8.ValidString(orig) && !utf8.ValidString(rev) {      t.Errorf("Reverse produced invalid UTF-8 string %q", rev)    }  })}

[root]# go18 test -fuzz=Fuzz -fuzztime 10sfuzz: elapsed: 0s, gathering baseline coverage: 0/40 completedfuzz: elapsed: 0s, gathering baseline coverage: 40/40 completed, now fuzzing with 8 workersfuzz: elapsed: 3s, execs: 424692 (141504/sec), new interesting: 1 (total: 41)fuzz: elapsed: 6s, execs: 824495 (133183/sec), new interesting: 1 (total: 41)fuzz: elapsed: 9s, execs: 1227987 (134614/sec), new interesting: 1 (total: 41)fuzz: elapsed: 10s, execs: 1364282 (122256/sec), new interesting: 1 (total: 41)PASSok      generic_test    10.122s

replace golang.org/x/net => /Users/guirongguo/go/awesomeProject

package main
import (    "github.com/guirongguo/utils")
func main() {    utils.PrintFish()}

Usage:        go work <command> [arguments]The commands are:
        edit        edit go.work from tools or scripts        init        initialize workspace file        sync        sync workspace build list to modules        use         add modules to workspace file
Use "go help work <command>" for more information about a command.

awesomeProject├── mod│   ├── go.mod      // 子模块│   └── main.go└── tools    ├── string_utils.go    └── go.mod      // 子模块    

cd awesomeProjectgo work init ./mod ./toolstreeawesomeProject.├── mod│   ├── go.mod      // 子模块│   └── main.go├── go.work         // 工作区└── tools    ├── string_utils.go    └── go.mod      // 子模块

go 1.18
use (    ./mod     ./tools)

go run -workfile=off main.go