Go 学习完整指南

# 创建工作目录
mkdir hello
cd hello

# 初始化模块
$ go mod init example/hello
go: creating new go.mod: module example/hello

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

# 运行程序
$ go run .
Hello, World!

package main

import "fmt"

import "rsc.io/quote"

func main() {
    fmt.Println(quote.Go())
}

# 添加依赖
$ go mod tidy
go: finding module for package rsc.io/quote
go: found rsc.io/quote in rsc.io/quote v1.5.2

# 运行
$ go run .
Don't communicate by sharing memory, share memory by communicating.

$ mkdir greetings
$ cd greetings
$ go mod init example.com/greetings
go: creating new go.mod: module example.com/greetings

package greetings

import "fmt"

// Hello 返回对指定人员的问候语
// 函数名首字母大写表示导出（对其他包可见）
func Hello(name string) string {
    // := 是声明并初始化变量的简写
    // %v 是格式化动词，用于插入变量值
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message
}

$ cd ..
$ mkdir hello
$ cd hello
$ go mod init example.com/hello

package main

import (
    "fmt"
    "example.com/greetings"
)

func main() {
    message := greetings.Hello("Gladys")
    fmt.Println(message)
}

$ go mod edit -replace example.com/greetings=../greetings
$ go mod tidy
$ go run .
Hi, Gladys. Welcome!

package greetings

import (
    "errors"
    "fmt"
)

// Hello 返回问候语和错误
func Hello(name string) (string, error) {
    // 名称为空时返回错误
    if name == "" {
        return "", errors.New("empty name")
    }

    // 正常返回问候语
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message, nil
}

package main

import (
    "fmt"
    "log"
    "example.com/greetings"
)

func main() {
    log.SetPrefix("greetings: ")
    log.SetFlags(0)

    // 多返回值：结果 + 错误
    message, err := greetings.Hello("")
    if err != nil {
        log.Fatal(err)  // 记录错误并退出程序
    }
    fmt.Println(message)
}

$ go run .
greetings: empty name
exit status 1

package greetings

import (
    "fmt"
    "math/rand/v2"
)

func Hello(name string) (string, error) {
    if name == "" {
        return name, fmt.Errorf("empty name")
    }
    // 调用 randomFormat 获取随机问候模板
    message := fmt.Sprintf(randomFormat(), name)
    return message, nil
}

// Hellos 返回将人名映射到问候语的 map
func Hellos(names []string) (map[string]string, error) {
    messages := make(map[string]string)
    for _, name := range names {
        message, err := Hello(name)
        if err != nil {
            return nil, err
        }
        messages[name] = message
    }
    return messages, nil
}

// randomFormat 从一组问候模板中随机返回一个
func randomFormat() string {
    formats := []string{
        "Hi, %v. Welcome!",
        "Great to see you, %v!",
        "Hail, %v! Well met!",
    }
    return formats[rand.IntN(len(formats))]
}

$ go run .
Great to see you, Gladys!
$ go run .
Hail, Gladys! Well met!

package greetings

import (
    "testing"
    "regexp"
)

// TestHelloName 验证 Hello 返回正确的问候语
func TestHelloName(t *testing.T) {
    name := "Gladys"
    want := regexp.MustCompile(`\b` + name + `\b`)
    msg, err := Hello("Gladys")
    if !want.MatchString(msg) || err != nil {
        t.Fatalf(`Hello("Gladys") = %q, %v, want match for %#q`, msg, err, want)
    }
}

// TestHelloEmpty 验证空名称时返回错误
func TestHelloEmpty(t *testing.T) {
    msg, err := Hello("")
    if msg != "" || err == nil {
        t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
    }
}

$ go test
PASS
ok      example.com/greetings   0.364s

$ go test -v  # 详细输出
=== RUN   TestHelloName
--- PASS: TestHelloName (0.00s)
=== RUN   TestHelloEmpty
--- PASS: TestHelloEmpty (0.00s)
PASS

# 编译为可执行文件
$ go build

# 安装到 $GOPATH/bin（默认为 ~/go/bin）
$ go install

# 初始化模块
go mod init example.com/mymodule

# 添加依赖
go get example.com/theirmodule@v1.3.4

# 获取最新版本
go get example.com/theirmodule@latest

# 同步依赖（添加缺失、移除未用的）
go mod tidy

# 列出所有依赖及最新版本
go list -m -u all

# 移除依赖
go mod tidy
go get example.com/theirmodule@none

# 使用本地未发布代码（replace 指令）
go mod edit -replace example.com/theirmodule=../theirmodule

