Go Cheat Sheet

编译时加入版本信息#

1
package main
2

3
import (
4
    "fmt"
5
    "os"
6
)
7
var (
8
    gitHash   string
9
    buildTime string
10
    goVersion string
11
)
12
func main() {
13
    args := os.Args
14
    if len(args) == 2 && (args[1] == "--version" || args[1] == "-v") {
15
        fmt.Printf("Git Commit Hash: %s \n", gitHash)
16
        fmt.Printf("Build TimeStamp: %s \n", buildTime)
17
        fmt.Printf("GoLang Version: %s \n", goVersion)
18
        return
19
    }
20
}

1
go build -ldflags "-X 'main.goVersion=$(go version)' -X 'main.gitHash=$(git show -s --format=%H)' -X 'main.buildTime=$(git show -s --format=%cd)'"

embed 相对路径#

1
package res
2

3
import (
4
  _ "embed"
5
)
6

7
//go:embed ../.temp/temp.txt
8
var tempFile string

defer#

顺序#

1
func main() {
2
    defer fmt.Println(1)
3
    defer fmt.Println(2)
4
    defer fmt.Println(3)
5

6
    fmt.Println("main")
7
}

1
main
2
3
3
2
4
1

闭包#

1
func main() {
2
    a := 1
3
    b := 2
4

5
    defer fmt.Println(a + b)
6

7
    a = 2
8
}

1
3

1
func main() {
2
    a := 1
3
    b := 2
4

5
    defer func() {
6
        fmt.Println(a + b)
7
    }()
8

9
    a = 2
10
}

1
4

返回#

1
func t1() int {
2
    a := 1
3
    defer func() {
4
        a++
5
    }()
6
    return a
7
}

1
1

1
func t2() (a int) {
2
    defer func() {
3
        a++
4
    }()
5
    return 1
6
}

1
2

defer 中的 a 来自外部（需要返回的），所以内部自加会影响返回值。

1
func t4() (a int) {
2
  defer func(a int) {
3
    a++
4
  }(a)
5
  return 2
6
}

1
2

defer 中的 a 是外部的复制。

`os.Exit`#

1
func main() {
2
    defer fmt.Println("1")
3
    fmt.Println("main")
4
    os.Exit(0)
5
}

1
main

程序退出不会执行 defer

coroutine#

1
func main() {
2
    GoA()
3
    time.Sleep(1 * time.Second)
4
    fmt.Println("main")
5
}
6

7
func GoA() {
8
    defer (func(){
9
        if err := recover(); err != nil {
10
            fmt.Println("panic:" + fmt.Sprintf("%s", err))
11
        }
12
    })()
13

14
    go GoB()
15
}
16

17
func GoB() {
18
    panic("error")
19
}

GoA 无法捕获 GoB 的错误。

for idx & range 性能对比#

测试#

1
package main
2

3
import "testing"
4

5
type Item struct {
6
  id  int
7
  val [4096]byte
8
}
9

10
func BenchmarkForStruct(b *testing.B) {
11
  var items [1024]Item
12
  for i := 0; i < b.N; i++ {
13
    length := len(items)
14
    var tmp int
15
    for k := 0; k < length; k++ {
16
      tmp = items[k].id
17
    }
18
    _ = tmp
19
  }
20
}
21

22
func BenchmarkRangeIndexStruct(b *testing.B) {
23
  var items [1024]Item
24
  for i := 0; i < b.N; i++ {
25
    var tmp int
26
    for k := range items {
27
      tmp = items[k].id
28
    }
29
    _ = tmp
30
  }
31
}
32

33
func BenchmarkRangeStruct(b *testing.B) {
34
  var items [1024]Item
35
  for i := 0; i < b.N; i++ {
36
    var tmp int
37
    for _, item := range items {
38
      tmp = item.id
39
    }
40
    _ = tmp
41
  }
42
}

结果#

1
➜  go_test go test -benchmem -run=^$ -bench ^Benchmark range_test.go
2
goos: darwin
3
goarch: arm64
4
BenchmarkForStruct-8             3486474               330.4 ns/op             0 B/op          0 allocs/op
5
BenchmarkRangeIndexStruct-8      3637329               329.9 ns/op             0 B/op          0 allocs/op
6
BenchmarkRangeStruct-8              6810            164832 ns/op               0 B/op          0 allocs/op
7
PASS
8
ok      command-line-arguments  4.279s

