为何选GO#

Go是 Google 在 2009 年发布的编程语言，也被称为“21世纪的C语言”

性能均衡，且易上手#

Go 的运行速度通常明显快于 Python、JavaScript 等解释型语言。
并且Go 的语法比 Rust、C++、Java 更精简，关键字少，代码结构统一。

自带GC(垃圾回收)#

Go 程序创建对象后，不需要手动释放。Go 运行时会检查哪些内存已经没有人使用，然后自动回收。
相较于Rust的GC(所有权,借用,生命周期)，学习成本低。

代码风格统一#

gofmt会自动整理缩进和代码格式，团队成员写出来的代码风格基本一致。
降低了屎山代码概率。

并发编程简单#

Go 内置了 goroutine，可以方便地同时执行多个任务。

Go语言基础与速查表#

引用自Quick Reference 该备忘单提供了帮助您使用 Golang 的基本语法和方法。

入门#

hello.go#

1
package main
2
import "fmt"
3
func main() {
4
    fmt.Println("Hello, world!")
5
}

直接运行

1
$ go run hello.go
2
Hello, world!

或者在 Go repl 中尝试一，go 命令参考

变量#

1
var s1 string
2
s1 = "Learn Go!"
3
// 一次声明多个变量
4
var b, c int = 1, 2
5
var d = true
6
// 匿名赋值
7
_ , e = 10, 20

简短声明

1
s1 := "Learn Go!"        // string
2
b, c := 1, 2             // int
3
d := true                // bool

参见：基本类型

函数#

1
package main
2
import "fmt"
3
// 程序的入口点
4
func main() {
5
  fmt.Println("Hello world!")
6
  say("Hello Go!")
7
}
8
func say(message string) {
9
  fmt.Println("You said: ", message)
10
}

参见：函数(Functions)

注释#

1
// 单行注释
2
/* 这是
3
多行注释 */

if 语句#

1
if true {
2
  fmt.Println("Yes!")
3
}

参见：条件控制

Golang 基本类型#

字符串 Strings#

1
s1 := "Hello" + "World"
2
s2 := `A "raw" string literal
3
can include line breaks.`
4
// 输出：10
5
fmt.Println(len(s1))
6
// 输出：Hello
7
fmt.Println(string(s1[0:5]))

字符串的类型为 字符串

数字 Numbers#

1
num := 3             // int
2
num := 3.            // float64
3
num := 3 + 4i        // complex128
4
num := byte('a')     // byte (alias: uint8)
5
var u uint = 7       // uint (unsigned)
6
var p float32 = 22.7  // 32-bit float

操作符 Operators#

1
x := 5
2
x++
3
fmt.Println("x + 4 =", x + 4)
4
fmt.Println("x * 4 =", x * 4)

参见：更多操作符

布尔值 Booleans#

1
isTrue   := true
2
isFalse  := false

操作符#

1
fmt.Println(true && true)   // true
2
fmt.Println(true && false)  // false
3
fmt.Println(true || true)   // true
4
fmt.Println(true || false)  // true
5
fmt.Println(!true)          // false

参见：更多操作符

数组 Arrays#

1
┌────┬────┬────┬────┬─────┬─────┐
2
| 2  | 3  | 5  | 7  | 11  | 13  |
3
└────┴────┴────┴────┴─────┴─────┘
4
  0    1    2    3     4     5

1
primes := [...]int{2, 3, 5, 7, 11, 13}
2
fmt.Println(len(primes)) // => 6
3
// 输出：[2 3 5 7 11 13]
4
fmt.Println(primes)
5
// 与 [:3] 相同，输出：[2 3 5]
6
fmt.Println(primes[0:3])

1
var a [2]string
2
a[0] = "Hello"
3
a[1] = "World"
4
fmt.Println(a[0], a[1]) //=> Hello World
5
fmt.Println(a)   // => [Hello World]

2d array#

1
var twoDimension [2][3]int
2
for i := 0; i < 2; i++ {
3
    for j := 0; j < 3; j++ {
4
        twoDimension[i][j] = i + j
5
    }
6
}
7
// => 2d:  [[0 1 2] [1 2 3]]
8
fmt.Println("2d: ", twoDimension)