# 使用私有代理
GOPROXY="https://proxy.example.com,direct"

# 添加工具依赖
go get -tool golang.org/x/tools/cmd/stringer

# 运行工具
go tool stringer

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

// album 表示唱片数据
type album struct {
    ID     string  `json:"id"`
    Title  string  `json:"title"`
    Artist string  `json:"artist"`
    Price  float64 `json:"price"`
}

// albums 初始化唱片数据
var albums = []album{
    {ID: "1", Title: "Blue Train", Artist: "John Coltrane", Price: 56.99},
    {ID: "2", Title: "Jeru", Artist: "Gerry Mulligan", Price: 17.99},
    {ID: "3", Title: "Sarah Vaughan and Clifford Brown", Artist: "Sarah Vaughan", Price: 39.99},
}

func main() {
    router := gin.Default()
    router.GET("/albums", getAlbums)        // 获取所有唱片
    router.GET("/albums/:id", getAlbumByID) // 按 ID 获取唱片
    router.POST("/albums", postAlbums)      // 添加新唱片

    router.Run("localhost:8080")
}

// getAlbums 以 JSON 返回所有唱片
func getAlbums(c *gin.Context) {
    c.IndentedJSON(http.StatusOK, albums)
}

// postAlbums 从请求体中解析 JSON 添加到唱片集
func postAlbums(c *gin.Context) {
    var newAlbum album
    if err := c.BindJSON(&newAlbum); err != nil {
        return
    }
    albums = append(albums, newAlbum)
    c.IndentedJSON(http.StatusCreated, newAlbum)
}

// getAlbumByID 按 ID 查找并返回唱片
func getAlbumByID(c *gin.Context) {
    id := c.Param("id")
    for _, a := range albums {
        if a.ID == id {
            c.IndentedJSON(http.StatusOK, a)
            return
        }
    }
    c.IndentedJSON(http.StatusNotFound, gin.H{"message": "album not found"})
}

# 初始化并运行
$ go mod init example/web-service-gin
$ go get .
$ go run .

# 使用 curl 测试
$ curl http://localhost:8080/albums
$ curl http://localhost:8080/albums/2

# 添加新唱片
$ curl http://localhost:8080/albums \
    --include \
    --header "Content-Type: application/json" \
    --request "POST" \
    --data '{"id": "4","title": "The Modern Sound of Betty Carter","artist": "Betty Carter","price": 49.99}'

go tool tour

// if 支持初始化子句
if err := file.Open("data.txt"); err != nil {
    log.Fatal("Failed to open file:", err)
}

// 不要悬挂 else — if 以 return 结束时省略 else
if err != nil {
    return err
}
// happy path 在左对齐位置

data, err := os.ReadFile(path)
if err != nil {
    return nil, fmt.Errorf("read file failed: %w", err)
}

// goroutine + channel 并发模式
func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch <-chan int) {
    for num := range ch {
        fmt.Println("Consumed:", num)
    }
}

func main() {
    ch := make(chan int)
    go producer(ch)
    consumer(ch)
}

package main

import "fmt"

func main() {
    fmt.Println("hello world")
}

# 直接运行
$ go run hello-world.go
hello world

# 编译为二进制文件
$ go build hello-world.go
$ ls
hello-world    hello-world.go

# 直接执行二进制文件
$ ./hello-world
hello world

package main

import "fmt"

func main() {
    // 字符串连接
    fmt.Println("go" + "lang")

    // 整数和浮点数运算
    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)

    // 布尔运算：与、或、非
    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

$ go run values.go
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

package main

import "fmt"

func main() {
    // var 声明一个或多个变量
    var a = "initial"
    fmt.Println(a)

    // 同时声明多个变量
    var b, c int = 1, 2
    fmt.Println(b, c)

    // 类型推断
    var d = true
    fmt.Println(d)

    // 未初始化的变量为零值
    var e int
    fmt.Println(e)

    // := 是声明并初始化的简写（仅限函数内使用）
    f := "apple"
    fmt.Println(f)
}

$ go run variables.go
initial
1 2
true
0
apple

package main

import (
    "fmt"
    "math"
)

// const 声明常量值
const s string = "constant"

func main() {
    fmt.Println(s)

    // const 语句也可以出现在函数体内
    const n = 500000000

    // 常量表达式以任意精度执行算术运算
    const d = 3e20 / n
    fmt.Println(d)

    // 数值常量在赋值时确定类型
    fmt.Println(int64(d))

    // 在需要特定类型的上下文中使用时会获得类型
    fmt.Println(math.Sin(n))
}

$ go run constant.go
constant
6e+11
600000000000
-0.28470407323754404

