Go 速查表
最后更新
Hello World 与程序结构
每个 Go 程序都属于某个包；入口点是 main 包中的 func main。
| 操作 | 语法 |
|---|---|
| 声明包 | package main |
| 导入包 | import "fmt" |
| 导入多个包 | import (\n "fmt"\n "os"\n) |
| 入口点 | func main() { ... } |
| 输出一行 | fmt.Println("Hello, World!") |
| 格式化输出 | fmt.Printf("%d items\n", n) |
| 运行文件 | go run main.go |
| 编译出可执行文件 | go build |
变量与类型
Go 是静态类型语言，但可以用 := 推断类型。
| 操作 | 语法 |
|---|---|
| 带类型声明 | var age int = 30 |
| 类型推断声明 | var name = "Ada" |
| 短变量声明 | count := 0 |
| 一次声明多个 | x, y := 1, 2 |
| 常量 | const Pi = 3.14 |
| 零值 | 0, "", false, nil |
| 基本类型 | int, float64, string, bool, byte, rune |
| 类型转换 | f := float64(i) |
流程控制
Go 只有一个循环关键字 for，条件两边也不用加圆括号。
| 操作 | 语法 |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| 带初始化语句的 if | if v, ok := m[k]; ok { ... } |
| for 循环（C 风格） | for i := 0; i < 10; i++ { ... } |
| 类似 while 的循环 | for x < 100 { ... } |
| 无限循环 | for { ... } |
| 用 range 遍历切片 | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| 不带表达式的 switch | switch { case x > 0: ... } |
| Break / continue | break, continue |
函数
函数是一等值，并且可以返回多个结果。
| 操作 | 语法 |
|---|---|
| 基本函数 | func add(a int, b int) int { return a + b } |
| 参数共用类型 | func add(a, b int) int { ... } |
| 多个返回值 | func divmod(a, b int) (int, int) { return a / b, a % b } |
| 命名返回值 | func split(sum int) (x, y int) { x = sum / 2; return } |
| 可变参数函数 | func sum(nums ...int) int { ... } |
| 匿名函数 | f := func() { ... } |
| 闭包 | func counter() func() int { ... } |
| Defer（在函数返回时执行） | defer file.Close() |
切片与数组
数组的长度是固定的；切片是建立在数组之上的动态视图。
| 操作 | 语法 |
|---|---|
| 固定长度的数组 | var a [3]int |
| 切片字面量 | nums := []int{1, 2, 3} |
| 用 make 创建切片 | s := make([]int, 0, 10) |
| 追加元素 | s = append(s, 4) |
| 长度 / 容量 | len(s), cap(s) |
| 对切片再切片 | s[1:3] |
| 复制 | copy(dst, src) |
| 遍历 | for i, v := range s { ... } |
Map
map 是 Go 内置的哈希表。
| 操作 | 语法 |
|---|---|
| 用 make 创建 map | m := make(map[string]int) |
| map 字面量 | m := map[string]int{"a": 1, "b": 2} |
| 设置值 | m["c"] = 3 |
| 获取值 | v := m["a"] |
| 检查键是否存在 | v, ok := m["x"] |
| 删除键 | delete(m, "a") |
| 长度 | len(m) |
| 遍历 | for k, v := range m { ... } |
结构体与方法
结构体把字段组织在一起；方法通过接收者附加行为。
| 操作 | 语法 |
|---|---|
| 定义结构体 | type Point struct { X, Y int } |
| 创建实例 | p := Point{X: 1, Y: 2} |
| 访问字段 | p.X |
| 指向结构体的指针 | p := &Point{1, 2} |
| 值接收者方法 | func (p Point) Dist() float64 { ... } |
| 指针接收者方法 | func (p *Point) Move(dx int) { p.X += dx } |
| 嵌入结构体 | type Circle struct { Point; R int } |
| 结构体标签 | Name string 加上用反引号括起来的 json:"name" 标签 |
接口
接口是隐式实现的：只要类型有对应的方法，就满足这个接口。
| 操作 | 语法 |
|---|---|
| 定义接口 | type Shape interface { Area() float64 } |
| 实现接口（隐式） | func (c Circle) Area() float64 { ... } |
| 空接口（any） | var x interface{} 或 var x any |
| 类型断言 | s, ok := x.(string) |
| 类型 switch | switch v := x.(type) { case int: ... } |
| Stringer 接口 | func (p Point) String() string { ... } |
Goroutine 与通道
goroutine 是轻量级线程；通道在它们之间传递值。
| 操作 | 语法 |
|---|---|
| 启动 goroutine | go doWork() |
| 创建通道 | ch := make(chan int) |
| 带缓冲的通道 | ch := make(chan int, 5) |
| 向通道发送 | ch <- 42 |
| 从通道接收 | v := <-ch |
| 关闭通道 | close(ch) |
| 用 range 遍历通道 | for v := range ch { ... } |
| 用 select 监听多个通道 | select { case v := <-ch: ...; default: ... } |
| WaitGroup | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| 互斥锁 | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
错误处理
Go 把错误作为值返回，没有异常机制。
| 操作 | 语法 |
|---|---|
| 返回错误 | func read() (string, error) { return "", err } |
| 检查错误 | if err != nil { return err } |
| 创建错误 | errors.New("not found") |
| 格式化错误 | fmt.Errorf("bad id %d", id) |
| 包装错误 | fmt.Errorf("load: %w", err) |
| 解包 / 匹配 | errors.Is(err, os.ErrNotExist) |
| 按类型匹配 | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
最常用的 Go 语法，全都在这一页。这份 Go 速查表是核心语言的快速参考：变量和类型、切片和 map、结构体和接口，还有让 Golang 在并发上大放异彩的 goroutine 和通道。
这里的内容都是标准 Go，可以用官方工具链编译。需要什么就复制什么，也可以在 Go 在线编辑器里直接运行每个代码片段，无需安装。正在学 Go？Coddy 的免费交互式 Go 课程会一步步讲解切片、结构体、接口和 goroutine。
Go 速查表常见问题
这份 Go 速查表免费吗？
免费。这份 Go 速查表完全免费，无需注册。把它加入书签，需要查切片操作、通道用法或结构体方法时随时回来看。
Go 中 := 和 var 有什么区别？
var x = 0 声明一个变量，在任何地方都能用，包括包级别。x := 0 是短变量声明：它同时完成声明和赋值，会推断类型，但只能在函数内部使用。需要显式类型或包级变量时用 var，写简洁的局部声明时用 :=。goroutine 和通道是什么？
goroutine 是由 Go 运行时管理的轻量级线程，写
go someFunc() 就能启动一个。通道是带类型的管道，让 goroutine 之间可以安全地通信：一个 goroutine 用 ch <- v 发送，另一个用 <-ch 接收。两者合起来构成了 Go 的核心并发模型，正如那句名言：“通过通信来共享内存。”可以在线练习 Go 吗？
可以。打开 Go 在线编辑器，就能在浏览器里运行这份速查表中的任意代码片段，无需安装 Go 工具链。想系统地学，Coddy 免费的交互式 Go 课程会带你一步步从变量和切片学到 goroutine 和通道。
这份速查表适合初学者吗？
适合。内容从最常用的主题（变量、流程控制、函数）排到进阶主题（goroutine、通道、错误处理），第一天就能用上前面的部分，再慢慢掌握其余内容。
相关资源
更多速查表