指针(Pointers)#

1
func main () {
2
  b := *getPointer()
3
  fmt.Println("Value is", b)
4
}
5

6
func getPointer () (myPointer *int) {
7
  a := 234
8
  return &a
9
}
10
//申明指针的时候，如果没有指向某个变量，默认值为nil
11
//不能直接进行操作，包括读写
12
var p *int
13
*p = 123      // panic   nil pointer

1
//而用new返回的是有默认值的指针, 为数据类型的默认值
2
func main(){
3
  //有一块内存存放了10，它的地址由系统自动分配，别名是a
4
  a := 10
5
  //内存存放的10变成了20
6
  a = 20
7
  var p *int
8
  p = &a   //或者直接写 p := &a
9
  //上面的p是一个指针，通过 *p 的方式同样可以访问 变量a指向 的内存
10

11
  /*当你动态申请内存的时候，指针的存在意义之一就被体现出来了*/
12
  ptr := new(int)
13
  //申请了一块内存空间，没有办法指定别名，new()返回内存地址，用指针接收
14
  //此时并没有变量能直接指向这块内存，所以只能通过内存地址来访问
15
}

参见：指针(Pointers)

切片(Slices)#

1
s := make([]string, 3)
2
s[0] = "a"
3
s[1] = "b"
4
s = append(s, "d")
5
s = append(s, "e", "f")
6
fmt.Println(s)
7
fmt.Println(s[1])
8
fmt.Println(len(s))
9
fmt.Println(s[1:3])
10
slice := []int{2, 3, 4}

另见：切片示例

常量(Constants)#

1
const s string = "constant"
2
const Phi = 1.618
3
const n = 500000000
4
const d = 3e20 / n

常量声明可以使用 iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。注意：

在一个const声明语句中，在第一个声明的常量所在的行，iota被置为0，然后在每一个有常量声明的行加一。
写在同一行的值是相同的

1
const (
2
    a = iota
3
    b
4
    c
5
)
6
// a = 0, b = 1, c = 2

类型转换#

Go语言中不允许隐式转换，所有类型转换必须显式声明（强制转换），而且转换只能发生在两种相互兼容的类型之间。

1
i := 90
2
f := float64(i)
3
u := uint(i)
4
// 将等于字符Z
5
s := string(i)

字符串与其他类型的相互转换#

1
// 字符串转其他类型
2
str := "90"
3
// 整数类型
4
i, err := strconv.Atoi(str)
5
if err != nil {
6
    fmt.Println("转换错误:", err)
7
} else {
8
    fmt.Println(i)
9
}
10
// 浮点类型
11
f, err := strconv.ParseFloat(str, 64)
12
// []byte 类型
13
bytes := []byte(str)
14
// 其他类型转字符串
15
str = strconv.Itoa(i)
16
str = strconv.FormatFloat(f, 'f', 2, 64)
17
str = string(bytes[:])

Golang 字符串#

字符串函数#

1
package main
2
import (
3
        "fmt"
4
        s "strings"
5
)
6
func main() {
7
    /* 需要将字符串导入为 s */
8
        fmt.Println(s.Contains("test", "e"))
9
    /* 内置 */
10
    fmt.Println(len("hello"))  // => 5
11
    // 输出: 101
12
        fmt.Println("hello"[1])
13
    // 输出: e
14
        fmt.Println(string("hello"[1]))
15
}

fmt.Printf#