package main

import "fmt"

func main() {
    // 最基本的：单条件循环（类似 while）
    i := 1
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }

    // 经典的 初始化/条件/后续 for 循环
    for j := 0; j < 3; j++ {
        fmt.Println(j)
    }

    // range 遍历整数（Go 1.22+ 特性）
    for i := range 3 {
        fmt.Println("range", i)
    }

    // 不带条件的无限循环，直到 break
    for {
        fmt.Println("loop")
        break
    }

    // continue 跳过当前迭代
    for n := range 6 {
        if n%2 == 0 {
            continue
        }
        fmt.Println(n)
    }
}

$ go run for.go
1
2
3
0
1
2
range 0
range 1
range 2
loop
1
3
5

package main

import "fmt"

func main() {
    // 基本用法
    if 7%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

    // 可以没有 else
    if 8%4 == 0 {
        fmt.Println("8 is divisible by 4")
    }

    // 逻辑运算符
    if 8%2 == 0 || 7%2 == 0 {
        fmt.Println("either 8 or 7 are even")
    }

    // 语句可以放在条件前面，声明的变量在所有分支中可用
    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

$ go run if-else.go
7 is odd
8 is divisible by 4
either 8 or 7 are even
9 has 1 digit

package main

import (
    "fmt"
    "time"
)

func main() {
    // 基本 switch
    i := 2
    fmt.Print("Write ", i, " as ")
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }

    // 逗号分隔多个匹配条件
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("It's the weekend")
    default:
        fmt.Println("It's a weekday")
    }

    // 不带表达式的 switch（替代 if/else 链）
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
    }

    // 类型 switch：比较类型而非值
    whatAmI := func(i interface{}) {
        switch t := i.(type) {
        case bool:
            fmt.Println("I'm a bool")
        case int:
            fmt.Println("I'm an int")
        default:
            fmt.Printf("Don't know type %T\n", t)
        }
    }
    whatAmI(true)
    whatAmI(1)
    whatAmI("hey")
}

$ go run switch.go
Write 2 as two
It's a weekday
It's after noon
I'm a bool
I'm an int
Don't know type string

package main

import "fmt"

func main() {
    // 创建包含 5 个 int 的数组，默认零值
    var a [5]int
    fmt.Println("emp:", a)

    // 通过索引设置和获取值
    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

    // 内置 len 函数返回数组长度
    fmt.Println("len:", len(a))

    // 声明并初始化
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

    // 让编译器统计元素个数
    b = [...]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

    // 指定索引初始化（中间元素为零值）
    b = [...]int{100, 3: 400, 500}
    fmt.Println("idx:", b)

    // 二维数组
    var twoD [2][3]int
    for i := range 2 {
        for j := range 3 {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)

    // 直接初始化二维数组
    twoD = [2][3]int{
        {1, 2, 3},
        {1, 2, 3},
    }
    fmt.Println("2d: ", twoD)
}

$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
dcl: [1 2 3 4 5]
idx: [100 0 0 400 500]
2d:  [[0 1 2] [1 2 3]]
2d:  [[1 2 3] [1 2 3]]

package main

import (
    "fmt"
    "slices"
)

func main() {
    // 未初始化的 slice 为 nil，长度为 0
    var s []string
    fmt.Println("uninit:", s, s == nil, len(s) == 0)

    // 使用 make 创建非零长度的 slice
    s = make([]string, 3)
    fmt.Println("emp:", s, "len:", len(s), "cap:", cap(s))

    // 设置和获取值
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])
    fmt.Println("len:", len(s))

    // append 追加元素
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    // copy 复制 slice
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    // 切片操作 slice[low:high]
    l := s[2:5]
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

    // 声明并初始化
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    // slices 包提供的工具函数
    t2 := []string{"g", "h", "i"}
    if slices.Equal(t, t2) {
        fmt.Println("t == t2")
    }

    // 二维 slice（内层长度可以不同）
    twoD := make([][]int, 3)
    for i := range 3 {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := range innerLen {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

$ go run slices.go
uninit: [] true true
emp: [  ] len: 3 cap: 3
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
t == t2
2d:  [[0] [1 2] [2 3 4]]

package main

import (
    "fmt"
    "maps"
)

func main() {
    // 使用 make 创建空 map
    m := make(map[string]int)

    // 设置键值对
    m["k1"] = 7
    m["k2"] = 13
    fmt.Println("map:", m)

    // 取值
    v1 := m["k1"]
    fmt.Println("v1:", v1)

    // 键不存在时返回值类型的零值
    v3 := m["k3"]
    fmt.Println("v3:", v3)

    // len 返回键值对数量
    fmt.Println("len:", len(m))

    // delete 删除键值对
    delete(m, "k2")
    fmt.Println("map:", m)

    // clear 清空 map
    clear(m)
    fmt.Println("map:", m)

    // 可选的第二个返回值表示键是否存在
    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    // 声明并初始化
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)

    // maps 包提供的工具函数
    n2 := map[string]int{"foo": 1, "bar": 2}
    if maps.Equal(n, n2) {
        fmt.Println("n == n2")
    }
}

$ go run maps.go
map: map[k1:7 k2:13]
v1: 7
v3: 0
len: 2
map: map[k1:7]
map: map[]
prs: false
map: map[bar:2 foo:1]
n == n2

package main

import "fmt"

// plus 接受两个 int，返回它们的和
func plus(a int, b int) int {
    // Go 需要显式 return
    return a + b
}

// 连续相同类型的参数可以省略中间的类型名
func plusPlus(a, b, c int) int {
    return a + b + c
}

func main() {
    res := plus(1, 2)
    fmt.Println("1+2 =", res)

    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)
}

