Go 速查表

本文翻译自我的英文博客，最新修订内容可随时参考：: Go Cheatsheet

以下是整理后的 Go 语言速查表，涵盖语法、依赖管理、数据类型、常用功能等核心知识点，结构清晰便于快速查阅：

一、语法规则

1. 导出规则
   • 首字母大写的 const/var/func/type 可被其他包访问（类似公共成员）。
   • 首字母小写为包内私有（类似私有成员）。
2. 代码格式
   • { 必须与语句同行（如 if condition {）。
   • 语句末尾无需分号（编译器自动处理）。
3. 注释
   • 行注释：// 单行注释
   • 块注释：/* 多行注释 */
4. 字符串拼接：使用 + 运算符。
5. 格式化输出：fmt.Printf("格式字符串", 值)，支持 %v（默认格式）、%+v（带字段名）等。

二、依赖管理

1. 环境变量

go env  // 查看环境变量
// 关键变量：
// GOROOT：Go 安装路径（存放标准库）
// GOPATH：项目路径（默认 `$HOME/go`，存放第三方库）

2. 工具对比

工具	特点
go get	下载第三方库到 GOPATH/src，依赖版本单一，易冲突
go vendor	将依赖复制到项目 vendor 目录，冗余但隔离，仍存在版本问题
go module	Go 1.11+ 推荐方案，通过 go.mod 管理版本，支持多版本共存

3. go module 常用命令

go mod init [模块名]       // 初始化模块
go mod tidy               // 整理依赖（添加缺失、移除无用）
go mod download           // 下载依赖到 `GOPATH/pkg/mod`

4. 依赖代理

GOPROXY='https://proxy.golang.org,direct'  // 优先使用代理，失败则访问原始源

三、数据类型

1. 基础类型默认值

类型	默认值
数值类型	0
字符串	""
布尔类型	false
指针/切片/映射等	nil

2. nil 适用类型

var (
    ptr *int       // 指针
    slc []int      // 切片
    m map[string]int // 映射
    ch chan int    // 通道
    fn func()      // 函数
    err error      // 错误
)

3. 值类型 vs 引用类型

类型	存储方式	复制行为	常见类型
值类型	直接存储值	复制值（地址不同）	整型、浮点型、字符串、数组
引用类型	存储值的地址	复制地址（共享数据）	指针、切片、映射、通道、函数、接口、结构体指针

四、变量与常量

1. 变量声明

// 标准声明
var name string = "value"
var a, b int = 1, 2

// 简短声明（仅限函数内）
x := 10        // 等价于 var x int = 10
s := "hello"   // 类型由编译器推断

// 多变量声明
var (
    user = "admin"
    pass = "123456"
)

2. 常量与 iota

// 普通常量
const Pi = 3.1415926

// iota 枚举（自增常量）
const (
    A = iota  // 0
    B         // 1（自动递增）
    C = 100   // 100（中断递增）
    D         // 100（继承上一值）
    E = iota  // 4（恢复递增，当前 iota 为 4）
)

五、运算符

运算符	说明	示例
&	取地址	ptr := &x
*	解引用（指针取值）	val := *ptr
<-	通道发送/接收数据	ch <- value
:=	简短变量声明	x := 20

六、流程控制

1. if 语句

if num := 9; num < 0 {
    fmt.Println("负数")
} else if num < 10 {
    fmt.Println("个位数") // 输出
} else {
    fmt.Println("多位数")
}

2. switch 语句

switch {
case age < 18:
    fmt.Println("未成年")
case age < 60:
    fmt.Println("成年")
default:
    fmt.Println("老年")
}

// 类型断言（判断接口类型）
switch v := x.(type) {
case int:
    fmt.Printf("x 是 int，值为 %d\n", v)
case string:
    fmt.Printf("x 是 string，值为 %s\n", v)
}

3. for 循环

// 标准循环
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 遍历切片/映射
nums := []int{1, 2, 3}
for idx, val := range nums {
    fmt.Printf("索引 %d，值 %d\n", idx, val)
}

m := map[string]int{"a": 1, "b": 2}
for key, value := range m {
    fmt.Printf("key: %s，value: %d\n", key, value)
}

4. select 语句（通道监听）

select {
case msg := <-ch1: // 从 ch1 接收数据
    fmt.Println("ch1:", msg)
case ch2 <- "hello": // 向 ch2 发送数据
    fmt.Println("ch2 发送成功")
default: // 无就绪通道时执行
    fmt.Println("无操作")
}

七、复合类型

1. 数组（固定长度）

var arr [3]int = [3]int{1, 2, 3} // 声明并初始化
fmt.Println(arr[0]) // 输出 1

2. 切片（动态数组）

// 创建切片
slc := make([]int, 5, 10) // 长度 5，容量 10
slc = []int{1, 2, 3}      // 简短声明

// 操作
slc = append(slc, 4)     // 添加元素（需重新赋值）
copy(dst, src)           // 复制切片
fmt.Println(len(slc))    // 长度
fmt.Println(cap(slc))    // 容量

3. 映射（键值对）

m := make(map[string]int) // 创建映射
m["one"] = 1              // 赋值
val, ok := m["two"]       // 取值（ok 检查存在性）
delete(m, "one")          // 删除键
fmt.Println(len(m))       // 键值对数量

八、函数与闭包

1. 函数声明

// 多返回值
func add(a, b int) (int, error) {
    return a + b, nil
}

// 可变参数（参数为切片）
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3) // 传递多个参数
sum([]int{1, 2, 3}...) // 传递切片（需用 ... 展开）

2. 闭包（匿名函数）

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

c := counter()
fmt.Println(c()) // 1
fmt.Println(c()) // 2

3. defer 语句（延迟执行）

func main() {
    defer fmt.Println(" deferred") // 函数返回前执行
    fmt.Println("main") // 先输出
}
// 输出顺序：main → deferred

九、指针与结构体

1. 指针操作

x := 10
ptr := &x        // 取地址
*ptr = 20        // 通过指针修改值
fmt.Println(x)   // 输出 20

2. 结构体

type User struct {
    Name string `json:"name"` // 字段标签（如 JSON 序列化）
    Age  int
}

// 值接收者方法（不修改原数据）
func (u User) GetName() string {
    return u.Name
}

// 指针接收者方法（可修改原数据）
func (u *User) SetAge(age int) {
    u.Age = age
}

u := User{"Alice", 20}
u.SetAge(21) // 通过指针修改年龄

十、错误处理

1. 错误接口

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零") // 返回错误对象
    }
    return a / b, nil
}