1
package main
2
import (
3
        "fmt"
4
        "os"
5
)
6
type point struct {
7
        x, y int
8
}
9
func main() {
10
        p := point{1, 2}
11
        fmt.Printf("%v\n", p)                        // => {1 2}
12
        fmt.Printf("%+v\n", p)                       // => {x:1 y:2}
13
        fmt.Printf("%#v\n", p)                       // => main.point{x:1, y:2}
14
        fmt.Printf("%T\n", p)                        // => main.point
15
        fmt.Printf("%t\n", true)                     // => TRUE
16
        fmt.Printf("%d\n", 123)                      // => 123
17
        fmt.Printf("%b\n", 14)                       // => 1110
18
        fmt.Printf("%c\n", 33)                       // => !
19
        fmt.Printf("%x\n", 456)                      // => 1c8
20
        fmt.Printf("%f\n", 78.9)                     // => 78.9
21
        fmt.Printf("%e\n", 123400000.0)              // => 1.23E+08
22
        fmt.Printf("%E\n", 123400000.0)              // => 1.23E+08
23
        fmt.Printf("%s\n", "\"string\"")             // => "string"
24
        fmt.Printf("%q\n", "\"string\"")             // => "\"string\""
25
        fmt.Printf("%x\n", "hex this")               // => 6.86578E+15
26
        fmt.Printf("%p\n", &p)                       // => 0xc00002c040
27
        fmt.Printf("|%6d|%6d|\n", 12, 345)           // => |    12|   345|
28
        fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)     // => |  1.20|  3.45|
29
        fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)   // => |1.20  |3.45  |
30
        fmt.Printf("|%6s|%6s|\n", "foo", "b")        // => |   foo|     b|
31
        fmt.Printf("|%-6s|%-6s|\n", "foo", "b")      // => |foo   |b     |
32
        s := fmt.Sprintf("a %s", "string")
33
        fmt.Println(s)
34
        fmt.Fprintf(os.Stderr, "an %s\n", "error")
35
}

另见：fmt

函数实例#

实例	Result
Contains(“test”, “es”)	true
Count(“test”, “t”)	2
HasPrefix(“test”, “te”)	true
HasSuffix(“test”, “st”)	true
Index(“test”, “e”)	1
Join([]string{“a”, “b”}, ”-“)	a-b
Repeat(“a”, 5)	aaaaa
Replace(“foo”, “o”, “0”, -1)	f00
Replace(“foo”, “o”, “0”, 1)	f0o
Split(“a-b-c-d-e”, ”-”)	[a b c d e]
ToLower(“TEST”)	test
ToUpper(“test”)	TEST

Golang 条件控制#

有条件的#

1
a := 10
2
if a > 20 {
3
    fmt.Println(">")
4
} else if a < 20 {
5
    fmt.Println("<")
6
} else {
7
    fmt.Println("=")
8
}

if 中的语句#

1
x := "hello go!"
2
if count := len(x); count > 0 {
3
    fmt.Println("Yes")
4
}

1
if _, err := doThing(); err != nil {
2
    fmt.Println("Uh oh")
3
}

Switch#

1
x := 42.0
2
switch x {
3
  case 0:
4
  case 1, 2:
5
      fmt.Println("Multiple matches")
6
  case 42:   // Don't "fall through".
7
      fmt.Println("reached")
8
  case 43:
9
      fmt.Println("Unreached")
10
  default:
11
      fmt.Println("Optional")
12
}

参见：Switch

For loop#

1
for i := 0; i <= 10; i++ {
2
  fmt.Println("i: ", i)
3
}

对于 Range 循环#

1
nums := []int{2, 3, 4}
2
sum := 0
3
for _, num := range nums {
4
  sum += num
5
}
6
fmt.Println("sum:", sum)

For 循环#

1
i := 1
2
for i <= 3 {
3
  fmt.Println(i)
4
  i++
5
}

Continue 关键字#

1
for i := 0; i <= 5; i++ {
2
  if i % 2 == 0 {
3
      continue
4
  }
5
  fmt.Println(i)
6
}

Break 关键字#

1
for {
2
  fmt.Println("loop")
3
  break
4
}

Golang 结构和Maps#

定义#

1
package main
2
import (
3
        "fmt"
4
)
5
type Vertex struct {
6
        X int
7
        Y int
8
}
9
func main() {
10
        v := Vertex{1, 2}
11
        v.X = 4
12
        fmt.Println(v.X, v.Y) // => 4 2
13
}

参见：结构(Structs)

字面量#