$ go run functions.go
1+2 = 3
1+2+3 = 6

package main

import "fmt"

// vals 返回两个 int
func vals() (int, int) {
    return 3, 7
}

func main() {
    // 多赋值接收多个返回值
    a, b := vals()
    fmt.Println(a)
    fmt.Println(b)

    // 使用空白标识符 _ 忽略不需要的值
    _, c := vals()
    fmt.Println(c)
}

$ go run multiple-return-values.go
3
7
7

package main

import "fmt"

// sum 接受任意数量的 int 参数
func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

func main() {
    // 单独参数调用
    sum(1, 2)
    sum(1, 2, 3)

    // 展开 slice 传入
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

$ go run variadic-functions.go
[1 2] 3
[1 2 3] 6
[1 2 3 4] 10

package main

import "fmt"

// intSeq 返回一个闭包，每次调用递增 i
func intSeq() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {
    nextInt := intSeq()

    // 每次调用更新捕获的 i
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())

    // 新闭包有独立的 i
    newInts := intSeq()
    fmt.Println(newInts())
}

$ go run closures.go
1
2
3
1

package main

import "fmt"

// fact 递归计算阶乘
func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}

func main() {
    fmt.Println(fact(7))

    // 匿名函数也需要先声明变量才能递归
    var fib func(n int) int
    fib = func(n int) int {
        if n < 2 {
            return n
        }
        return fib(n-1) + fib(n-2)
    }
    fmt.Println(fib(7))
}

$ go run recursion.go
5040
13

package main

import "fmt"

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

    // range 提供索引和值
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    // 遍历 map 的键值对
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // 只遍历 map 的键
    for k := range kvs {
        fmt.Println("key:", k)
    }

    // 遍历字符串的 Unicode 码点
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

$ go run range-over-built-in-types.go
sum: 9
index: 1
a -> apple
b -> banana
key: a
key: b
0 103
1 111

package main

import "fmt"

// zeroval 通过值传递，不改变原值
func zeroval(ival int) {
    ival = 0
}

// zeroptr 通过指针传递，改变原值
func zeroptr(iptr *int) {
    *iptr = 0
}

func main() {
    i := 1
    fmt.Println("initial:", i)

    zeroval(i)
    fmt.Println("zeroval:", i)  // 不变

    zeroptr(&i)
    fmt.Println("zeroptr:", i)  // 变为 0

    fmt.Println("pointer:", &i)  // 内存地址
}

$ go run pointers.go
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    const s = "สวัสดี"  // 泰语"你好"

    // 字符串长度（字节数）
    fmt.Println("Len:", len(s))

    // 原始字节值（十六进制）
    for i := 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
    fmt.Println()

    // 实际字符数（rune 数）
    fmt.Println("Rune count:", utf8.RuneCountInString(s))

    // range 自动解码 UTF-8
    for idx, runeValue := range s {
        fmt.Printf("%#U starts at %d\n", runeValue, idx)
    }

    // 使用 utf8.DecodeRuneInString 显式解码
    fmt.Println("\nUsing DecodeRuneInString")
    for i, w := 0, 0; i < len(s); i += w {
        runeValue, width := utf8.DecodeRuneInString(s[i:])
        fmt.Printf("%#U starts at %d\n", runeValue, i)
        w = width
        examineRune(runeValue)
    }
}

func examineRune(r rune) {
    if r == 't' {
        fmt.Println("found tee")
    } else if r == 'ส' {
        fmt.Println("found so sua")
    }
}