result, err := divide(10, 0)
if err != nil {
    fmt.Println("错误:", err) // 输出错误信息
    return
}

2. panic 与 recover（处理运行时错误）

func main() {
    defer func() {
        if r := recover(); r != nil { // 捕获 panic
            fmt.Println("恢复:", r)
        }
    }()
    panic("运行时错误") // 触发 panic
}

十一、常用标准库

1. 字符串操作（strings）

import "strings"

s := "hello world"
strings.Contains(s, "world") // true
strings.Split(s, " ")       // []string{"hello", "world"}
strings.ToUpper(s)          // "HELLO WORLD"

2. JSON 编解码（encoding/json）

type Data struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// 编码（结构体 → JSON）
data := Data{"Alice", 30}
jsonData, _ := json.Marshal(data)
fmt.Println(string(jsonData)) // {"name":"Alice","age":30}

// 解码（JSON → 结构体）
var result Data
json.Unmarshal(jsonData, &result)

3. 时间处理（time）

now := time.Now()
fmt.Println(now.Format("2006-01-02 15:04:05")) // 格式化时间

duration := time.Hour * 2 // 2 小时
fmt.Println(duration.Minutes()) // 120 分钟

4. 系统交互（os/exec）

import "os/exec"

// 执行系统命令
cmd := exec.Command("ls", "-l")
output, _ := cmd.CombinedOutput()
fmt.Println(string(output)) // 输出命令结果

十二、关键概念速记

概念	要点
导出规则	首字母大写可被其他包访问，小写为包内私有
切片 vs 数组	切片是动态数组（长度可变），数组长度固定
值类型复制	复制值本身，新变量与原变量地址不同（如 int, string）
引用类型复制	复制地址，新旧变量共享数据（如 slice, map）
defer 执行顺序	按声明逆序执行（FILO），常用于资源清理（如关闭文件、释放锁）
接口断言	使用 x.(type) 或 switch 判断接口具体类型，避免运行时错误

如需进一步了解某个知识点（如并发模式、性能优化等），欢迎随时提问！完整内容请参考 Go Cheatsheet 获取最新修订。