1
v := Vertex{X: 1, Y: 2}
2
// Field names can be omitted
3
v := Vertex{1, 2}
4
// Y is implicit
5
v := Vertex{X: 1}

您还可以输入字段名

Maps#

1
m := make(map[string]int)
2
m["k1"] = 7
3
m["k2"] = 13
4
fmt.Println(m) // => map[k1:7 k2:13]
5
v1 := m["k1"]
6
fmt.Println(v1)     // => 7
7
fmt.Println(len(m)) // => 2
8
delete(m, "k2")
9
fmt.Println(m) // => map[k1:7]
10
_, prs := m["k2"]
11
fmt.Println(prs) // => false
12
n := map[string]int{"foo": 1, "bar": 2}
13
fmt.Println(n) // => map[bar:2 foo:1]

指向结构的指针#

1
v := &Vertex{1, 2}
2
v.X = 2

Doing v.X is the same as doing (*v).X, when v is a pointer.

Golang 函数#

多个参数#

1
func plus(a int, b int) int {
2
    return a + b
3
}
4
func plusPlus(a, b, c int) int {
5
    return a + b + c
6
}
7
fmt.Println(plus(1, 2))
8
fmt.Println(plusPlus(1, 2, 3))

多返回值#

1
func vals() (int, int) {
2
  return 3, 7
3
}
4
a, b := vals()
5
fmt.Println(a)    // => 3
6
fmt.Println(b)    // => 7

匿名函数#

1
r1, r2 := func() (string, string) {
2
    x := []string{"hello", "world"}
3
    return x[0], x[1]
4
}()
5
// => hello world
6
fmt.Println(r1, r2)

命名返回值#

1
func split(sum int) (x, y int) {
2
  x = sum * 4 / 9
3
  y = sum - x
4
  return
5
}
6
x, y := split(17)
7
fmt.Println(x)   // => 7
8
fmt.Println(y)   // => 10

可变参数函数#

1
func sum(nums ...int) {
2
  fmt.Print(nums, " ")
3
  total := 0
4
  for _, num := range nums {
5
      total += num
6
  }
7
  fmt.Println(total)
8
}
9
sum(1, 2)     // => [1 2] 3
10
sum(1, 2, 3)  // => [1 2 3] 6
11
nums := []int{1, 2, 3, 4}
12
sum(nums...)  // => [1 2 3 4] 10
13
// 不定参在内存中是连续存储的
14
// 不定参内部再传递的时候，参数也要是不定的

初始化函数#

1
import --> const --> var --> init()

1
var num = setNumber()
2
func setNumber() int {
3
  return 42
4
}
5
func init() {
6
  num = 0
7
}
8
func main() {
9
  fmt.Println(num) // => 0
10
}

作为值的函数#

1
func main() {
2
  // 将函数赋给名称
3
  add := func(a, b int) int {
4
      return a + b
5
  }
6
  // 使用名称调用函数
7
  fmt.Println(add(3, 4)) // => 7
8
}

闭包#

1
func outer() (func() int, int) {
2
    outer_var := 2
3
    inner := func() int {
4
        outer_var += 99
5
        return outer_var
6
    }
7
    inner()
8
    return inner, outer_var
9
}
10
inner, val := outer()
11
fmt.Println(val)
12
// => 101
13
fmt.Println(inner())
14
// => 200，这里涉及到golang中闭包和内存逃逸的概念，inner()实际上执行了两次，outer()中一次，fmt又一次，
15
//但为什么是200呢，编译器不能确定outer_var在后续会不会使用，
16
//所以outer_var不会随着outer()结束而释放它的栈（Stack）空间，
17
//而会‘逃逸到’堆（Heap）上，那么第二次的inner()中outer_var就会是101。

关闭 1#

1
func scope() func() int{
2
  outer_var := 2
3
  foo := func() int {return outer_var}
4
  return foo
5
}
6
// Outpus: 2
7
fmt.Println(scope()())

Golang 包(Packages)#

导入#

1
import "fmt"
2
import "math/rand"

等同于#

