Go 语言速查表

Go 语言速查表

这不是教程，是字典。教程教你走路，字典只在你卡住时递上一根拐杖。所以本页写得密、写得短、写得没什么耐心——每一条都假设你已经会编程，只是记不清 Go 里这个动作该怎么写。

风格上参考 Rust Language Cheat Sheet，但内容完全按 Go 重写：Go 没有泛型继承、没有异常、没有析构函数，却有一等公民的 goroutine、隐式接口、值语义切片，还有一整套只有 go 命令才有的工程化约定。照搬没有意义，该不一样的地方就让它不一样。

语言版本基线：Go 1.27.1（写作时本机工具链实际版本）。凡是较新版本才引入的特性，都会当场标注 🆕 并写明起始版本；示例一律在该版本下实跑验证。

图例说明

关于 // 输出:：标的是这段代码真实跑出来的结果，全部在 Go 1.27.1 / darwin/arm64 下实跑核对。行尾的中文注解只是给人看的，不属于输出内容。

全表地图

19 页不是随便切的，它按「写代码时的思维路径」分层：从怎么跑起来，到语言主干，再到并发与工程化。

flowchart TB
    ROOT(["Go 速查表"])

    subgraph L1["① 起步层：让代码跑起来"]
        A1["01 起步与工具链<br/>go 命令 / 模块 / 交叉编译"]
        A2["02 词法与语法骨架<br/>关键字 / 运算符 / 命名"]
    end

    subgraph L2["② 语言主干：类型、控制、函数"]
        B1["03 类型与零值"]
        B2["04 变量·常量·iota"]
        B3["05 语句与控制流"]
        B4["06 函数·方法·defer"]
    end

    subgraph L3["③ 数据与抽象"]
        C1["07 数组·切片·映射·结构体"]
        C2["08 接口与嵌入"]
        C3["09 错误处理"]
        C4["10 泛型"]
    end

    subgraph L4["④ 运行时与并发"]
        D1["11 内存·指针·unsafe"]
        D2["12 goroutine 与 channel"]
        D3["13 sync·atomic·context"]
        D4["18 并发模式"]
    end

    subgraph L5["⑤ 标准库与工程化"]
        E1["14 strings 与数字"]
        E2["15 io·fs·time"]
        E3["16 编码·日志·slog"]
        E4["17 测试"]
        E5["19 陷阱与惯用法"]
    end

    ROOT --> L1 --> L2 --> L3 --> L4 --> L5

学习路径

如果你只有半小时，按这条线看；如果只是查一个语法，直接翻目录。

flowchart LR
    S(["开始"]) --> Q1{"你会写 Go 吗？"}
    Q1 -- "不会，从别的语言来" --> P1["02 → 03 → 05 → 06<br/>先能读懂语法"]
    Q1 -- "会一点，总写错" --> P2["19 陷阱 → 07 切片/映射<br/>先止血"]
    Q1 -- "会写，要并发" --> P3["12 → 13 → 18<br/>goroutine 到模式"]
    Q1 -- "会写，要上线" --> P4["17 测试 → 01 工具链<br/>→ 16 日志"]
    P1 --> DONE(["能干活"])
    P2 --> DONE
    P3 --> DONE
    P4 --> DONE

目录导航

你好，Go

先让第一行代码跑起来。Go 的设计目标之一就是「装上就能编译」，从 1.16 起模块模式已是默认，不再需要 GOPATH。

• ① 单文件直跑
• ② 正规模块
• ③ 边写边测

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// hello.go
package main

import "fmt"

func main() {
	fmt.Println(greet("世界"))
}

// greet 被下一节的测试复用，所以单独抽出来
func greet(name string) string {
	return "Hello, " + name
}

1
2

$ go run hello.go
Hello, 世界

1
2
3
4
5
6
7

$ mkdir demo && cd demo
$ go mod init example.com/demo
go: creating new go.mod: module example.com/demo
$ cat go.mod
module example.com/demo

go 1.27.1

1
2
3

$ go build -o demo .
$ ./demo
Hello, 世界

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// hello_test.go
package main

import "testing"

func TestHello(t *testing.T) {
	got := greet("世界")
	want := "Hello, 世界"
	if got != want {
		t.Errorf("greet() = %q, want %q", got, want)
	}
}

1
2

$ go test ./...
ok  	example.com/demo	0.002s

15 条最高频速查

这 15 条是「一天要用十次」级别的。每条都能在对应章节里找到完整展开。

Go 的取舍

Go 不是「更好的 C++」，它是一套明确取舍：用表达力换编译速度与工程一致性。

• Go 擅长什么
• Go 不擅长什么
• 和邻居比

安装与验证

• macOS
• Linux
• Windows
• 代理与校验

1
2
3
4

$ brew install go
# 或用官方安装包：https://go.dev/dl/
$ go version
go version go1.27.1 darwin/arm64

1
2
3
4
5

# 官方压缩包（推荐，版本可控）
curl -LO https://go.dev/dl/go1.27.1.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.27.1.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin   # 写进 ~/.zshrc 或 ~/.bashrc
go version

1
2
3

winget install GoLang.Go
# 或下载官方 .msi 安装包，会自动配置 PATH
go version

1
2
3
4

$ go env -w GOPROXY=https://goproxy.cn,direct
$ go env -w GOSUMDB=sum.golang.org
$ go env GOPROXY
https://goproxy.cn,direct

装完做一次「四连验证」，四项全过说明工具链完好：

1

$ go version && go env GOROOT GOPATH && go vet ./... && go test ./...

Go 程序是怎么变成可执行文件的

理解这条流水线，你才能在「报错不知道在哪一步」时定位问题。

flowchart LR
    SRC["hello.go<br/>源码"] -->|"go build"| COMPILE
    MOD["go.mod / go.sum<br/>依赖清单"] --> COMPILE

    subgraph COMPILE["编译链路（go 命令自动调度）"]
        direction TB
        P["compile<br/>→ .a 归档"] --> L["link<br/>→ 可执行文件"]
    end

    COMPILE --> CACHE[("构建缓存<br/>GOCACHE")]
    CACHE -.->|"命中则跳过"| COMPILE

    COMPILE --> BIN["demo<br/>静态二进制"]
    BIN -->|"go run"| RUN["直接执行"]
    BIN -->|"go install"| GOBIN["$GOBIN<br/>或 $GOPATH/bin"]

关键点只有两条：

1. 缓存是默认的：GOCACHE 命中时编译几乎是瞬间的，go build -a 可以强制全量重建（排查「本地能过 CI 不能过」时偶尔有用）。
2. go run 不落盘：它把二进制放进临时目录再执行，所以生产环境不要依赖它的产物路径。

术语速查

准备好了？从 01 起步与工具链 开始，或直接跳到你在找的那一页。