差距大概50倍。
原因是for range的k，v中的v是复制的，需要申请内存（除非值为指针）。
for range尽量只使用下标，不使用值。

any 传入 `[]any`或`map[string]any`#

1
v := reflect.ValueOf(i)
2
switch v.Kind() {
3
case reflect.Slice:
4
  items := make([]any, v.Len())
5
  for i := 0; i < v.Len(); i++ {
6
    items[i] = v.Index(i).Interface()
7
  }
8
case reflect.Map:
9
  items := make(map[string]any)
10
  for _, key := range v.MapKeys() {
11
    items[key.String()] = v.MapIndex(key).Interface()
12
  }
13
}

string#

for idx & for range#

1
a := "1万🔖"
2
for i := 0; i < len(a); i++ {
3
  println(i, a[i])
4
}
5
println()
6
for i := range a {
7
  fmt.Println(i, a[i])
8
}
9
println()
10
for i, v := range a {
11
  fmt.Println(i, v)
12
}

拼接#

多次拼接使用strings.Builder

1
func builderConcat(strs... string) string {
2
  var builder strings.Builder
3
  for _, str := range strs {
4
    builder.Grow(len(str))
5
  }
6

7
  for _, str := range strs {
8
    builder.WriteString(str)
9
  }
10
  return builder.String()
11
}

error#

`==`

1
err1 := errors.New("error1")
2
err2 := errors.New("error1")
3
err1 == err2 // false
4
reflect.DeepEqual(err1, err2) // true
5
errors.Is(err1, err2) // false

即使error内部str相同，也不==
可以使用reflect.DeepEqual，但是linter不推荐

time#

ticker#

1
package main
2

3
import (
4
  "time"
5
)
6

7
func main() {
8
  ti := time.NewTicker(time.Second * 2)
9
  times := 0
10
  for range ti.C {
11
    times++
12
    if times % 2 == 0 {
13
      println("tick")
14
      continue
15
    }
16
    println(time.Now().Format("2006-01-02 15:04:05"))
17
  }
18
}

输出:

1
2022-08-08 18:36:00
2
tick
3
2022-08-08 18:36:04
4
tick
5
2022-08-08 18:36:08
6
tick
7
2022-08-08 18:36:12
8
tick
9
2022-08-08 18:36:16

ticker中continue不会直接进入下一个循环，而是会等待ticker到达预定时间才运行

json#

`interface{}`#

1
var temp interface{}
2
userStr := `{"name":"zhangsan","age":18}`
3
err := json.Unmarshal([]byte(userStr), &temp)
4
if err != nil {
5
  println(err.Error())
6
} else {
7
  fmt.Printf("%#v\n", temp)
8
}
9
// 输出:
10
// map[string]interface {}{"age":18, "name":"zhangsan"}

interface{} -> map[string]interface{}

flag#

bool#

1
b := flag.Bool("b", false, "bool flag")
2
flag.Parse()
3
println(*b)

1
go run . --b # true
2
go run . # false

`:=`#

1
a := 0
2
if a == 0 {
3
  a, _:= strconv.Atoi("1")
4
  fmt.Printf("%#v\n", a) // 1
5
}
6
fmt.Printf("%#v\n", a) // 0

:=表示为一个新对象，if外部a对象被覆盖了，只在if作用域内a为1

单、双、反引号#

1
fmt.Printf("%#v\n", '\v') // 11

单引号，表示byte类型或rune类型，对应 uint8和int32类型，默认是 rune 类型。

1
``

用来强调数据是raw data；而rune用来表示Unicode的code point。

nil 详解#

https://zhuanlan.zhihu.com/p/354498185

格式化输出（前置0）。#

1
package main
2

3
import "fmt"
4

5
func main() {
6
    var num1 int = 5
7

8
    // 使用 %0Nd，其中 N 是你想要的宽度
9
    fmt.Printf("%05d\n", num1)
10
}

在这个例子中，%05d 会打印一个宽度为 5 的整数，如果整数的长度小于 5，那么它会在前面添加 0 以达到 5 的宽度。