1
import (
2
  "fmt"        // 给 fmt.Println
3
  "math/rand"  // 给 rand.Intn
4
)

另见：导入

别名#

1
import r "math/rand"

1
import (
2
    "fmt"
3
    r "math/rand"
4
)

1
r.Intn()

Packages#

1
package main
2
// 一个内部包只能被另一个包导入
3
// 那是在以内部目录的父级为根的树内
4
package internal

另见：内部包

导出名称#

1
// 以大写字母开头
2
func Hello () {
3
  ···
4
}

另见：导出的名称

Golang 并发#

协程#

1
package main
2
import (
3
    "fmt"
4
    "time"
5
)
6
func f(from string) {
7
    for i := 0; i < 3; i++ {
8
            fmt.Println(from, ":", i)
9
    }
10
}
11
func main() {
12
    f("direct")
13
    go f("goroutine")
14
    go func(msg string) {
15
            fmt.Println(msg)
16
    }("going")
17
    time.Sleep(time.Second)
18
    fmt.Println("done")
19
}

参见：Goroutines, Channels

WaitGroup#

1
package main
2
import (
3
    "fmt"
4
    "sync"
5
    "time"
6
)
7
func w(id int, wg *sync.WaitGroup) {
8
    defer wg.Done()
9
    fmt.Printf("%d starting\n", id)
10
    time.Sleep(time.Second)
11
    fmt.Printf("%d done\n", id)
12
}
13
func main() {
14
    var wg sync.WaitGroup
15
    for i := 1; i <= 5; i++ {
16
            wg.Add(1)
17
            go w(i, &wg)
18
    }
19
    wg.Wait()
20
}

参见：WaitGroup

Closing channels#

1
ch <- 1
2
ch <- 2
3
ch <- 3
4
close(ch) // 关闭频道

1
// 迭代通道直到关闭
2
for i := range ch {
3
  ···
4
}

1
// Closed if `ok == false`
2
v, ok := <- ch

参见：范围和关闭

缓冲通道#

1
ch := make(chan int, 2)
2
ch <- 1
3
ch <- 2
4
ch <- 3
5
// 致命错误：
6
// 所有 goroutine 都处于休眠状态 - 死锁

参见：缓冲通道

Context#

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "time"
7
)
8

9
func main() {
10
    // 创建根 context
11
    ctx := context.Background() // 空 context，通常作为根 context
12
    todo := context.TODO()      // 当不确定使用哪个 context 时使用
13

14
    // 创建带取消功能的 context
15
    ctx, cancel := context.WithCancel(context.Background())
16
    defer cancel() // 确保所有路径都调用取消函数
17

18
    // 创建带超时的 context
19
    ctx, cancel = context.WithTimeout(context.Background(), 100*time.Millisecond)
20
    defer cancel()
21

22
    // 创建带截止时间的 context
23
    deadline := time.Now().Add(200 * time.Millisecond)
24
    ctx, cancel = context.WithDeadline(context.Background(), deadline)
25
    defer cancel()
26

27
    // 创建带值的 context
28
    ctx = context.WithValue(context.Background(), "key", "value")
29

30
    // 从 context 获取值
31
    value := ctx.Value("key")
32
    fmt.Println(value)
33

34
    // 检查 context 是否已取消
35
    select {
36
    case <-ctx.Done():
37
        fmt.Println("Context canceled:", ctx.Err())
38
    default:
39
        fmt.Println("Context still valid")
40
    }
41
}

Golang 错误控制#

延迟函数#

1
func main() {
2
  defer func() {
3
    fmt.Println("Done")
4
  }()
5
  fmt.Println("Working...")
6
}

Lambda defer#

1
func main() {
2
  var d = int64(0)
3
  defer func(d *int64) {
4
    fmt.Printf("& %v Unix Sec\n", *d)
5
  }(&d)
6
  fmt.Print("Done ")
7
  d = time.Now().Unix()
8
}

defer 函数使用当前值d，除非我们使用指针在 main 末尾获取最终值

Defer#

1
func main() {
2
  defer fmt.Println("Done")
3
  fmt.Println("Working...")
4
}

参见：Defer, panic and recover

Golang 方法(Methods)#

接收器#

1
//Go语言中的方法（Method）是一种作用于特定类型变量的函数。
2
//这种特定类型变量叫做接收者（Receiver）。
3
//接收者的概念就类似于其他语言中的 this 或者 self。
4
//方法的定义格式如下：
5
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
6
    函数体
7
}
8
// 其中，
9
//     1.接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名
10
//的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量
11
// 应该命名为 p，Connector类型的接收者变量应该命名为c等。
12
//     2.接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
13
//     3.方法名、参数列表、返回参数：具体格式与函数定义相同。
14
type Vertex struct {
15
  X, Y float64
16
}
17

18
func (v Vertex) Abs() float64 {
19
  return math.Sqrt(v.X * v.X + v.Y * v.Y)
20
}
21
func (v Vertex) valuechange() float64 {
22
  v.X += 1
23
  return v.X
24
}
25
func (v *Vertex) pointerchange() float64 {
26
  v.X += 1
27
  return v.X
28
}
29
func main() {
30
  v := Vertex{1, 2}
31
  v.Abs()
32

33
  v = Vertex{1, 2}
34
  fmt.Println(v.valuechange())  // 2
35
  fmt.Println(v)                // {1 2}
36

37
  v = Vertex{1, 2}
38
  fmt.Println(v.pointerchange())// 2
39
  fmt.Println(v)                // {2 2}
40
}
41
//如果在方法里修改receiver的值要对caller生效，使用 pointer receiver。

参见：Methods，指针接收器

方法表达式#

方法表达式相当于提供一种语法将类型方法调用显式地转换为函数调用，接收者(receiver)必须显式地传递进去。

1
func (t T) Get(){
2
    return t.a
3
}
4
func (t *T) Set(i int){
5
    t.a = i
6
}
7
//表达式`T.Get`和`(*T).Set`被称为方法表达式，
8
//需要注意的是在方法表达式中编译器不会做自动转换。
9
//值调用会自动转换，表达式调用则不会，例如：
10
type Data struct{}
11
func (Data) TestValue () {}
12
func (*Data) TestPointer () {}
13
//声明一个类型变量a
14
var a Data= struct{}{}
15
//表达式调用编译器不会进行自动转换
16
Data.TestValue(a)
17
//Data.TestValue(&a)
18
(*Data).TestPointer (&a)
19
//Data.TestPointer(&a) //type Data has no method TestPointer
20
//值调用编译器会进行自动转换
21
y : = (&a).TestValue //编译器帮助转换a.TestValue
22
g : = a.TestPointer //会转换为(&a).TestPointer

组合结构的方法集#

内嵌字段的访问不需要使用全路径，只要保证命名是唯一的就可以，尽量避免同名。如果外层字段和内层字段有相同的方法，则使用简化模式访问外层方法会覆盖内层的方法。

1
x : = X{a: 1}
2
y : = Y{
3
    X : x ,
4
    b : 2 ,
5
}
6
z : = z {
7
    Y : y ,
8
    c : 3 ,
9
}//组合结构，内嵌字段

组合结构的方法集有如下规则：

若类型 T 包含匿名字段 S ，则 T 的方法集包含S的方法集
若类型 T 包含匿名字段 S ，则 T 的方法集包含 S 和S方法集
不管类型 T 中嵌入的匿名字段是 S 还是 *S ，*T 方法集总是包含 S 和 *S 方法集

Golang 接口(Interfaces)#

基本接口(Interfaces)#

1
type Shape interface {
2
  Area() float64
3
  Perimeter() float64
4
}

结构(Struct)#

1
type Rectangle struct {
2
  Length, Width float64
3
}

结构 Rectangle 通过实现其所有方法隐式实现接口 Shape

方法(Methods)#

1
func (r Rectangle) Area() float64 {
2
  return r.Length * r.Width
3
}
4
func (r Rectangle) Perimeter() float64 {
5
  return 2 * (r.Length + r.Width)
6
}

在 Shape 中定义的方法在Rectangle中实现

接口实例#

1
func main() {
2
  var r Shape = Rectangle{Length: 3, Width: 4}
3
  fmt.Printf("Type of r: %T, Area: %v, Perimeter: %v.", r, r.Area(), r.Perimeter())
4
}

Golang Embed (Go version >= 1.16)#

嵌入为string#

1
package main
2

3
import (
4
    _ "embed"
5
    "fmt"
6
)
7

8
//go:embed version.txt
9
var version string
10

11
func main() {
12
    fmt.Printf("version %q\n", version)
13
}

嵌入为[]byte#

1
package main
2
import (
3
    _ "embed"
4
    "fmt"
5
)
6

7
//go:embed version.txt
8
var versionByte []byte
9

10
func main() {
11
    fmt.Printf("version %q\n", string(versionByte))
12
}

嵌入为embed.FS#

1
//go:embed hello.txt
2
var f embed.FS
3
func main() {
4
  data, _ := f.ReadFile("hello.txt")
5
  fmt.Println(string(data))
6
}

嵌入多个文件#

1
//go:embed hello.txt
2
//go:embed hello2.txt
3
var f embed.FS
4
func main() {
5
  data, _ := f.ReadFile("hello.txt")
6
  fmt.Println(string(data))
7
  data, _ = f.ReadFile("hello2.txt")
8
  fmt.Println(string(data))
9
}

嵌入子文件夹下的文件#

1
//go:embed p/hello.txt p/hello2.txt
2
var f embed.FS
3
func main() {
4
  data, _ := f.ReadFile("p/hello.txt")
5
  fmt.Println(string(data))
6
  data, _ = f.ReadFile("p/hello2.txt")
7
  fmt.Println(string(data))
8
}

同一个文件嵌入为多个变量#

1
//go:embed hello.txt
2
var s string
3
//go:embed hello.txt
4
var s2 string
5
func main() {
6
  fmt.Println(s)
7
  fmt.Println(s2)
8
}

匹配模式#

1
//go:embed p/*
2
var f embed.FS
3
func main() {
4
  data, _ := f.ReadFile("p/.hello.txt")
5
  fmt.Println(string(data))
6
  data, _ = f.ReadFile("p/q/.hi.txt") // 没有嵌入 p/q/.hi.txt
7
  fmt.Println(string(data))
8
}

Golang 泛型 (Go version >= 1.18)#

泛型类型#

1
type S[T int|float32|float64 ] []T
2
       ┬  ────────┬────────
3
       ┆          ╰─── 2. 类型约束
4
       ╰────────────── 1. 类型形参

可以使用类型实参 int 或 string 实例化

1
type MyMap[K int|string, V float32 | float64] map[K]V
2

3
var a MyMap[string, float64] = map[string]float64{
4
    "jack_score": 9.6,
5
    "bob_score":  8.4,
6
}

匿名结构体不支持泛型
匿名函数不支持泛型

泛型函数#

任意类型

1
func Add[T any](a,b T) T {
2
    return  a+b
3
}

对类型进行约束

1
func Add[T string | int | int8](a,b T) T {
2
    return  a+b
3
}

类型嵌套

1
type WowStruct[T int | float32, S []T] struct {
2
    Data     S
3
    MaxValue T
4
    MinValue T
5
}
6

7
var ws WowStruct[int, []int]

泛型函数中进行类型声明 (go version >= 1.20)

1
func F[T1 any]() {
2
    type x struct{}
3
    type y = x
4
}

泛型约束#

通过接口实现

1
type Addable interface{
2
    type int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex64, complex128, string
3
}
4

5
func Add[T Addable](a,b T) T {
6
    return  a+b
7
}

使用 ~ 符号

1
type Int interface {
2
    ~int | ~int8 | ~int16 | ~int32 | ~int64
3
}
4

5
type Uint interface {
6
    ~uint | ~uint8 | ~uint16 | ~uint32
7
}
8
type Float interface {
9
    ~float32 | ~float64
10
}
11

12
type Slice[T Int | Uint | Float] []T
13

14
var s Slice[int] // 正确
15

16
type MyInt int
17
var s2 Slice[MyInt]  // MyInt底层类型是int，所以可以用于实例化
18

19
type MyMyInt MyInt
20
var s3 Slice[MyMyInt]  // 正确。MyMyInt 虽然基于 MyInt ，但底层类型也是int，所以也能用于实例化
21

22
type MyFloat32 float32  // 正确
23
var s4 Slice[MyFloat32]

使用 ~ 时的限制：

~后面的类型不能为接口
~后面的类型必须为基本类型

泛型 Receiver#

定义普通类型支持泛型

1
type MySlice[T int | float32] []T
2

3
func (s MySlice[T]) Sum() T {
4
    var sum T
5
    for _, value := range s {
6
        sum += value
7
    }
8
    return sum
9
}

结构体支持泛型

1
type A[T int | float32 | float64] struct {
2
}
3

4
func (receiver A[T]) Add(a T, b T) T {
5
    return a + b
6
}

泛型接口#

1
type Uint interface { // 接口 Uint 中有类型，所以是一般接口
2
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
3
}
4

5
type ReadWriter interface {  // ReadWriter 接口既有方法也有类型，所以是一般接口
6
    ~string | ~[]rune
7

8
    Read(p []byte) (n int, err error)
9
    Write(p []byte) (n int, err error)
10
}

一般接口类型不能用来定义变量，只能用于泛型的类型约束中

杂项#

关键字(Keywords)#

break
default
func
interface
select
case
defer
go
map
struct
chan
else
goto
package
switch
const
fallthrough
if
range
type
continue
for
import
return
var

运算符和标点符号#


`+`	`&`	`+=`	`&=`	`&&`	`==`	`!=`	`(`	`)`
`-`	`\|`	`-=`	`\|=`	`\|\|`	`<`	`<=`	`[`	`]`
`*`	`^`	`*=`	`^=`	`<-`	`>`	`>=`	`{`	`}`
`/`	`<<`	`/=`	`<<=`	`++`	`=`	`:=`	`,`	`;`
`%`	`>>`	`%=`	`>>=`	`--`	`!`	`...`	`.`	`:`
	`&^`	`&^=`

Go 命令#

Go 编译器命令#

:-	—
`go command [参数]`	go 命令 [参数]
`go build`	编译包和依赖包
`go clean`	移除对象和缓存文件
`go doc`	显示包的文档
`go env`	打印go的环境变量信息
`go bug`	报告bug
`go fix`	更新包使用新的api
`go fmt`	格式规范化代码
`go generate`	通过处理资源生成go文件
`go get`	下载并安装包及其依赖
`go install`	编译和安装包及其依赖
`go list`	列出所有包
`go run`	编译和运行go程序
`go test`	测试
`go tool`	运行给定的go工具
`go version`	显示go当前版本
`go vet`	发现代码中可能的错误

ENV#

:-	—
`GOOS`	编译系统
`GOARCH`	编译arch
`GO111MODULE`	gomod开关
`GOPROXY`	go代理 https://goproxy.io https://goproxy.cn https://mirrors.aliyun.com/goproxy/
`GOSSAFUNC`	生成 `SSA.html` 文件，展示代码优化的每一步 `GOSSAFUNC=func_name go build`

Module#

:-	—
`go mod init`	初始化当前文件夹，创建go.mod文件
`go mod download`	下载依赖的module到本地
`go mod tidy`	增加缺少的module，删除无用的module
`go mod vendor`	将依赖复制到vendor下
文件 `go.mod`	依赖列表和版本约束
文件 `go.sum`	记录 `module` 文件 `hash` 值，用于安全校验

另见#

Devhints (devhints.io)
A tour of Go (tour.golang.org)
Golang wiki (github.com)
Effective Go (golang.org)
Go by Example (gobyexample.com)
Awesome Go (awesome-go.com)
JustForFunc Youtube (youtube.com)
Style Guide (github.com)