Golang编程完全指南

← 返回指南列表

Golang编程完全指南

一、Go语言概述

1.1 语言简介

Go(又称Golang)是由Google的Robert Griesemer、Rob Pike和Ken Thompson于2007年开始设计,并于2009年正式发布的开源编程语言。

设计目标:

  • 解决C++和Java等语言在大型项目开发中的编译速度慢、依赖管理复杂等问题
  • 提供一种兼具开发效率和执行性能的现代化语言
  • 天生为多核处理器和网络编程而设计

核心特性:

特性 说明
简洁性 语法精炼,关键字仅25个,无继承、无泛型(Go 1.18前)、无异常
并发原生支持 Goroutine(轻量级协程)和Channel,基于CSP模型
静态类型 编译时类型检查,类型安全
编译型 直接编译为机器码,无需虚拟机,启动快
垃圾回收 自动内存管理,降低内存泄漏风险
标准库丰富 内置HTTP、JSON、加密、数据库等常用功能

1.2 安装与配置

Linux 安装:

BASH
# 下载最新版本(以1.22为例)
wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz

# 解压到 /usr/local
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz

# 配置环境变量(添加到 ~/.bashrc 或 ~/.zshrc)
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

# 验证安装
go version

macOS 安装:

BASH
# Homebrew 安装
brew install go

Windows 安装:

CODE
下载 .msi 安装包,双击安装,自动配置环境变量

1.3 开发环境与IDE

IDE/编辑器 特点
VS Code + Go插件 最流行,免费,功能完善
GoLand JetBrains出品,功能最强大,商业软件
Vim/Neovim + vim-go 轻量高效,适合服务器环境

VS Code Go插件常用功能:

  • 代码自动补全(gopls)
  • 代码格式化(gofmt)
  • 静态分析(go vet)
  • 调试支持(delve)
  • 测试运行

1.4 Go项目结构

CODE
myproject/
├── go.mod              # 模块定义文件
├── go.sum              # 依赖校验文件
├── main.go             # 程序入口
├── cmd/                # 可执行程序入口
│   └── myapp/
│       └── main.go
├── internal/           # 私有包(不可被外部导入)
│   └── config/
│       └── config.go
├── pkg/                # 可被外部导入的公共库
│   └── utils/
│       └── helper.go
├── api/                # API定义(如protobuf)
├── configs/            # 配置文件
├── scripts/            # 构建脚本
├── test/               # 额外的测试数据
└── docs/               # 文档

1.5 第一个Go程序

GO
package main

import "fmt"

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

编译与运行:

BASH
# 直接运行
go run main.go

# 编译为可执行文件
go build -o hello main.go
./hello

# 交叉编译(Linux编译Windows可执行文件)
GOOS=windows GOARCH=amd64 go build -o hello.exe main.go

# 常用GOOS/GOARCH组合
# GOOS: linux, darwin, windows
# GOARCH: amd64, arm64, 386

1.6 版本历史

版本 发布时间 主要特性
Go 1.0 2012年3月 首个稳定版,兼容性承诺
Go 1.5 2015年8月 自举编译器(Go编译Go),并发GC
Go 1.11 2018年8月 Go Modules(依赖管理)
Go 1.13 2019年9月 错误包装(Error Wrapping)
Go 1.16 2021年2月 嵌入静态文件(embed)
Go 1.18 2022年3月 泛型(Generics)、模糊测试(Fuzzing)
Go 1.21 2023年8月 新的slices/maps包、结构化日志slog
Go 1.22 2024年2月 for循环变量语义改变、增强路由

二、基础语法详解

2.1 变量声明与初始化

Go语言提供多种变量声明方式,每种方式有其适用的场景。

GO
package main

import "fmt"

// 包级别变量(必须使用var声明)
var globalVar string = "全局变量"
var (
    name    string = "Go"
    version int    = 22
    debug   bool   = false
)

func main() {
    // 1. 标准声明:var 变量名 类型 = 值
    var a int = 10
    var b string = "hello"

    // 2. 类型推断:省略类型,由编译器推断
    var c = 3.14       // float64
    var d = true       // bool

    // 3. 短变量声明(仅函数内可用)::= 运算符
    e := 42
    f := "world"

    // 4. 只声明不赋值(使用零值)
    var g int      // 0
    var h string   // ""
    var i bool     // false
    var j float64  // 0.0

    // 5. 多变量声明
    x, y := 1, 2
    var m, n int = 3, 4

    fmt.Println(a, b, c, d, e, f, g, h, i, j, x, y, m, n)
}

零值(Zero Value)对照表:

类型 零值
int, int8, int16, int32, int64 0
uint, uint8, uint16, uint32, uint64 0
float32, float64 0.0
bool false
string “”
pointer, slice, map, channel, interface, function nil
struct 所有字段均为零值

2.2 常量

GO
package main

import "fmt"

// 单个常量
const PI = 3.1415926

// 批量声明常量
const (
    StatusOK       = 200
    StatusNotFound = 404
    StatusError    = 500
)

// iota:常量计数器(每行递增1)
const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

// iota 高级用法:位掩码
const (
    FlagRead   = 1 << iota  // 1  (0001)
    FlagWrite               // 2  (0010)
    FlagExecute             // 4  (0100)
)

// iota 跳过某个值
const (
    _        = iota  // 0 跳过
    KB       = 1 << (10 * iota)  // 1 << 10 = 1024
    MB                                   // 1 << 20
    GB                                   // 1 << 30
    TB                                   // 1 << 40
)

func main() {
    fmt.Println("PI:", PI)
    fmt.Println("Sunday:", Sunday, "Saturday:", Saturday)
    fmt.Println("FlagRead:", FlagRead, "FlagWrite:", FlagWrite)
    fmt.Printf("KB=%d, MB=%d, GB=%d\n", KB, MB, GB)
}

2.3 基本数据类型

Go语言的数据类型体系完整,每种类型都有明确的取值范围和内存占用。

GO
package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // ========== 整型 ==========
    var i8 int8 = 127          // -128 ~ 127,占用1字节
    var i16 int16 = 32767      // 占用2字节
    var i32 int32 = 2147483647 // 占用4字节
    var i64 int64 = 9223372036854775807  // 占用8字节

    var ui8 uint8 = 255        // 0 ~ 255,占用1字节
    var ui16 uint16 = 65535    // 占用2字节

    // int/uint 长度依赖于平台(32位或64位)
    var n int = 100

    // byte 是 uint8 的别名
    var b byte = 'A'  // 等同于 var b uint8 = 65

    // rune 是 int32 的别名(表示Unicode码点)
    var r rune = '中'  // 等同于 var r int32 = 20013

    fmt.Printf("int8: 值=%d, 大小=%d字节\n", i8, unsafe.Sizeof(i8))
    fmt.Printf("uint8: 值=%d, 大小=%d字节\n", ui8, unsafe.Sizeof(ui8))
    fmt.Printf("byte: 值=%d(字符%c), 大小=%d字节\n", b, b, unsafe.Sizeof(b))
    fmt.Printf("rune: 值=%d(字符%c), 大小=%d字节\n", r, r, unsafe.Sizeof(r))
    fmt.Printf("int: 值=%d, 大小=%d字节\n", n, unsafe.Sizeof(n))

    // ========== 浮点型 ==========
    var f32 float32 = 3.141592653589793  // ~6位有效数字
    var f64 float64 = 3.141592653589793  // ~15位有效数字
    fmt.Printf("float32: %f, float64: %.15f\n", f32, f64)

    var nan = float64(0) / float64(0)    // NaN
    var inf = float64(1) / float64(0)    // 正无穷
    fmt.Printf("NaN: %v, +Inf: %v\n", nan, inf)

    // ========== 复数 ==========
    var c64 complex64 = 1 + 2i    // 实部和虚部都是float32
    var c128 complex128 = 3 + 4i  // 实部和虚部都是float64
    fmt.Printf("complex64: %v, 实部=%f, 虚部=%f\n",
        c64, real(c64), imag(c64))
    fmt.Printf("complex128: %v\n", c128)

    // ========== 布尔型 ==========
    var flag bool = true
    fmt.Println("bool:", flag)

    // ========== 字符串 ==========
    var s1 string = "Hello, Go!"
    var s2 string = `多行字符串
可以包含"引号"
和换行符`
    fmt.Println("string1:", s1)
    fmt.Println("string2:", s2)
    fmt.Printf("s1长度: %d字节\n", len(s1))

    // 字符串不可变(immutable)
    // s1[0] = 'h'  // 编译错误!

    // 遍历字符串(按字节 vs 按rune)
    chinese := "你好Go"
    fmt.Println("按字节遍历:")
    for i := 0; i < len(chinese); i++ {
        fmt.Printf("%x ", chinese[i])
    }
    fmt.Println()
    fmt.Println("按Unicode字符遍历:")
    for i, ch := range chinese {
        fmt.Printf("索引%d: %c ", i, ch)
    }
    fmt.Println()
}

2.4 类型转换

Go语言不支持隐式类型转换,所有类型转换必须显式进行。

GO
package main

import (
    "fmt"
    "strconv"
)

func main() {
    // ========== 数值类型转换 ==========
    var a int = 100
    var b int64 = int64(a)      // int -> int64
    var c float64 = float64(a)   // int -> float64
    var d uint = uint(a)         // int -> uint

    fmt.Println(a, b, c, d)

    // 注意:从大范围到小范围转换可能溢出
    var big int16 = 300
    var small int8 = int8(big)   // 300 > 127,溢出!结果为44
    fmt.Printf("big=%d, small=%d(溢出)\n", big, small)

    // ========== 字符串与数值转换 ==========
    // 数值 -> 字符串(使用 strconv 包)
    s1 := strconv.Itoa(42)                    // int -> string: "42"
    s2 := strconv.FormatFloat(3.14159, 'f', 2, 64)  // float -> string: "3.14"
    s3 := strconv.FormatBool(true)            // bool -> string: "true"
    fmt.Println(s1, s2, s3)

    // 字符串 -> 数值
    n1, err1 := strconv.Atoi("42")
    n2, err2 := strconv.ParseFloat("3.14", 64)
    n3, err3 := strconv.ParseBool("true")
    fmt.Println(n1, err1, n2, err2, n3, err3)

    // ========== 字符串与字节切片转换 ==========
    str := "Hello"
    bytes := []byte(str)        // string -> []byte
    str2 := string(bytes)       // []byte -> string
    fmt.Println(bytes, str2)

    // ========== 类型断言(用于interface{})==========
    var val interface{} = "hello"
    s, ok := val.(string)       // 类型断言
    if ok {
        fmt.Println("字符串值:", s)
    }

    // 使用 fmt.Sprintf 进行通用转换
    result := fmt.Sprintf("%d-%s-%.2f", 2024, "Jan", 3.14159)
    fmt.Println(result)
}

2.5 运算符

GO
package main

import "fmt"

func main() {
    // ========== 算术运算符 ==========
    a, b := 10, 3
    fmt.Printf("a+b=%d, a-b=%d, a*b=%d, a/b=%d, a%%b=%d\n",
        a+b, a-b, a*b, a/b, a%b)
    // 注意:整数除法截断小数部分,10/3=3

    // ========== 比较运算符 ==========
    fmt.Printf("a==b: %v, a!=b: %v, a>b: %v, a<b: %v\n",
        a == b, a != b, a > b, a < b)

    // ========== 逻辑运算符 ==========
    x, y := true, false
    fmt.Printf("x&&y=%v, x||y=%v, !x=%v\n", x && y, x || y, !x)
    // 短路求值:&& 遇到false停止,|| 遇到true停止

    // ========== 位运算符 ==========
    var m uint = 0b1100  // 12
    var n uint = 0b1010  // 10
    fmt.Printf("m&n=%b(%d)\n", m&n, m&n)    // 按位与:1000(8)
    fmt.Printf("m|n=%b(%d)\n", m|n, m|n)    // 按位或:1110(14)
    fmt.Printf("m^n=%b(%d)\n", m^n, m^n)    // 按位异或:0110(6)
    fmt.Printf("m<<1=%b(%d)\n", m<<1, m<<1) // 左移:11000(24)
    fmt.Printf("m>>1=%b(%d)\n", m>>1, m>>1) // 右移:110(6)

    // ========== 赋值运算符 ==========
    num := 10
    num += 5   // num = 15
    num -= 3   // num = 12
    num *= 2   // num = 24
    num /= 4   // num = 6
    num %= 4   // num = 2
    fmt.Println("num:", num)

    // ========== 指针运算符 ==========
    value := 42
    ptr := &value       // & 取地址
    fmt.Printf("value=%d, ptr=%p, *ptr=%d\n", value, ptr, *ptr)
    *ptr = 100          // * 解引用(修改指针指向的值)
    fmt.Printf("修改后 value=%d\n", value)

    // ========== 运算符优先级(从高到低)==========
    // 1: * / % << >> & &^
    // 2: + - | ^
    // 3: == != < <= > >=
    // 4: &&
    // 5: ||
    result := 10 + 5*2   // 20(乘法优先于加法)
    fmt.Println("10+5*2 =", result)
}

2.6 控制流

GO
package main

import "fmt"

func main() {
    // ========== if 语句 ==========
    score := 85

    // 基本形式
    if score >= 90 {
        fmt.Println("优秀")
    } else if score >= 80 {
        fmt.Println("良好")
    } else if score >= 60 {
        fmt.Println("及格")
    } else {
        fmt.Println("不及格")
    }

    // 带初始化语句的 if(初始化变量作用域仅限于if块)
    if password := "secret123"; len(password) < 8 {
        fmt.Println("密码太短")
    } else {
        fmt.Println("密码长度符合要求")
    }
    // password 在此不可访问

    // ========== switch 语句 ==========
    // Go的switch不需要break,默认自动break
    day := 3
    switch day {
    case 1:
        fmt.Println("星期一")
    case 2:
        fmt.Println("星期二")
    case 3:
        fmt.Println("星期三")
    default:
        fmt.Println("其他")
    }

    // 多值匹配
    switch day {
    case 1, 2, 3, 4, 5:
        fmt.Println("工作日")
    case 6, 7:
        fmt.Println("周末")
    }

    // 无表达式的switch(替代if-else链)
    age := 25
    switch {
    case age < 18:
        fmt.Println("未成年")
    case age >= 18 && age < 60:
        fmt.Println("成年人")
    default:
        fmt.Println("老年人")
    }

    // fallthrough:强制执行下一个case
    n := 1
    switch n {
    case 1:
        fmt.Println("one")
        fallthrough
    case 2:
        fmt.Println("two")  // case 1 执行后,case 2 也会执行
    default:
        fmt.Println("default")
    }

    // 类型switch
    var val interface{} = "hello"
    switch v := val.(type) {
    case int:
        fmt.Printf("整数: %d\n", v)
    case string:
        fmt.Printf("字符串: %s\n", v)
    case bool:
        fmt.Printf("布尔值: %v\n", v)
    default:
        fmt.Printf("未知类型: %T\n", v)
    }

    // ========== for 循环 ==========
    // 标准C风格for循环
    for i := 0; i < 5; i++ {
        fmt.Print(i, " ")
    }
    fmt.Println()

    // 省略初始化语句
    j := 0
    for ; j < 5; j++ {
        fmt.Print(j, " ")
    }
    fmt.Println()

    // 省略后置语句(类似while循环)
    k := 0
    for k < 5 {
        fmt.Print(k, " ")
        k++
    }
    fmt.Println()

    // 无限循环
    // for {
    //     // 使用 break 退出
    // }

    // for range:遍历数组/切片/Map/字符串/Channel
    fruits := []string{"apple", "banana", "cherry"}
    for index, fruit := range fruits {
        fmt.Printf("索引: %d, 水果: %s\n", index, fruit)
    }

    // 忽略索引
    for _, fruit := range fruits {
        fmt.Println(fruit)
    }

    // 仅使用索引
    for index := range fruits {
        fmt.Println(index)
    }

    // 遍历map
    scores := map[string]int{"Alice": 90, "Bob": 85}
    for name, score := range scores {
        fmt.Printf("%s: %d分\n", name, score)
    }

    // 遍历字符串(按Unicode码点)
    str := "你好Go"
    for i, ch := range str {
        fmt.Printf("索引%d: %c(%U)\n", i, ch, ch)
    }

    // ========== break 和 continue ==========
    for i := 0; i < 10; i++ {
        if i == 5 {
            break    // 跳出整个循环
        }
        if i%2 == 0 {
            continue // 跳过本次迭代
        }
        fmt.Print(i, " ")  // 输出: 1 3
    }
    fmt.Println()

    // break 标签:跳出多层循环
    outer:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i == 1 && j == 1 {
                break outer
            }
            fmt.Printf("(%d,%d) ", i, j)
        }
    }
    fmt.Println()

    // ========== goto 语句 ==========
    // 不推荐频繁使用,但在某些场景下(如错误处理)很有用
    n := 0
    loop:
    if n < 3 {
        fmt.Print(n, " ")
        n++
        goto loop
    }
    fmt.Println()
}

2.7 函数定义

GO
package main

import (
    "errors"
    "fmt"
)

// 1. 基本函数:func 函数名(参数列表) 返回值类型
func add(a int, b int) int {
    return a + b
}

// 2. 参数类型相同可简写
func multiply(a, b int) int {
    return a * b
}

// 3. 多返回值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

// 4. 命名返回值(naked return)
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return  // 自动返回 x, y
}

// 5. 可变参数(...类型,必须是最后一个参数)
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

// 6. 函数作为参数(高阶函数)
func apply(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, v := range nums {
        result[i] = fn(v)
    }
    return result
}

// 7. 函数作为返回值(闭包)
func makeAdder(base int) func(int) int {
    return func(n int) int {
        return base + n
    }
}

// 8. 匿名函数与立即执行
var greet = func(name string) string {
    return "Hello, " + name
}

func main() {
    fmt.Println("add(3,5):", add(3, 5))
    fmt.Println("multiply(4,6):", multiply(4, 6))

    result, err := divide(10, 3)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("divide(10,3): %.2f\n", result)
    }

    x, y := split(17)
    fmt.Printf("split(17): x=%d, y=%d\n", x, y)

    fmt.Println("sum(1,2,3,4,5):", sum(1, 2, 3, 4, 5))

    // 高阶函数用法
    doubled := apply([]int{1, 2, 3, 4}, func(n int) int {
        return n * 2
    })
    fmt.Println("doubled:", doubled)

    // 闭包用法
    add5 := makeAdder(5)
    fmt.Println("add5(10):", add5(10))
    fmt.Println("add5(20):", add5(20))

    fmt.Println(greet("Go"))

    // 立即执行的匿名函数
    func(msg string) {
        fmt.Println("匿名函数:", msg)
    }("Hello!")
}

2.8 defer、panic、recover

GO
package main

import "fmt"

func main() {
    // ========== defer:延迟执行 ==========
    // defer 在函数返回前执行,可用于资源释放、文件关闭等
    // 多个 defer 按 LIFO(后进先出)顺序执行

    fmt.Println("开始")
    defer fmt.Println("defer 1(最先注册,最后执行)")
    defer fmt.Println("defer 2(其次注册,其次执行)")
    defer fmt.Println("defer 3(最后注册,最先执行)")
    fmt.Println("结束")
    // 输出顺序:开始 → 结束 → defer 3 → defer 2 → defer 1

    // defer 参数在声明时求值
    x := 1
    defer fmt.Println("defer 捕获的 x =", x)  // 输出 1,因为此时x=1
    x = 100

    // defer 常用于:
    // 1. 关闭文件
    // f, _ := os.Open("file.txt")
    // defer f.Close()
    //
    // 2. 释放锁
    // mu.Lock()
    // defer mu.Unlock()
    //
    // 3. 记录函数执行时间
    // defer time.Since(time.Now())

    // ========== panic:运行时恐慌 ==========
    // panic 会中断当前函数执行,沿调用栈向上传播
    // 类似其他语言的"抛出异常"

    // ========== recover:捕获panic ==========
    // recover 只能在 defer 函数中生效
    // 可防止程序崩溃

    safeDivide()
    fmt.Println("程序继续执行...")
}

func safeDivide() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("捕获到 panic: %v\n", r)
        }
    }()

    fmt.Println("即将触发 panic...")
    panic("手动触发 panic")
    fmt.Println("这行不会被执行")
}

三、复合类型

3.1 数组(Array)

数组是固定长度、相同类型元素的集合。

GO
package main

import "fmt"

func main() {
    // ========== 数组声明 ==========
    var arr1 [5]int                          // 声明5个元素的int数组,零值0
    arr2 := [3]string{"Go", "Python", "JS"}  // 声明并初始化
    arr3 := [...]int{1, 2, 3, 4}             // 由编译器推断长度
    arr4 := [5]int{0: 10, 4: 50}             // 指定索引初始化(其余为零值)

    fmt.Println("arr1:", arr1)
    fmt.Println("arr2:", arr2)
    fmt.Println("arr3:", arr3, "长度:", len(arr3))
    fmt.Println("arr4:", arr4)

    // ========== 访问和修改 ==========
    arr1[0] = 100
    arr1[4] = 200
    fmt.Println("修改后 arr1:", arr1)

    for i := 0; i < len(arr2); i++ {
        fmt.Printf("arr2[%d] = %s\n", i, arr2[i])
    }

    // ========== 数组是值类型 ==========
    // 赋值或传参会复制整个数组
    original := [3]int{1, 2, 3}
    copyArr := original    // 完整复制
    copyArr[0] = 999
    fmt.Println("original:", original)  // [1,2,3] 未改变
    fmt.Println("copyArr:", copyArr)    // [999,2,3]

    // 传递指针避免复制
    modifyArray(&original)
    fmt.Println("传递指针后 original:", original)  // [100,2,3]

    // ========== 二维数组 ==========
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }
    fmt.Println("matrix:", matrix)
    fmt.Println("matrix[1][2]:", matrix[1][2])  // 7
}

func modifyArray(arr *[3]int) {
    arr[0] = 100
}

3.2 切片(Slice)

切片是Go中最常用的数据结构,是对数组的动态视图。

GO
package main

import "fmt"

func main() {
    // ========== 创建切片 ==========
    // 方式1:字面量
    s1 := []int{1, 2, 3, 4, 5}

    // 方式2:make 函数:make([]T, length, capacity)
    s2 := make([]int, 5)         // 长度5,容量5,零值
    s3 := make([]int, 3, 10)     // 长度3,容量10

    // 方式3:从数组或切片创建
    arr := [5]int{10, 20, 30, 40, 50}
    s4 := arr[1:4]               // [20,30,40],索引1到3(不含4)
    s5 := arr[:3]                // [10,20,30]
    s6 := arr[2:]                // [30,40,50]

    fmt.Println("s1:", s1)
    fmt.Println("s2:", s2)
    fmt.Println("s3:", s3, "len:", len(s3), "cap:", cap(s3))
    fmt.Println("s4:", s4)
    fmt.Println("s5:", s5)
    fmt.Println("s6:", s6)

    // ========== 切片操作 ==========
    s := []int{1, 2, 3, 4, 5}

    // append:追加元素
    s = append(s, 6)
    s = append(s, 7, 8, 9)  // 追加多个
    fmt.Println("append后:", s)

    // 合并两个切片
    s1 := []int{1, 2}
    s2 := []int{3, 4}
    s1 = append(s1, s2...)  // ... 将切片展开
    fmt.Println("合并后:", s1)

    // copy:复制切片
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, 3)
    n := copy(dst, src)               // 复制 min(len(dst), len(src)) 个元素
    fmt.Println("copy后 dst:", dst, "复制了:", n, "个")

    // 删除元素(通过 append 技巧)
    s = []int{1, 2, 3, 4, 5}
    index := 2  // 删除索引2的元素(值为3)
    s = append(s[:index], s[index+1:]...)
    fmt.Println("删除索引2后:", s)  // [1,2,4,5]

    // 插入元素
    s = []int{1, 2, 3, 4, 5}
    index = 2
    value := 99
    s = append(s[:index], append([]int{value}, s[index:]...)...)
    fmt.Println("插入99后:", s)  // [1,2,99,3,4,5]

    // ========== 切片内部原理 ==========
    // 切片结构:ptr(指向底层数组)、len(长度)、cap(容量)
    // 截取切片会共享底层数组!
    base := []int{1, 2, 3, 4, 5}
    sub := base[1:4]          // [2,3,4]
    sub[0] = 999              // 修改sub会影响base
    fmt.Println("base:", base)  // [1,999,3,4,5]
    fmt.Println("sub:", sub)    // [999,3,4]

    // 容量增长规则:小于1024时翻倍,大于1024时增长25%
    fmt.Println("容量演示:")
    capSlice := make([]int, 0)
    for i := 0; i < 10; i++ {
        capSlice = append(capSlice, i)
        fmt.Printf("len=%d, cap=%d\n", len(capSlice), cap(capSlice))
    }
}

3.3 Map

GO
package main

import "fmt"

func main() {
    // ========== 创建Map ==========
    // 方式1:make
    m1 := make(map[string]int)

    // 方式2:字面量
    m2 := map[string]int{
        "apple":  5,
        "banana": 3,
        "cherry": 7,
    }

    // 方式3:make 指定初始容量(减少扩容次数)
    m3 := make(map[string]int, 100)

    fmt.Println("m1:", m1)
    fmt.Println("m2:", m2)
    fmt.Println("m3:", m3)

    // ========== 基本操作 ==========
    // 添加/修改
    m2["date"] = 10
    m2["apple"] = 99  // 修改已有键
    fmt.Println("添加/修改后:", m2)

    // 访问
    fmt.Println("apple:", m2["apple"])

    // 检查键是否存在
    value, exists := m2["orange"]
    if exists {
        fmt.Println("orange存在,值:", value)
    } else {
        fmt.Println("orange不存在,零值:", value)
    }

    // 删除
    delete(m2, "banana")
    fmt.Println("删除banana后:", m2)

    // 长度
    fmt.Println("元素个数:", len(m2))

    // ========== 遍历Map ==========
    // 遍历顺序是随机的(每次运行可能不同)
    for key, value := range m2 {
        fmt.Printf("  %s -> %d\n", key, value)
    }

    // ========== Map注意事项 ==========
    // nil map 可以读取(返回零值),但不能写入(会panic)
    var nilMap map[string]int
    fmt.Println("nilMap[\"key\"] =", nilMap["key"])  // 0,不报错
    // nilMap["key"] = 1  // panic: assignment to entry in nil map

    // Map不是并发安全的,并发写入会panic
    // 需要使用 sync.Mutex 或 sync.Map
}

3.4 结构体(Struct)

GO
package main

import (
    "encoding/json"
    "fmt"
)

// ========== 结构体定义 ==========
type Person struct {
    Name    string
    Age     int
    Email   string
    private string  // 小写字段:包内可见,包外不可见
}

// 方法:值接收者(不会修改原始结构体)
func (p Person) Greet() string {
    return fmt.Sprintf("你好,我是%s,今年%d岁", p.Name, p.Age)
}

// 方法:指针接收者(可以修改原始结构体)
func (p *Person) Birthday() {
    p.Age++
}

// 方法:指针接收者(即使不需要修改,大结构体也建议用指针避免复制)
func (p *Person) SetEmail(email string) {
    p.Email = email
}

// ========== 结构体标签(Tag)==========
type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Password string `json:"-"`               // - 表示忽略
    Age      int    `json:"age,omitempty"`    // omitempty:零值时忽略
}

func main() {
    // ========== 创建实例 ==========
    // 方式1:字段名赋值(推荐)
    p1 := Person{
        Name:  "张三",
        Age:   30,
        Email: "zhangsan@example.com",
    }

    // 方式2:按顺序赋值(不推荐,字段顺序改变会导致错误)
    p2 := Person{"李四", 25, "lisi@example.com", "secret"}

    // 方式3:零值初始化
    var p3 Person
    p3.Name = "王五"
    p3.Age = 35

    fmt.Println("p1:", p1)
    fmt.Println("p2:", p2)
    fmt.Println("p3:", p3)

    // ========== 访问字段 ==========
    fmt.Println("p1.Name:", p1.Name)

    // 指针访问(自动解引用)
    ptr := &p1
    fmt.Println("ptr.Name:", ptr.Name)  // 等价于 (*ptr).Name

    // ========== 方法调用 ==========
    fmt.Println(p1.Greet())

    p1.Birthday()
    fmt.Println("生日后年龄:", p1.Age)

    // ========== 结构体标签应用:JSON序列化 ==========
    user := User{ID: 1, Username: "gopher", Age: 0}
    data, _ := json.Marshal(user)
    fmt.Println("JSON:", string(data))  // Age为0,omitempty导致被忽略

    user2 := User{ID: 2, Username: "golang", Age: 25}
    data2, _ := json.Marshal(user2)
    fmt.Println("JSON:", string(data2))

    // JSON反序列化
    jsonStr := `{"id":3,"username":"dev","age":30}`
    var user3 User
    json.Unmarshal([]byte(jsonStr), &user3)
    fmt.Printf("反序列化: %+v\n", user3)

    // ========== 匿名结构体 ==========
    temp := struct {
        X int
        Y int
    }{10, 20}
    fmt.Println("匿名结构体:", temp)

    // ========== 空结构体(零内存占用)==========
    var empty struct{}
    fmt.Printf("空结构体大小: %d字节\n", unsafe.Sizeof(empty))

    // 常用场景:集合(Set)的替代实现
    set := make(map[string]struct{})
    set["apple"] = struct{}{}
    set["banana"] = struct{}{}
    if _, exists := set["apple"]; exists {
        fmt.Println("apple在集合中")
    }
}

四、面向对象编程

4.1 接口(Interface)

接口是Go语言实现多态的核心机制,定义了一组方法签名。

GO
package main

import (
    "fmt"
    "math"
)

// ========== 接口定义 ==========
type Shape interface {
    Area() float64
    Perimeter() float64
}

// ========== 接口实现(隐式实现)==========
// 只要类型实现了接口的所有方法,就自动实现了该接口
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// ========== 接口嵌套 ==========
type Object interface {
    Shape
    Name() string
}

// ========== 空接口 ==========
// interface{} 表示任意类型(Go 1.18+ 可用 any 代替)
func printAny(v interface{}) {
    fmt.Printf("类型: %T, 值: %v\n", v, v)
}

func main() {
    // ========== 多态:通过接口变量调用方法 ==========
    var s Shape

    s = Circle{Radius: 5}
    fmt.Printf("圆形: 面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())

    s = Rectangle{Width: 4, Height: 6}
    fmt.Printf("矩形: 面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())

    // ========== 接口参数 ==========
    printShapeInfo(Circle{Radius: 3})
    printShapeInfo(Rectangle{Width: 5, Height: 8})

    // ========== 类型断言 ==========
    var i interface{} = "hello"
    str, ok := i.(string)  // 安全断言
    if ok {
        fmt.Println("字符串:", str)
    }

    // 类型断言常用于区分接口的具体类型
    describeShape(Circle{Radius: 2})
    describeShape(Rectangle{Width: 3, Height: 4})

    // ========== 接口判断(nil 接口陷阱)==========
    // 接口值由(类型, 值)组成
    // 只有当类型和值都为 nil 时,接口才等于 nil
    var ptr *Circle = nil
    var s2 Shape = ptr
    fmt.Printf("s2 == nil? %v\n", s2 == nil)  // false!因为类型不为nil
}

func printShapeInfo(s Shape) {
    fmt.Printf("形状信息: 面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())
}

func describeShape(s Shape) {
    switch v := s.(type) {
    case Circle:
        fmt.Printf("这是圆形,半径: %.2f\n", v.Radius)
    case Rectangle:
        fmt.Printf("这是矩形,宽: %.2f, 高: %.2f\n", v.Width, v.Height)
    default:
        fmt.Println("未知形状")
    }
}

4.2 嵌入类型(组合代替继承)

Go语言通过类型嵌入(组合)实现代码复用,代替传统面向对象的继承。

GO
package main

import (
    "fmt"
)

// ========== 基础类型 ==========
type Animal struct {
    Name string
    Age  int
}

func (a Animal) Eat() {
    fmt.Printf("%s 正在吃东西\n", a.Name)
}

func (a Animal) Sleep() {
    fmt.Printf("%s 正在睡觉\n", a.Name)
}

// ========== 嵌入Animal ==========
// Dog 通过嵌入 Animal 获得了其字段和方法
type Dog struct {
    Animal          // 匿名嵌入(字段和方法被"提升")
    Breed  string
}

// Dog 可以覆盖嵌入类型的方法
func (d Dog) Eat() {
    fmt.Printf("%s(%s) 正在吃狗粮\n", d.Name, d.Breed)
}

// Dog 特有的方法
func (d Dog) Bark() {
    fmt.Printf("%s 在汪汪叫\n", d.Name)
}

// ========== 多级嵌入 ==========
type PetDog struct {
    Dog
    Owner string
}

func (p PetDog) Play() {
    fmt.Printf("%s 和主人 %s 一起玩耍\n", p.Name, p.Owner)
}

// ========== 接口与嵌入 ==========
type Walker interface {
    Walk()
}

type Swimmer interface {
    Swim()
}

type WalkerSwimmer interface {
    Walker
    Swimmer
}

type Person struct {
    Name string
}

func (p Person) Walk() {
    fmt.Printf("%s 在走路\n", p.Name)
}

func (p Person) Swim() {
    fmt.Printf("%s 在游泳\n", p.Name)
}

func main() {
    // ========== 创建嵌入类型的实例 ==========
    dog := Dog{
        Animal: Animal{Name: "旺财", Age: 3},
        Breed:  "金毛",
    }

    // 访问嵌入类型的字段(字段名被提升)
    fmt.Println("名字:", dog.Name)    // 等价于 dog.Animal.Name
    fmt.Println("品种:", dog.Breed)

    // 调用嵌入类型的方法
    dog.Sleep()    // 来自 Animal
    dog.Eat()      // Dog 覆盖后的版本
    dog.Bark()     // Dog 特有

    // 也可以显式访问嵌入类型
    dog.Animal.Eat()  // 原始 Animal.Eat

    // ========== 多级嵌入 ==========
    pet := PetDog{
        Dog:   Dog{Animal: Animal{Name: "小黄", Age: 2}, Breed: "泰迪"},
        Owner: "小明",
    }
    pet.Eat()
    pet.Bark()
    pet.Play()

    // ========== 接口嵌入 ==========
    var ws WalkerSwimmer
    ws = Person{Name: "张三"}
    ws.Walk()
    ws.Swim()

    // ========== 方法集与指针接收者 ==========
    // 注意:指针类型的方法集包含值接收者和指针接收者的方法
    // 值类型的方法集仅包含值接收者的方法
}

4.3 泛型(Go 1.18+)

GO
package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

// ========== 泛型函数 ==========
// [T any] 表示类型参数,any 是 interface{} 的别名
func Print[T any](s []T) {
    for _, v := range s {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

// 类型约束:T 必须支持比较操作
func IndexOf[T comparable](s []T, x T) int {
    for i, v := range s {
        if v == x {
            return i
        }
    }
    return -1
}

// 数值约束:T 必须是整数或浮点数
func Sum[T int | float64](s []T) T {
    var total T
    for _, v := range s {
        total += v
    }
    return total
}

// 使用 constraints 包的约束
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// ========== 泛型类型 ==========
// 泛型切片包装
type Slice[T any] []T

func (s Slice[T]) First() T {
    return s[0]
}

func (s Slice[T]) Last() T {
    return s[len(s)-1]
}

// 泛型 Map
type MyMap[K comparable, V any] map[K]V

func (m MyMap[K, V]) Keys() []K {
    keys := make([]K, 0, len(m))
    for k := range m {
        keys = append(keys, k)
    }
    return keys
}

// 泛型结构体(链式操作示例)
type Result[T any] struct {
    Value T
    Err   error
}

// ========== 自定义类型约束 ==========
// 定义约束接口
type Number interface {
    int | int64 | float64
}

func Max[T Number](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func main() {
    // 泛型函数调用
    Print([]int{1, 2, 3, 4, 5})
    Print([]string{"Go", "Python", "Java"})

    fmt.Println("IndexOf 5:", IndexOf([]int{1, 3, 5, 7, 9}, 5))
    fmt.Println("IndexOf 'a':", IndexOf([]string{"a", "b", "c"}, "a"))

    fmt.Println("Sum int:", Sum([]int{1, 2, 3, 4, 5}))
    fmt.Println("Sum float64:", Sum([]float64{1.1, 2.2, 3.3}))

    fmt.Println("Min(10, 20):", Min(10, 20))
    fmt.Println("Min(1.5, 0.8):", Min(1.5, 0.8))

    // 泛型类型使用
    s := Slice[int]{1, 2, 3, 4, 5}
    fmt.Println("First:", s.First(), "Last:", s.Last())

    m := MyMap[string, int]{"a": 1, "b": 2, "c": 3}
    fmt.Println("Keys:", m.Keys())

    fmt.Println("Max(10, 20):", Max(10, 20))
    fmt.Println("Max(1.5, 0.8):", Max(1.5, 0.8))

    // 类型推断:Go可以推断类型参数
    // 也可以显式指定
    _ = Max[int](100, 200)
}

五、并发编程

5.1 Goroutine(协程)

Goroutine是Go语言的核心并发原语,是轻量级线程。

GO
package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func main() {
    // ========== 启动 Goroutine ==========
    // 使用 go 关键字启动一个goroutine
    go sayHello("World")

    // 匿名函数 goroutine
    go func(name string) {
        fmt.Printf("匿名goroutine: Hello, %s!\n", name)
    }("Go")

    // 主goroutine等待(生产环境应使用 WaitGroup 或 Channel)
    time.Sleep(100 * time.Millisecond)

    // ========== GOMAXPROCS ==========
    // 设置可同时执行的最大CPU核数
    fmt.Printf("逻辑CPU数: %d\n", runtime.NumCPU())
    runtime.GOMAXPROCS(runtime.NumCPU())  // 使用所有CPU核心

    // ========== Goroutine 调度模型(GMP)==========
    // G: Goroutine(协程)
    // M: Machine(操作系统线程)
    // P: Processor(逻辑处理器,数量由 GOMAXPROCS 决定)
    // 一个M必须绑定一个P才能执行G

    // ========== WaitGroup:等待多个goroutine ==========
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)  // 计数器 +1
        go worker(i, &wg)
    }

    wg.Wait()  // 阻塞直到计数器归零
    fmt.Println("所有worker执行完成")
}

func sayHello(name string) {
    for i := 0; i < 3; i++ {
        fmt.Printf("Hello, %s! (%d)\n", name, i)
        time.Sleep(50 * time.Millisecond)
    }
}

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()  // 函数结束时计数器 -1
    fmt.Printf("Worker %d 开始工作\n", id)
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("Worker %d 完成工作\n", id)
}

5.2 Channel(通道)

Channel是Go中goroutine之间通信的主要方式,基于CSP(Communicating Sequential Processes)模型。

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    // ========== Channel 创建 ==========
    // 无缓冲Channel:发送方阻塞直到接收方准备好
    unbuffered := make(chan int)

    // 带缓冲Channel:缓冲区满之前不会阻塞
    buffered := make(chan string, 3)

    _ = unbuffered
    _ = buffered

    // ========== 基本操作:发送和接收 ==========
    ch := make(chan int, 2)

    ch <- 1   // 发送
    ch <- 2   // 发送
    value := <-ch  // 接收
    fmt.Println("接收:", value)
    value = <-ch
    fmt.Println("接收:", value)

    // ========== 关闭 Channel ==========
    ch2 := make(chan int, 3)
    ch2 <- 10
    ch2 <- 20
    ch2 <- 30
    close(ch2)  // 关闭后不能再发送(会panic),但可以继续接收

    for v := range ch2 {  // range 会在 channel 关闭且数据读完后自动退出
        fmt.Println("读取:", v)
    }

    // 检查channel是否关闭
    ch3 := make(chan int, 1)
    ch3 <- 42
    close(ch3)
    v, ok := <-ch3
    fmt.Printf("值=%d, 状态=%v\n", v, ok)  // 42, true
    v, ok = <-ch3
    fmt.Printf("值=%d, 状态=%v\n", v, ok)  // 0, false

    // ========== 单向 Channel ==========
    // 用于函数参数中限制channel的读写方向
    numbers := make(chan int, 10)
    go producer(numbers)
    consumer(numbers)

    // ========== Channel 应用模式 ==========
    // 1. 信号通知(使用 chan struct{})
    done := make(chan struct{})
    go func() {
        time.Sleep(200 * time.Millisecond)
        fmt.Println("任务完成")
        close(done)  // 关闭channel发送信号
    }()
    <-done  // 阻塞等待信号

    // 2. 限制并发数(信号量模式)
    semaphore := make(chan struct{}, 3)  // 最多3个并发
    for i := 0; i < 10; i++ {
        semaphore <- struct{}{}  // 获取许可证
        go func(id int) {
            defer func() { <-semaphore }()  // 释放许可证
            fmt.Printf("任务 %d 执行中...\n", id)
            time.Sleep(100 * time.Millisecond)
        }(i)
    }
    time.Sleep(time.Second)
}

func producer(ch chan<- int) {  // 只能发送
    for i := 0; i < 5; i++ {
        ch <- i
        fmt.Println("生产:", i)
    }
    close(ch)
}

func consumer(ch <-chan int) {  // 只能接收
    for v := range ch {
        fmt.Println("消费:", v)
    }
}

5.3 Select语句

select 用于同时等待多个channel操作。

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    // ========== 基本 Select ==========
    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "来自通道1"
    }()

    go func() {
        time.Sleep(200 * time.Millisecond)
        ch2 <- "来自通道2"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println("收到:", msg)
        case msg := <-ch2:
            fmt.Println("收到:", msg)
        }
    }

    // ========== Select + default(非阻塞操作)==========
    ch3 := make(chan int, 1)
    ch3 <- 42

    select {
    case v := <-ch3:
        fmt.Println("读取到:", v)
    default:
        fmt.Println("channel为空,不阻塞")
    }

    // ========== Select + 超时控制 ==========
    ch4 := make(chan string)
    go func() {
        time.Sleep(500 * time.Millisecond)
        ch4 <- "延迟数据"
    }()

    select {
    case msg := <-ch4:
        fmt.Println("收到:", msg)
    case <-time.After(200 * time.Millisecond):
        fmt.Println("超时!2秒内未收到数据")
    }

    // ========== Select + 心跳检测 (Ticker) ==========
    ticker := time.NewTicker(100 * time.Millisecond)
    done := make(chan bool)

    go func() {
        time.Sleep(500 * time.Millisecond)
        done <- true
    }()

    loop:
    for {
        select {
        case t := <-ticker.C:
            fmt.Println("心跳:", t.Format("15:04:05.000"))
        case <-done:
            fmt.Println("任务完成,停止心跳")
            ticker.Stop()
            break loop
        }
    }
}

5.4 同步原语(sync包)

GO
package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

func main() {
    // ========== sync.Mutex:互斥锁 ==========
    var mu sync.Mutex
    counter := 0

    for i := 0; i < 1000; i++ {
        go func() {
            mu.Lock()
            counter++        // 临界区
            mu.Unlock()
        }()
    }
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Mutex counter:", counter)

    // ========== sync.RWMutex:读写锁 ==========
    var rwmu sync.RWMutex
    data := make(map[string]int)

    // 写操作(独占锁)
    go func() {
        rwmu.Lock()
        data["key"] = 42
        rwmu.Unlock()
    }()

    // 读操作(共享锁,多个读可以同时进行)
    for i := 0; i < 5; i++ {
        go func(id int) {
            rwmu.RLock()
            fmt.Printf("Reader %d 读取: %d\n", id, data["key"])
            rwmu.RUnlock()
        }(i)
    }
    time.Sleep(100 * time.Millisecond)

    // ========== sync.Once:单次执行 ==========
    // 常用于单例模式、初始化操作
    var once sync.Once
    initFunc := func() {
        fmt.Println("初始化操作(只执行一次)")
    }

    for i := 0; i < 5; i++ {
        go func() {
            once.Do(initFunc)  // 只有第一个调用会执行
        }()
    }
    time.Sleep(100 * time.Millisecond)

    // ========== sync.Map:并发安全的Map ==========
    var sm sync.Map
    sm.Store("key1", "value1")
    sm.Store("key2", "value2")

    value, ok := sm.Load("key1")
    if ok {
        fmt.Println("Load key1:", value)
    }

    sm.Range(func(key, value interface{}) bool {
        fmt.Printf("  %v -> %v\n", key, value)
        return true  // 继续遍历
    })

    sm.Delete("key1")

    // LoadOrStore: 存在则返回现有值,不存在则存储
    actual, loaded := sm.LoadOrStore("key3", "value3")
    fmt.Printf("LoadOrStore: value=%v, loaded=%v\n", actual, loaded)

    // ========== sync.Pool:对象池(减少GC压力)==========
    var pool = sync.Pool{
        New: func() interface{} {
            return make([]byte, 1024)
        },
    }

    buf := pool.Get().([]byte)
    // 使用 buf...
    pool.Put(buf)  // 用完归还

    // ========== atomic:原子操作 ==========
    // 比互斥锁更轻量,用于简单的计数器操作
    var atomicCounter int64
    for i := 0; i < 1000; i++ {
        go func() {
            atomic.AddInt64(&atomicCounter, 1)
        }()
    }
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Atomic counter:", atomic.LoadInt64(&atomicCounter))

    // CAS(Compare And Swap)操作
    var value int64 = 0
    swapped := atomic.CompareAndSwapInt64(&value, 0, 100)  // 如果value==0则设为100
    fmt.Printf("CAS swapped=%v, value=%d\n", swapped, value)

    // ========== sync.Cond:条件变量 ==========
    // 用于等待某个条件满足
    var condMu sync.Mutex
    cond := sync.NewCond(&condMu)
    ready := false

    go func() {
        condMu.Lock()
        for !ready {
            cond.Wait()  // 等待条件,自动释放锁
        }
        fmt.Println("条件满足,继续执行")
        condMu.Unlock()
    }()

    time.Sleep(100 * time.Millisecond)
    condMu.Lock()
    ready = true
    condMu.Unlock()
    cond.Signal()  // 唤醒一个等待者(Broadcast唤醒所有)
    time.Sleep(100 * time.Millisecond)
}

六、错误处理

6.1 error 接口与基本错误处理

GO
package main

import (
    "errors"
    "fmt"
    "os"
)

// Go 的 error 是一个内置接口:
// type error interface {
//     Error() string
// }

// ========== 创建错误 ==========
func demoErrors() {
    // 方式1:errors.New
    err1 := errors.New("这是一个错误")

    // 方式2:fmt.Errorf(支持格式化)
    name := "文件"
    err2 := fmt.Errorf("打开%s失败: %w", name, err1)

    // 方式3:直接使用预定义错误
    err3 := os.ErrNotExist
    err4 := os.ErrPermission

    fmt.Println(err1)
    fmt.Println(err2)
    fmt.Println(err3)
    fmt.Println(err4)
}

// ========== 错误检查模式 ==========
func readFile(filename string) ([]byte, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("读取文件%s失败: %w", filename, err)
    }
    return data, nil
}

func main() {
    demoErrors()

    data, err := readFile("nonexistent.txt")
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("文件内容:", string(data))
    }
}

6.2 自定义错误类型

GO
package main

import (
    "fmt"
)

// ========== 自定义错误类型 ==========
type ValidationError struct {
    Field string
    Value interface{}
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("验证失败: 字段=%s, 值=%v, 原因=%s", e.Field, e.Value, e.Msg)
}

// 带错误码的错误类型
type AppError struct {
    Code    int
    Message string
    Cause   error
}

func (e *AppError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("[%d] %s: %v", e.Code, e.Message, e.Cause)
    }
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}

func (e *AppError) Unwrap() error {
    return e.Cause
}

func validateAge(age int) error {
    if age < 0 {
        return &ValidationError{
            Field: "age",
            Value: age,
            Msg:   "年龄不能为负数",
        }
    }
    if age > 150 {
        return &ValidationError{
            Field: "age",
            Value: age,
            Msg:   "年龄超出合理范围",
        }
    }
    return nil
}

func main() {
    err := validateAge(-5)
    if err != nil {
        // 类型断言检查具体错误类型
        if ve, ok := err.(*ValidationError); ok {
            fmt.Printf("字段%s验证失败\n", ve.Field)
        }
        fmt.Println(err)
    }

    // 应用错误示例
    appErr := &AppError{Code: 404, Message: "资源未找到"}
    fmt.Println(appErr)
}

6.3 错误包装与解包(Go 1.13+)

GO
package main

import (
    "errors"
    "fmt"
    "os"
)

// ========== 错误包装 ==========
// 使用 fmt.Errorf 的 %w 动词包装错误
func openConfig() error {
    _, err := os.Open("config.yaml")
    if err != nil {
        return fmt.Errorf("打开配置文件失败: %w", err)
    }
    return nil
}

func loadApp() error {
    err := openConfig()
    if err != nil {
        return fmt.Errorf("加载应用失败: %w", err)
    }
    return nil
}

func main() {
    err := loadApp()
    if err != nil {
        fmt.Println("完整错误链:", err)

        // errors.Unwrap:解包一层错误
        unwrapped := errors.Unwrap(err)
        fmt.Println("解包一层:", unwrapped)

        // errors.Is:判断错误链中是否包含特定错误
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("根本原因是文件不存在")
        }

        // errors.As:从错误链中提取特定类型的错误
        var pathErr *os.PathError
        if errors.As(err, &pathErr) {
            fmt.Printf("路径错误: path=%s, op=%s\n", pathErr.Path, pathErr.Op)
        }
    }
}

6.4 panic 与 recover 深入

GO
package main

import (
    "fmt"
)

// ========== 何时使用 panic ==========
// panic 应用于不可恢复的错误:
// - 程序启动时的配置错误
// - 编程错误(如数组越界,但Go运行时已处理)
// - 不想处理的不变量违反
// 业务逻辑错误应使用 error 返回

// ========== recover 使用规则 ==========
func safeCall(fn func()) (recovered interface{}) {
    defer func() {
        recovered = recover()
    }()

    fn()
    return nil
}

func riskyOperation(shouldPanic bool) {
    if shouldPanic {
        panic("发生了严重错误")
    }
    fmt.Println("操作成功")
}

func main() {
    // recover 捕获 panic
    result := safeCall(func() {
        riskyOperation(true)
    })
    if result != nil {
        fmt.Println("捕获到 panic:", result)
    }

    // 正常执行
    safeCall(func() {
        riskyOperation(false)
    })

    // ========== panic 和 defer 的执行顺序 ==========
    // 发生 panic 时:执行所有 defer → 打印 panic 信息 → 程序退出
    // 如果 defer 中调用了 recover → 恢复正常执行

    fmt.Println("程序正常结束")

    // ========== 重新 panic ==========
    // 在 recover 后可以重新 panic
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("第一次recover:", r)
            // panic("重新panic")  // 可以再次panic
        }
    }()
    panic("原始panic")
}

七、包与模块

7.1 包的定义与导入

GO
// ========== 包的定义规则 ==========
// 1. 每个Go文件的第一行必须是 package 声明
// 2. 同一目录下的所有 .go 文件必须属于同一个包
// 3. main 包是程序的入口包,包含 main() 函数
// 4. 包名通常是小写单词,简洁明了

// ========== 导入包的几种方式 ==========
package main

import (
    // 标准导入
    "fmt"

    // 别名导入
    str "strings"

    // 点导入(不推荐,污染命名空间)
    // . "math"

    // 匿名导入(仅执行包的 init 函数)
    _ "database/sql/driver"
)

func main() {
    fmt.Println(str.ToUpper("hello"))
}

7.2 可见性规则

GO
package user

import "fmt"

// 大写开头:公开(exported),包外可访问
var PublicVar = "public"

// 小写开头:私有(unexported),仅在包内可访问
var privateVar = "private"

type User struct {
    Name  string  // 公开字段
    age   int     // 私有字段
}

// 公开方法
func (u *User) GetAge() int {
    return u.age
}

// 公开函数
func NewUser(name string, age int) *User {
    return &User{Name: name, age: age}
}

// init 函数:包加载时自动执行(先于 main)
func init() {
    fmt.Println("user 包初始化")
}

7.3 Go Modules 详解

BASH
# ========== 模块初始化 ==========
go mod init example.com/myproject
# 生成 go.mod 文件

# ========== 依赖管理 ==========
# 添加依赖
go get github.com/gin-gonic/gin          # 最新版本
go get github.com/gin-gonic/gin@v1.9.0   # 指定版本
go get github.com/gin-gonic/gin@latest   # 最新版本
go get github.com/gin-gonic/gin@none     # 移除依赖

# 查看依赖
go list -m all              # 列出所有依赖
go list -m -u all           # 列出所有依赖及可用更新
go mod graph                # 依赖关系图

# 清理与同步
go mod tidy                 # 添加缺失的依赖,移除未使用的依赖
go mod download             # 下载依赖到本地缓存
go mod verify               # 验证依赖完整性

# 替换依赖(用于本地开发或fork版本)
go mod edit -replace example.com/original=../local/path
go mod edit -replace example.com/original=github.com/fork/version@v1.0.0

go.mod 文件结构示例:

CODE
module example.com/myproject

go 1.22

require (
    github.com/gin-gonic/gin v1.9.1
    github.com/go-sql-driver/mysql v1.7.0
)

require (
    // 间接依赖
    github.com/bytedance/sonic v1.9.1 // indirect
    github.com/goccy/go-json v0.10.2 // indirect
)

replace example.com/local => ./local
exclude example.com/broken v1.0.0
retract v1.0.0  // 撤回有问题的版本

7.4 内部包(internal)

GO
// internal 目录的包只能被其父目录树的包导入
// 示例目录结构:
// myproject/
// ├── internal/
// │   ├── config/
// │   │   └── config.go     // 只能被 myproject 及其子包导入
// │   └── db/
// │       └── db.go
// ├── main.go               // 可以导入 internal/config
// └── cmd/
//     └── tool/
//         └── main.go       // 可以导入 internal/config
// pkg/
// └── public/
//     └── public.go         // 不能导入 internal/config

八、标准库详解

8.1 fmt 包 —— 格式化输入输出

核心功能: 提供格式化I/O功能,包括打印到标准输出/文件、从输入读取数据、格式化字符串。

8.1.1 输出函数

函数 签名 说明
Print func Print(a ...any) (n int, err error) 打印到标准输出,不换行
Println func Println(a ...any) (n int, err error) 打印后加换行,参数间加空格
Printf func Printf(format string, a ...any) (n int, err error) 格式化打印
Fprint func Fprint(w io.Writer, a ...any) (n int, err error) 写入到 Writer
Fprintf func Fprintf(w io.Writer, format string, a ...any) (n int, err error) 格式化写入到 Writer
Fprintln func Fprintln(w io.Writer, a ...any) (n int, err error) 写入后加换行
Sprint func Sprint(a ...any) string 返回字符串
Sprintf func Sprintf(format string, a ...any) string 格式化后返回字符串
Sprintln func Sprintln(a ...any) string 返回带换行和空格的字符串

8.1.2 输入函数

函数 签名 说明
Scan func Scan(a ...any) (n int, err error) 从标准输入读取,空格分隔
Scanln func Scanln(a ...any) (n int, err error) 从标准输入读取一行
Scanf func Scanf(format string, a ...any) (n int, err error) 格式化读取
Fscan func Fscan(r io.Reader, a ...any) (n int, err error) 从 Reader 读取
Sscan func Sscan(str string, a ...any) (n int, err error) 从字符串读取

8.1.3 格式化动词(Verbs)

动词 说明 示例 输出
%v 默认格式 fmt.Sprintf("%v", "hello") hello
%+v 结构体添加字段名 fmt.Sprintf("%+v", User{Name:"Tom"}) {Name:Tom}
%#v Go语法表示 fmt.Sprintf("%#v", User{Name:"Tom"}) main.User{Name:”Tom”}
%T 类型 fmt.Sprintf("%T", 42) int
%t 布尔值 fmt.Sprintf("%t", true) true
%d 十进制整数 fmt.Sprintf("%d", 42) 42
%b 二进制 fmt.Sprintf("%b", 42) 101010
%o 八进制 fmt.Sprintf("%o", 42) 52
%x 十六进制(小写) fmt.Sprintf("%x", 255) ff
%X 十六进制(大写) fmt.Sprintf("%X", 255) FF
%f 浮点数 fmt.Sprintf("%f", 3.14) 3.140000
%.2f 浮点数(2位小数) fmt.Sprintf("%.2f", 3.14159) 3.14
%e 科学计数法 fmt.Sprintf("%e", 314159.0) 3.141590e+05
%s 字符串 fmt.Sprintf("%s", "hello") hello
%q 带引号的字符串 fmt.Sprintf("%q", "hello") “hello”
%p 指针地址 fmt.Sprintf("%p", &value) 0xc00001a0a0
%c Unicode字符 fmt.Sprintf("%c", 20013) 中
%% 百分号 fmt.Sprintf("%d%%", 80) 80%

8.1.4 使用示例

GO
package main

import (
    "bytes"
    "fmt"
    "os"
)

func main() {
    // ========== 基本输出 ==========
    fmt.Print("不带换行")
    fmt.Println("带换行")

    name := "Alice"
    age := 30
    fmt.Printf("姓名: %s, 年龄: %d\n", name, age)

    // ========== 输出到文件 ==========
    f, _ := os.Create("output.txt")
    defer f.Close()
    fmt.Fprintln(f, "写入文件的内容")

    // ========== 输出到字节缓冲区 ==========
    var buf bytes.Buffer
    fmt.Fprintf(&buf, "缓冲区: %d", 100)
    fmt.Println(buf.String())

    // ========== 字符串格式化 ==========
    result := fmt.Sprintf("计算结果: %.2f", 3.14159)
    fmt.Println(result)

    // ========== 结构体格式化 ==========
    type User struct {
        Name string
        Age  int
    }
    u := User{"Bob", 25}
    fmt.Printf("默认: %v\n", u)    // {Bob 25}
    fmt.Printf("详细: %+v\n", u)   // {Name:Bob Age:25}
    fmt.Printf("完整: %#v\n", u)   // main.User{Name:"Bob", Age:25}
    fmt.Printf("类型: %T\n", u)    // main.User

    // ========== 对齐与宽度控制 ==========
    fmt.Printf("|%10s|%10d|\n", "右对齐", 42)
    fmt.Printf("|%-10s|%-10d|\n", "左对齐", 42)
    fmt.Printf("|%010d|\n", 42)  // 零填充: |0000000042|

    // ========== 输入 ==========
    fmt.Print("请输入你的名字: ")
    var input string
    fmt.Scanln(&input)
    fmt.Println("你好,", input)

    // ========== Errorf:创建格式化错误 ==========
    err := fmt.Errorf("在第%d行发生错误: %s", 42, "未定义变量")
    fmt.Println(err)
}

8.2 os 包 —— 操作系统接口

核心功能: 提供操作系统功能,包括文件操作、进程管理、环境变量、命令行参数等。

8.2.1 主要函数

函数 签名 说明
Open func Open(name string) (*File, error) 只读方式打开文件
Create func Create(name string) (*File, error) 创建/截断文件
OpenFile func OpenFile(name string, flag int, perm FileMode) (*File, error) 指定方式打开文件
ReadFile func ReadFile(name string) ([]byte, error) 读取整个文件
WriteFile func WriteFile(name string, data []byte, perm FileMode) error 写入整个文件
Mkdir func Mkdir(name string, perm FileMode) error 创建单层目录
MkdirAll func MkdirAll(path string, perm FileMode) error 递归创建目录
Remove func Remove(name string) error 删除文件或空目录
RemoveAll func RemoveAll(path string) error 递归删除
Rename func Rename(oldpath, newpath string) error 重命名/移动
Stat func Stat(name string) (FileInfo, error) 获取文件信息
Getenv func Getenv(key string) string 获取环境变量
Setenv func Setenv(key, value string) error 设置环境变量
LookupEnv func LookupEnv(key string) (string, bool) 检查环境变量是否存在
Environ func Environ() []string 所有环境变量
Exit func Exit(code int) 退出程序
Getwd func Getwd() (dir string, err error) 获取当前工作目录
Chdir func Chdir(dir string) error 改变工作目录
TempDir func TempDir() string 临时目录路径
UserHomeDir func UserHomeDir() (string, error) 用户主目录
UserCacheDir func UserCacheDir() (string, error) 用户缓存目录
UserConfigDir func UserConfigDir() (string, error) 用户配置目录
Executable func Executable() (string, error) 可执行文件路径

8.2.2 文件打开标志

常量 值 说明
O_RDONLY 0 只读
O_WRONLY 1 只写
O_RDWR 2 读写
O_APPEND 1024 追加
O_CREATE 256 不存在则创建
O_EXCL 512 与O_CREATE配合,文件存在则失败
O_TRUNC 512 打开时截断文件
O_SYNC 4096 同步写入

8.2.3 使用示例

GO
package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    // ========== 环境变量 ==========
    path := os.Getenv("PATH")
    fmt.Println("PATH:", path)

    home, _ := os.UserHomeDir()
    fmt.Println("主目录:", home)

    exe, _ := os.Executable()
    fmt.Println("可执行文件:", exe)

    dir, _ := os.Getwd()
    fmt.Println("工作目录:", dir)

    // ========== 命令行参数 ==========
    fmt.Println("程序名:", os.Args[0])
    for i, arg := range os.Args[1:] {
        fmt.Printf("参数%d: %s\n", i+1, arg)
    }

    // ========== 文件读取 ==========
    // 方式1:一次性读取(适合小文件)
    data, err := os.ReadFile("example.txt")
    if err != nil {
        fmt.Println("读取失败:", err)
    } else {
        fmt.Println("文件内容:", string(data))
    }

    // 方式2:打开文件流式读取(适合大文件)
    f, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("打开失败:", err)
    } else {
        defer f.Close()
        buf := make([]byte, 1024)
        n, err := f.Read(buf)
        if err == nil {
            fmt.Printf("读取了%d字节\n", n)
        }
    }

    // ========== 文件写入 ==========
    content := []byte("Hello, Go!\n这是写入的内容\n")
    err = os.WriteFile("output.txt", content, 0644)
    if err != nil {
        fmt.Println("写入失败:", err)
    }

    // ========== 文件追加写入 ==========
    f2, err := os.OpenFile("output.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        fmt.Println("打开失败:", err)
    } else {
        defer f2.Close()
        f2.WriteString("追加的内容\n")
    }

    // ========== 目录操作 ==========
    // 创建目录
    err = os.MkdirAll(filepath.Join("data", "subdir"), 0755)
    if err != nil {
        fmt.Println("创建目录失败:", err)
    }

    // 读取目录内容
    entries, err := os.ReadDir(".")
    if err != nil {
        fmt.Println("读取目录失败:", err)
    } else {
        for _, entry := range entries {
            fmt.Printf("  %s (目录:%v)\n", entry.Name(), entry.IsDir())
        }
    }

    // ========== 文件信息 ==========
    info, err := os.Stat("output.txt")
    if err != nil {
        fmt.Println("获取文件信息失败:", err)
    } else {
        fmt.Printf("文件名: %s\n", info.Name())
        fmt.Printf("大小: %d 字节\n", info.Size())
        fmt.Printf("权限: %s\n", info.Mode())
        fmt.Printf("修改时间: %s\n", info.ModTime())
        fmt.Printf("是否为目录: %v\n", info.IsDir())
    }

    // ========== 临时文件 ==========
    tmpFile, err := os.CreateTemp("", "example-*.txt")
    if err != nil {
        fmt.Println("创建临时文件失败:", err)
    } else {
        defer os.Remove(tmpFile.Name())  // 清理
        tmpFile.WriteString("临时内容")
        fmt.Println("临时文件:", tmpFile.Name())
        tmpFile.Close()
    }

    // ========== 进程操作 ==========
    fmt.Println("进程ID:", os.Getpid())
    fmt.Println("父进程ID:", os.Getppid())
}

8.3 io 包 —— 基础I/O接口

核心功能: 定义基本的I/O接口(Reader、Writer等),提供通用的I/O工具函数。

8.3.1 核心接口

GO
// Reader 接口:读取数据
// type Reader interface {
//     Read(p []byte) (n int, err error)
// }

// Writer 接口:写入数据
// type Writer interface {
//     Write(p []byte) (n int, err error)
// }

// Closer 接口:关闭资源
// type Closer interface {
//     Close() error
// }

// Seeker 接口:设置读写位置
// type Seeker interface {
//     Seek(offset int64, whence int) (int64, error)
// }

// 组合接口
// type ReadWriter interface { Reader; Writer }
// type ReadCloser interface { Reader; Closer }
// type WriteCloser interface { Writer; Closer }
// type ReadWriteCloser interface { Reader; Writer; Closer }
// type ReadSeeker interface { Reader; Seeker }
// type WriteSeeker interface { Writer; Seeker }
// type ReadWriteSeeker interface { Reader; Writer; Seeker }

8.3.2 函数列表

函数 签名 说明
Copy func Copy(dst Writer, src Reader) (written int64, err error) 复制数据(从Reader到Writer)
CopyN func CopyN(dst Writer, src Reader, n int64) (written int64, err error) 复制最多n字节
CopyBuffer func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) 带缓冲区的复制
ReadAll func ReadAll(r Reader) ([]byte, error) 读取所有数据
ReadAtLeast func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) 至少读取min字节
ReadFull func ReadFull(r Reader, buf []byte) (n int, err error) 精确读取 len(buf) 字节
WriteString func WriteString(w Writer, s string) (n int, err error) 写入字符串
LimitReader func LimitReader(r Reader, n int64) Reader 限制读取字节数的Reader
MultiReader func MultiReader(readers ...Reader) Reader 将多个Reader串联
MultiWriter func MultiWriter(writers ...Writer) Writer 将数据同时写入多个Writer
TeeReader func TeeReader(r Reader, w Writer) Reader 读取的同时写入到另一个Writer
NopCloser func NopCloser(r Reader) ReadCloser 将Reader包装为ReadCloser
Pipe func Pipe() (*PipeReader, *PipeWriter) 创建内存管道

8.3.3 使用示例

GO
package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
    // ========== io.Copy:数据复制 ==========
    // 从Reader复制到Writer(内部使用32KB缓冲区)
    src := strings.NewReader("Hello, io.Copy!")
    var dst bytes.Buffer
    written, _ := io.Copy(&dst, src)
    fmt.Printf("复制了%d字节: %s\n", written, dst.String())

    // ========== io.ReadAll:读取所有数据 ==========
    reader := strings.NewReader("读取所有内容")
    data, _ := io.ReadAll(reader)
    fmt.Println("ReadAll:", string(data))

    // ========== io.WriteString:写入字符串 ==========
    var buf bytes.Buffer
    io.WriteString(&buf, "写入字符串到Buffer\n")
    io.WriteString(&buf, "第二行内容")
    fmt.Println(buf.String())

    // ========== io.LimitReader:限制读取量 ==========
    bigReader := strings.NewReader("1234567890ABCDEFGHIJ")
    limited := io.LimitReader(bigReader, 10)
    limitedData, _ := io.ReadAll(limited)
    fmt.Println("限制10字节:", string(limitedData))

    // ========== io.MultiReader:合并多个Reader ==========
    r1 := strings.NewReader("第一部分 ")
    r2 := strings.NewReader("第二部分 ")
    r3 := strings.NewReader("第三部分")
    multi := io.MultiReader(r1, r2, r3)
    combined, _ := io.ReadAll(multi)
    fmt.Println("合并:", string(combined))

    // ========== io.MultiWriter:写入多个Writer ==========
    var buf1, buf2 bytes.Buffer
    mw := io.MultiWriter(&buf1, &buf2)
    mw.Write([]byte("同时写入两个Buffer"))
    fmt.Println("buf1:", buf1.String())
    fmt.Println("buf2:", buf2.String())

    // ========== io.TeeReader:分流读取 ==========
    // 读取数据的同时将数据写入另一个Writer(类似Unix tee命令)
    teeReader := strings.NewReader("TeeReader示例")
    var teeBuf bytes.Buffer
    tee := io.TeeReader(teeReader, &teeBuf)
    teeData, _ := io.ReadAll(tee)
    fmt.Println("Tee读取:", string(teeData))
    fmt.Println("Tee旁路:", teeBuf.String())

    // ========== io.Pipe:内存管道 ==========
    // 用于连接期望Reader的代码和期望Writer的代码
    pipeReader, pipeWriter := io.Pipe()

    // 写入端
    go func() {
        defer pipeWriter.Close()
        pipeWriter.Write([]byte("通过管道传输的数据"))
    }()

    // 读取端
    pipeData, _ := io.ReadAll(pipeReader)
    fmt.Println("Pipe读取:", string(pipeData))

    // ========== io.ReadFull:精确读取 ==========
    reader2 := strings.NewReader("Hello, Go!")
    buf := make([]byte, 5)
    n, _ := io.ReadFull(reader2, buf)
    fmt.Printf("精确读取%d字节: %s\n", n, buf)

    // ========== 文件复制示例 ==========
    // srcFile, _ := os.Open("source.txt")
    // defer srcFile.Close()
    // dstFile, _ := os.Create("destination.txt")
    // defer dstFile.Close()
    // io.Copy(dstFile, srcFile)
}

8.4 path/filepath 包 —— 文件路径操作

核心功能: 跨平台的文件路径操作,处理路径分隔符、路径清理、通配符匹配等。

函数 签名 说明
Base func Base(path string) string 路径最后元素
Dir func Dir(path string) string 路径目录部分
Ext func Ext(path string) string 文件扩展名
Clean func Clean(path string) string 清理路径
Join func Join(elem ...string) string 拼接路径
Split func Split(path string) (dir, file string) 分割路径
Abs func Abs(path string) (string, error) 绝对路径
Rel func Rel(basepath, targpath string) (string, error) 相对路径
Walk func Walk(root string, fn WalkFunc) error 遍历目录树
WalkDir func WalkDir(root string, fn WalkDirFunc) error 遍历目录树(Go 1.16+更高效)
Glob func Glob(pattern string) (matches []string, err error) 通配符匹配
Match func Match(pattern, name string) (matched bool, err error) 路径匹配
FromSlash func FromSlash(path string) string / 转为系统分隔符
ToSlash func ToSlash(path string) string 系统分隔符转为 /
IsAbs func IsAbs(path string) bool 判断是否为绝对路径
GO
package main

import (
    "fmt"
    "path/filepath"
)

func main() {
    // ========== 路径解析 ==========
    path := "/home/user/docs/report.pdf"

    fmt.Println("Base:", filepath.Base(path))          // report.pdf
    fmt.Println("Dir:", filepath.Dir(path))            // /home/user/docs
    fmt.Println("Ext:", filepath.Ext(path))            // .pdf
    fmt.Println("Clean:", filepath.Clean("a//b/../c")) // a/c

    dir, file := filepath.Split(path)
    fmt.Println("Split:", dir, "|", file)  // /home/user/docs/ | report.pdf

    // ========== 路径拼接 ==========
    joined := filepath.Join("/home", "user", "docs", "file.txt")
    fmt.Println("Join:", joined)  // /home/user/docs/file.txt

    // ========== 绝对路径和相对路径 ==========
    abs, _ := filepath.Abs(".")
    fmt.Println("绝对路径:", abs)

    rel, _ := filepath.Rel("/home/user", "/home/user/docs/report.pdf")
    fmt.Println("相对路径:", rel)  // docs/report.pdf

    // ========== 通配符匹配 ==========
    matches, _ := filepath.Glob("*.go")
    fmt.Println("匹配的Go文件:", matches)

    matched, _ := filepath.Match("*.txt", "readme.txt")
    fmt.Println("匹配结果:", matched)  // true

    // ========== 目录遍历 ==========
    fmt.Println("遍历当前目录:")
    filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if !info.IsDir() {
            fmt.Printf("  %s (%d字节)\n", path, info.Size())
        }
        return nil
    })
}

8.5 strings 包 —— 字符串操作

核心功能: 提供字符串操作函数,包括查找、替换、分割、拼接、修剪等。

函数 签名 说明
Contains func Contains(s, substr string) bool 是否包含子串
ContainsAny func ContainsAny(s, chars string) bool 是否包含任意字符
Count func Count(s, substr string) int 子串出现次数
HasPrefix func HasPrefix(s, prefix string) bool 是否以prefix开头
HasSuffix func HasSuffix(s, suffix string) bool 是否以suffix结尾
Index func Index(s, substr string) int 子串首次出现位置
LastIndex func LastIndex(s, substr string) int 子串最后出现位置
Join func Join(elems []string, sep string) string 连接字符串
Split func Split(s, sep string) []string 分割字符串
SplitN func SplitN(s, sep string, n int) []string 分割为n段
SplitAfter func SplitAfter(s, sep string) []string 分割后保留分隔符
Fields func Fields(s string) []string 按空白字符分割
FieldsFunc func FieldsFunc(s string, f func(rune) bool) []string 自定义分割函数
Replace func Replace(s, old, new string, n int) string 替换子串(n次)
ReplaceAll func ReplaceAll(s, old, new string) string 替换所有子串
ToLower func ToLower(s string) string 转小写
ToUpper func ToUpper(s string) string 转大写
ToTitle func ToTitle(s string) string 转标题大小写
Trim func Trim(s, cutset string) string 修剪前后字符
TrimSpace func TrimSpace(s string) string 修剪前后空白
TrimPrefix func TrimPrefix(s, prefix string) string 修剪前缀
TrimSuffix func TrimSuffix(s, suffix string) string 修剪后缀
Repeat func Repeat(s string, count int) string 重复字符串
Compare func Compare(a, b string) int 比较字符串
EqualFold func EqualFold(s, t string) bool 忽略大小写比较
Builder type Builder struct{...} 高效字符串构建器
Reader type Reader struct{...} 字符串Reader
GO
package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "  Hello, Go Programming Language!  "

    // ========== 查找 ==========
    fmt.Println("Contains Go:", strings.Contains(s, "Go"))
    fmt.Println("HasPrefix Hello:", strings.HasPrefix(strings.TrimSpace(s), "Hello"))
    fmt.Println("HasSuffix !:", strings.HasSuffix(s, "!  "))
    fmt.Println("Index Go:", strings.Index(s, "Go"))
    fmt.Println("Count o:", strings.Count(s, "o"))

    // ========== 分割与合并 ==========
    words := strings.Fields(s)
    fmt.Println("Fields:", words)

    parts := strings.Split("a,b,c,d", ",")
    fmt.Println("Split:", parts)

    joined := strings.Join(parts, "-")
    fmt.Println("Join:", joined)  // a-b-c-d

    // ========== 替换 ==========
    replaced := strings.Replace(s, "o", "0", 2)
    fmt.Println("Replace前2个o:", replaced)

    replacedAll := strings.ReplaceAll(s, "o", "0")
    fmt.Println("ReplaceAll:", replacedAll)

    // ========== 大小写转换 ==========
    fmt.Println("ToUpper:", strings.ToUpper(s))
    fmt.Println("ToLower:", strings.ToLower(s))

    // ========== 修剪 ==========
    fmt.Println("TrimSpace:", strings.TrimSpace(s))
    fmt.Println("TrimPrefix:", strings.TrimPrefix("file.txt", "file"))    // .txt
    fmt.Println("TrimSuffix:", strings.TrimSuffix("file.txt", ".txt"))    // file
    fmt.Println("Trim:", strings.Trim("!!Hello!!", "!"))                 // Hello

    // ========== 重复 ==========
    fmt.Println("Repeat:", strings.Repeat("Go ", 3))  // Go Go Go

    // ========== 比较 ==========
    fmt.Println("EqualFold:", strings.EqualFold("Go", "go"))  // true

    // ========== strings.Builder:高效构建字符串 ==========
    // 比 + 或 fmt.Sprintf 更高效,适合循环拼接
    var builder strings.Builder
    builder.WriteString("Hello")
    builder.WriteString(", ")
    builder.WriteString("World!")
    fmt.Println("Builder:", builder.String())

    builder.Reset()  // 重置
    builder.Grow(100)  // 预分配内存
    for i := 0; i < 5; i++ {
        fmt.Fprintf(&builder, "Item %d, ", i)
    }
    result := builder.String()
    fmt.Println("Builder result:", result)

    // ========== strings.Reader:字符串Reader ==========
    reader := strings.NewReader("Hello, Go Reader!")
    buf := make([]byte, 5)
    n, _ := reader.Read(buf)
    fmt.Printf("读取%d字节: %s\n", n, buf)
    fmt.Printf("剩余未读: %d字节\n", reader.Len())

    // ========== 按函数分割 ==========
    csv := "apple,banana;cherry,date"
    fields := strings.FieldsFunc(csv, func(r rune) bool {
        return r == ',' || r == ';'
    })
    fmt.Println("FieldsFunc:", fields)
}

8.6 strconv 包 —— 字符串与基本类型转换

核心功能: 字符串与基本数据类型之间的转换。

函数 签名 说明
Itoa func Itoa(i int) string int → string
Atoi func Atoi(s string) (int, error) string → int
FormatBool func FormatBool(b bool) string bool → string
ParseBool func ParseBool(str string) (bool, error) string → bool
FormatFloat func FormatFloat(f float64, fmt byte, prec, bitSize int) string float64 → string
ParseFloat func ParseFloat(s string, bitSize int) (float64, error) string → float64
FormatInt func FormatInt(i int64, base int) string int64 → string(按进制)
ParseInt func ParseInt(s string, base int, bitSize int) (int64, error) string → int64(按进制)
FormatUint func FormatUint(i uint64, base int) string uint64 → string
ParseUint func ParseUint(s string, base int, bitSize int) (uint64, error) string → uint64
Quote func Quote(s string) string 添加Go语法引号
Unquote func Unquote(s string) (string, error) 去除Go语法引号
AppendBool func AppendBool(dst []byte, b bool) []byte 追加转换后的bool
AppendFloat func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte 追加转换后的float
AppendInt func AppendInt(dst []byte, i int64, base int) []byte 追加转换后的int

FormatFloat 的 fmt 参数格式

fmt 说明 示例(3.14159, prec=2)
‘f’ 十进制(无指数) “3.14”
‘e’ 科学计数法(e) “3.14e+00”
‘E’ 科学计数法(E) “3.14E+00”
‘g’ 自动选择最紧凑格式 “3.1”
‘G’ 同’g’,用大写E “3.1”
‘b’ 二进制指数 “7074237752028440p-51”
GO
package main

import (
    "fmt"
    "strconv"
)

func main() {
    // ========== 整数转换 ==========
    // int -> string
    s1 := strconv.Itoa(42)
    fmt.Println("Itoa:", s1, "类型:", fmt.Sprintf("%T", s1))

    // string -> int
    n1, err := strconv.Atoi("42")
    fmt.Println("Atoi:", n1, err)

    n2, err := strconv.Atoi("42abc")  // 错误:不是纯数字
    fmt.Println("Atoi错误:", n2, err)

    // ========== 按进制转换 ==========
    // int64 -> 不同进制的string
    fmt.Println("FormatInt(255, 2):", strconv.FormatInt(255, 2))   // 11111111
    fmt.Println("FormatInt(255, 8):", strconv.FormatInt(255, 8))   // 377
    fmt.Println("FormatInt(255, 16):", strconv.FormatInt(255, 16)) // ff

    // 不同进制的string -> int64
    parsed, _ := strconv.ParseInt("11111111", 2, 64)
    fmt.Println("ParseInt二进制:", parsed)  // 255

    parsed, _ = strconv.ParseInt("ff", 16, 64)
    fmt.Println("ParseInt十六进制:", parsed)  // 255

    // ========== 浮点数转换 ==========
    // float64 -> string
    fStr1 := strconv.FormatFloat(3.14159, 'f', 2, 64)   // 3.14
    fStr2 := strconv.FormatFloat(3.14159, 'e', 3, 64)   // 3.142e+00
    fStr3 := strconv.FormatFloat(3.14159, 'g', 4, 64)   // 3.142
    fmt.Printf("FormatFloat: %s, %s, %s\n", fStr1, fStr2, fStr3)

    // string -> float64
    f, _ := strconv.ParseFloat("3.14159", 64)
    fmt.Printf("ParseFloat: %.5f\n", f)

    // ========== 布尔值转换 ==========
    bStr := strconv.FormatBool(true)
    fmt.Println("FormatBool:", bStr)  // "true"

    b, _ := strconv.ParseBool("true")
    fmt.Println("ParseBool:", b)

    // ParseBool 可接受的字符串(不区分大小写)
    // true:  "1", "t", "T", "TRUE", "true", "True"
    // false: "0", "f", "F", "FALSE", "false", "False"

    // ========== 引号处理 ==========
    quoted := strconv.Quote("Hello, \"World\"!\n")
    fmt.Println("Quote:", quoted)  // "Hello, \"World\"!\n"

    unquoted, _ := strconv.Unquote(quoted)
    fmt.Println("Unquote:", unquoted)

    // ========== Append 系列(高效追加到字节切片)==========
    buf := []byte("Count: ")
    buf = strconv.AppendInt(buf, 42, 10)
    buf = append(buf, ", Value: "...)
    buf = strconv.AppendFloat(buf, 3.14, 'f', 2, 64)
    fmt.Println("Append结果:", string(buf))
}

8.7 bytes 包 —— 字节切片操作

核心功能: 类似于 strings 包,但操作对象是 []byte 而不是 string。

bytes 包提供了与 strings 包几乎完全对应的函数集,主要区别在于操作的数据类型:

strings 函数 bytes 对应函数
strings.Contains bytes.Contains
strings.Count bytes.Count
strings.Index bytes.Index
strings.Join bytes.Join
strings.Split bytes.Split
strings.Replace bytes.Replace
strings.ToLower bytes.ToLower
strings.Trim bytes.Trim
strings.Builder bytes.Buffer
strings.Reader bytes.Reader
GO
package main

import (
    "bytes"
    "fmt"
)

func main() {
    // ========== bytes.Buffer:可增长的字节缓冲区 ==========
    // 实现了 io.Reader 和 io.Writer 接口
    var buf bytes.Buffer

    // 写入
    buf.Write([]byte("Hello"))
    buf.WriteByte(' ')
    buf.WriteString("World!")
    buf.WriteRune('🚀')

    fmt.Println("Buffer内容:", buf.String())
    fmt.Println("Buffer长度:", buf.Len())
    fmt.Println("Buffer容量:", buf.Cap())

    // 读取
    data := make([]byte, 5)
    n, _ := buf.Read(data)
    fmt.Printf("读取%d字节: %s\n", n, data)

    // 读取到分隔符
    line, _ := buf.ReadString('!')
    fmt.Println("读到分隔符:", line)

    // 重置
    buf.Reset()
    fmt.Println("重置后长度:", buf.Len())

    // 预分配(减少扩容)
    buf.Grow(1024)

    // 读取剩余所有字节
    buf.WriteString("Go语言编程")
    remaining := buf.Bytes()
    fmt.Println("剩余字节:", string(remaining))
}

8.8 bufio 包 —— 带缓冲的I/O

核心功能: 提供带缓冲的I/O操作,通过减少系统调用次数来提升读写性能。

主要类型和函数

类型/函数 签名/说明
NewReader func NewReader(rd io.Reader) *Reader —— 创建带缓冲的Reader(默认4096字节)
NewReaderSize func NewReaderSize(rd io.Reader, size int) *Reader —— 指定缓冲区大小
NewWriter func NewWriter(w io.Writer) *Writer —— 创建带缓冲的Writer
NewWriterSize func NewWriterSize(w io.Writer, size int) *Writer —— 指定缓冲区大小
NewScanner func NewScanner(r io.Reader) *Scanner —— 创建扫描器(按行/单词扫描)

Reader 主要方法

方法 说明
Read(p []byte) (n int, err error) 读取数据到p
ReadByte() (byte, error) 读取一个字节
ReadRune() (r rune, size int, err error) 读取一个Unicode字符
ReadBytes(delim byte) ([]byte, error) 读取到分隔符(包含分隔符)
ReadString(delim byte) (string, error) 读取到分隔符返回字符串
ReadLine() (line []byte, isPrefix bool, err error) 读取一行(低级别)
Peek(n int) ([]byte, error) 预读n字节,不移动读取位置

Writer 主要方法

方法 说明
Write(p []byte) (nn int, err error) 写入数据
WriteByte(c byte) error 写入一个字节
WriteRune(r rune) (size int, err error) 写入Unicode字符
WriteString(s string) (int, error) 写入字符串
Flush() error 刷新缓冲区到下层Writer

Scanner 主要方法

方法 说明
Scan() bool 扫描下一个token
Text() string 返回当前token的字符串
Bytes() []byte 返回当前token的字节切片
Split(split SplitFunc) 设置分割函数

Scanner 预定义分割函数

函数 说明
ScanLines 按行分割(默认)
ScanWords 按单词分割
ScanRunes 按Unicode字符分割
ScanBytes 按字节分割
GO
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    // ========== bufio.Writer:缓冲写入 ==========
    f, _ := os.Create("bufio_test.txt")
    defer f.Close()

    writer := bufio.NewWriter(f)
    writer.WriteString("Hello, bufio!\n")
    writer.WriteString("这是第二行\n")
    writer.WriteString("这是第三行\n")
    writer.Flush()  // 必须Flush才能将缓冲区的数据写入文件

    // ========== bufio.Reader:缓冲读取 ==========
    reader := strings.NewReader("Hello, Go!\n这是bufio读取的数据")
    bufReader := bufio.NewReader(reader)

    // 读取一行
    line, _ := bufReader.ReadString('\n')
    fmt.Println("第一行:", line)

    // 预读(不移动读取光标)
    peek, _ := bufReader.Peek(4)
    fmt.Println("预读4字节:", string(peek))

    // 读取剩余数据
    remaining, _ := bufReader.ReadString('\n')
    fmt.Println("剩余:", remaining)

    // ========== bufio.Scanner:逐行扫描 ==========
    input := "第一行\n第二行\n第三行\n"
    scanner := bufio.NewScanner(strings.NewReader(input))

    fmt.Println("逐行扫描:")
    lineNum := 1
    for scanner.Scan() {
        fmt.Printf("  行%d: %s\n", lineNum, scanner.Text())
        lineNum++
    }
    if err := scanner.Err(); err != nil {
        fmt.Println("扫描错误:", err)
    }

    // ========== Scanner 按单词扫描 ==========
    text := "Hello World Go Language"
    wordScanner := bufio.NewScanner(strings.NewReader(text))
    wordScanner.Split(bufio.ScanWords)

    fmt.Println("按单词扫描:")
    for wordScanner.Scan() {
        fmt.Println("  ", wordScanner.Text())
    }

    // ========== 读取大文件示例 ==========
    // file, _ := os.Open("large_file.txt")
    // defer file.Close()
    // scanner := bufio.NewScanner(file)
    // scanner.Buffer(make([]byte, 1024*1024), 1024*1024) // 增大缓冲区
    // for scanner.Scan() {
    //     processLine(scanner.Text())
    // }
}

8.9 encoding/json 包 —— JSON编解码

核心功能: 提供JSON数据的编码(序列化)和解码(反序列化)功能。

主要函数

函数 签名 说明
Marshal func Marshal(v any) ([]byte, error) 将Go值序列化为JSON字节切片
MarshalIndent func MarshalIndent(v any, prefix, indent string) ([]byte, error) 带缩进的序列化
Unmarshal func Unmarshal(data []byte, v any) error 将JSON反序列化为Go值
NewEncoder func NewEncoder(w io.Writer) *Encoder 创建JSON编码器(流式)
NewDecoder func NewDecoder(r io.Reader) *Decoder 创建JSON解码器(流式)

Encoder/Decoder 方法

方法 说明
Encoder.Encode(v any) error 编码并写入
Encoder.SetIndent(prefix, indent string) 设置缩进
Decoder.Decode(v any) error 从流中解码
Decoder.DisallowUnknownFields() 禁止未知字段

JSON Tag 常用选项

选项 说明 示例
json:"fieldname" 指定JSON字段名 json:"user_name"
json:"-" 忽略该字段 json:"-"
json:",omitempty" 零值时忽略 json:"age,omitempty"
json:",string" 转为字符串类型 json:"id,string"
GO
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "os"
)

type Person struct {
    Name    string   `json:"name"`
    Age     int      `json:"age,omitempty"`
    Email   string   `json:"email,omitempty"`
    Tags    []string `json:"tags,omitempty"`
    secret  string   `json:"-"`  // 不会被序列化
}

func main() {
    // ========== Marshal:序列化 ==========
    p := Person{
        Name:  "张三",
        Age:   30,
        Email: "zhangsan@example.com",
        Tags:  []string{"go", "programming"},
    }

    data, _ := json.Marshal(p)
    fmt.Println("Marshal:", string(data))

    // 带缩进的序列化
    prettyData, _ := json.MarshalIndent(p, "", "  ")
    fmt.Println("MarshalIndent:\n", string(prettyData))

    // ========== Unmarshal:反序列化 ==========
    jsonStr := `{"name":"李四","age":25,"email":"lisi@example.com","tags":["java","spring"]}`
    var p2 Person
    err := json.Unmarshal([]byte(jsonStr), &p2)
    if err != nil {
        fmt.Println("解析错误:", err)
    } else {
        fmt.Printf("Unmarshal: %+v\n", p2)
    }

    // ========== 解析为 map ==========
    var result map[string]interface{}
    json.Unmarshal([]byte(jsonStr), &result)
    fmt.Println("解析为map:", result)
    fmt.Println("name:", result["name"])

    // ========== 解析未知结构的JSON ==========
    complexJSON := `{
        "users": [
            {"id": 1, "name": "Alice"},
            {"id": 2, "name": "Bob"}
        ],
        "total": 2,
        "page": 1
    }`

    var data2 struct {
        Users []struct {
            ID   int    `json:"id"`
            Name string `json:"name"`
        } `json:"users"`
        Total int `json:"total"`
    }
    json.Unmarshal([]byte(complexJSON), &data2)
    fmt.Printf("解析嵌套JSON: %+v\n", data2)

    // ========== Encoder/Decoder:流式编解码 ==========
    // 编码到文件
    f, _ := os.Create("person.json")
    defer f.Close()
    encoder := json.NewEncoder(f)
    encoder.SetIndent("", "  ")
    encoder.Encode(p)

    // 从文件解码
    jsonData := []byte(`{"name":"王五","age":35}`)
    decoder := json.NewDecoder(bytes.NewReader(jsonData))
    var p3 Person
    decoder.Decode(&p3)
    fmt.Printf("Decoder: %+v\n", p3)

    // ========== RawMessage:延迟解析 ==========
    // 当某个字段的类型不确定时,可以先用RawMessage保存
    type Event struct {
        Type string          `json:"type"`
        Data json.RawMessage `json:"data"`
    }

    eventJSON := `{"type":"login","data":{"username":"admin","ip":"127.0.0.1"}}`
    var event Event
    json.Unmarshal([]byte(eventJSON), &event)
    fmt.Printf("Event类型: %s, 原始数据: %s\n", event.Type, event.Data)

    // ========== Number:保持数字精度 ==========
    // 默认情况下,JSON数字会被解析为float64,可能丢失精度
    // 使用 Decoder.UseNumber() 可以保持精度
    numberJSON := `{"price": 123.456, "count": 999999999999999999}`
    dec := json.NewDecoder(bytes.NewReader([]byte(numberJSON)))
    dec.UseNumber()
    var numData map[string]interface{}
    dec.Decode(&numData)
    fmt.Printf("类型: price=%T, count=%T\n", numData["price"], numData["count"])
}

8.10 time 包 —— 时间处理

核心功能: 时间测量和显示,包括时间点的表示、时间间隔的计算、定时器等。

主要类型

类型 说明
Time 时间点,精确到纳秒,包含时区信息
Duration 时间段,以纳秒为单位的 int64 类型
Location 时区
Timer 一次性定时器(触发后失效)
Ticker 周期性定时器(每隔一段时间触发)

常用函数

函数 签名 说明
Now func Now() Time 当前时间
Date func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time 创建指定时间
Parse func Parse(layout, value string) (Time, error) 解析时间字符串
ParseInLocation func ParseInLocation(layout, value string, loc *Location) (Time, error) 指定时区解析
Unix func Unix(sec int64, nsec int64) Time 从Unix时间戳创建
Since func Since(t Time) Duration 从t到现在的时长
Until func Until(t Time) Duration 从现在到t的时长
Sleep func Sleep(d Duration) 暂停当前goroutine
After func After(d Duration) <-chan Time 返回一个channel,d时间后发送信号
Tick func Tick(d Duration) <-chan Time 返回周期性发送信号的channel
NewTimer func NewTimer(d Duration) *Timer 创建一次性定时器
NewTicker func NewTicker(d Duration) *Ticker 创建周期性定时器
FixedZone func FixedZone(name string, offset int) *Location 创建固定偏移时区
LoadLocation func LoadLocation(name string) (*Location, error) 加载时区

Time 方法

方法 返回值 说明
Year() int 年份
Month() Month 月份
Day() int 日
Hour() int 小时
Minute() int 分钟
Second() int 秒
Nanosecond() int 纳秒
Weekday() Weekday 星期几
Unix() int64 Unix时间戳(秒)
UnixMilli() int64 Unix时间戳(毫秒)
UnixNano() int64 Unix时间戳(纳秒)
Format(layout) string 格式化时间
Add(d Duration) Time 加上时间段
Sub(t Time) Duration 时间差
Before(t Time) bool 是否在t之前
After(t Time) bool 是否在t之后
Equal(t Time) bool 是否相等
In(loc *Location) Time 转换时区
Local() Time 转为本地时间
UTC() Time 转为UTC时间
IsZero() bool 是否为零值

时间格式化参考时间

Mon Jan 2 15:04:05 MST 2006(2006-01-02 15:04:05,1 2 3 4 5 6 7记忆法)

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    // ========== 当前时间 ==========
    now := time.Now()
    fmt.Println("当前时间:", now)
    fmt.Printf("年=%d, 月=%d, 日=%d, 时=%d, 分=%d, 秒=%d\n",
        now.Year(), now.Month(), now.Day(),
        now.Hour(), now.Minute(), now.Second())
    fmt.Println("星期:", now.Weekday())
    fmt.Println("Unix秒:", now.Unix())
    fmt.Println("Unix毫秒:", now.UnixMilli())

    // ========== 时间格式化 ==========
    // Go使用特定的参考时间:Mon Jan 2 15:04:05 MST 2006
    fmt.Println("标准格式:", now.Format("2006-01-02 15:04:05"))
    fmt.Println("RFC3339:", now.Format(time.RFC3339))
    fmt.Println("日期:", now.Format("2006-01-02"))
    fmt.Println("时间:", now.Format("15:04:05"))
    fmt.Println("12小时制:", now.Format("2006-01-02 03:04:05 PM"))
    fmt.Println("中文格式:", now.Format("2006年01月02日 15时04分05秒"))

    // ========== 时间解析 ==========
    t1, _ := time.Parse("2006-01-02 15:04:05", "2024-06-15 14:30:00")
    fmt.Println("解析时间:", t1)

    // 从Unix时间戳创建
    t2 := time.Unix(1718438400, 0)
    fmt.Println("从时间戳创建:", t2)
    t3 := time.UnixMilli(1718438400000)
    fmt.Println("从毫秒时间戳创建:", t3)

    // ========== 时间运算 ==========
    now = time.Now()

    // 加减时间
    oneHourLater := now.Add(time.Hour)
    tenMinutesAgo := now.Add(-10 * time.Minute)
    twoDaysLater := now.AddDate(0, 0, 2)
    oneMonthAgo := now.AddDate(0, -1, 0)

    fmt.Println("一小时后:", oneHourLater)
    fmt.Println("十分钟前:", tenMinutesAgo)
    fmt.Println("两天后:", twoDaysLater)
    fmt.Println("一个月前:", oneMonthAgo)

    // 时间差
    duration := oneHourLater.Sub(now)
    fmt.Printf("时间差: %.0f分钟\n", duration.Minutes())

    // 比较
    fmt.Println("now before oneHourLater:", now.Before(oneHourLater))
    fmt.Println("now after tenMinutesAgo:", now.After(tenMinutesAgo))

    // ========== Duration ==========
    var d time.Duration = 2*time.Hour + 30*time.Minute + 15*time.Second
    fmt.Printf("自定义Duration: %s\n", d)
    fmt.Printf("  小时: %.2f\n", d.Hours())
    fmt.Printf("  分钟: %.0f\n", d.Minutes())
    fmt.Printf("  秒: %.0f\n", d.Seconds())
    fmt.Printf("  毫秒: %d\n", d.Milliseconds())

    // ========== 定时器 ==========
    // Timer:一次性定时器
    timer := time.NewTimer(2 * time.Second)
    fmt.Println("等待Timer...")
    <-timer.C  // 阻塞等待2秒
    fmt.Println("Timer触发!")

    // 使用After(便捷方式)
    <-time.After(500 * time.Millisecond)

    // 停止定时器
    timer2 := time.NewTimer(time.Second)
    go func() {
        <-timer2.C
        fmt.Println("这条不会打印,因为timer被停止了")
    }()
    stopped := timer2.Stop()
    if stopped {
        fmt.Println("Timer被成功停止")
    }

    // ========== Ticker:周期性定时器 ==========
    ticker := time.NewTicker(500 * time.Millisecond)
    done := make(chan bool)

    go func() {
        count := 0
        for {
            select {
            case t := <-ticker.C:
                fmt.Println("Ticker触发:", t.Format("15:04:05.000"))
                count++
                if count >= 3 {
                    ticker.Stop()
                    done <- true
                    return
                }
            }
        }
    }()
    <-done
    fmt.Println("Ticker已停止")

    // ========== 时区处理 ==========
    // 加载时区
    loc, _ := time.LoadLocation("Asia/Shanghai")
    shanghaiTime := time.Now().In(loc)
    fmt.Println("上海时间:", shanghaiTime)

    // UTC时间
    utcTime := now.UTC()
    fmt.Println("UTC时间:", utcTime)

    // 固定偏移时区
    east8 := time.FixedZone("UTC+8", 8*3600)
    t4 := time.Date(2024, 6, 15, 14, 30, 0, 0, east8)
    fmt.Println("指定时区时间:", t4)

    // ========== 性能计时 ==========
    start := time.Now()
    // 执行一些操作...
    time.Sleep(100 * time.Millisecond)
    elapsed := time.Since(start)
    fmt.Printf("操作耗时: %s (%d毫秒)\n", elapsed, elapsed.Milliseconds())
}

8.11 net/http 包 —— HTTP客户端与服务器

核心功能: 提供HTTP客户端和HTTP服务器实现。

HTTP 客户端函数

函数/类型 说明
http.Get(url) 发送GET请求,返回 (*Response, error)
http.Post(url, contentType, body) 发送POST请求
http.PostForm(url, data) 发送POST表单请求
http.Head(url) 发送HEAD请求
http.NewRequest(method, url, body) 创建自定义请求
http.DefaultClient 默认HTTP客户端
&http.Client{...} 自定义HTTP客户端(可设置超时等)

HTTP 服务器函数

函数/类型 说明
http.HandleFunc(pattern, handler) 注册路由处理函数
http.Handle(pattern, handler) 注册路由处理器
http.ListenAndServe(addr, handler) 启动HTTP服务器
http.ServeMux HTTP请求多路复用器(路由器)
http.FileServer(root) 静态文件服务器
http.StripPrefix(prefix, handler) 去除URL前缀
http.Redirect(w, r, url, code) 重定向
http.Error(w, msg, code) 发送HTTP错误响应
http.NotFound(w, r) 发送404响应

Request 结构体主要字段

字段 类型 说明
Method string 请求方法(GET/POST等)
URL *url.URL 请求URL
Header Header 请求头
Body io.ReadCloser 请求体
Form url.Values 解析后的表单数据
PostForm url.Values 仅POST表单数据
RemoteAddr string 客户端地址
Context context.Context 请求上下文

Response 结构体主要字段

字段 类型 说明
Status string 状态文本(如”200 OK”)
StatusCode int 状态码
Header Header 响应头
Body io.ReadCloser 响应体
GO
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

// ========== HTTP 服务器 ==========
func main() {
    // 注册路由
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/hello", helloHandler)
    http.HandleFunc("/user/", userHandler)
    http.HandleFunc("/api/json", jsonHandler)
    http.HandleFunc("/form", formHandler)

    // 静态文件服务器
    // http.Handle("/static/", http.StripPrefix("/static/",
    //     http.FileServer(http.Dir("./static"))))

    // 自定义服务器配置
    server := &http.Server{
        Addr:         ":8080",
        Handler:      nil,  // nil表示使用默认路由DefaultServeMux
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  30 * time.Second,
    }

    fmt.Println("服务器启动在 http://localhost:8080")
    server.ListenAndServe()
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        http.NotFound(w, r)
        return
    }
    fmt.Fprintf(w, "欢迎来到Go HTTP服务器!\n")
    fmt.Fprintf(w, "方法: %s\n", r.Method)
    fmt.Fprintf(w, "路径: %s\n", r.URL.Path)
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    // 获取查询参数
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "World"
    }
    fmt.Fprintf(w, "Hello, %s!\n", name)
}

func userHandler(w http.ResponseWriter, r *http.Request) {
    // URL路径参数解析
    id := r.URL.Path[len("/user/"):]
    fmt.Fprintf(w, "用户ID: %s\n", id)
    fmt.Fprintf(w, "查询参数: %v\n", r.URL.Query())
}

func jsonHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    data := map[string]interface{}{
        "status": "ok",
        "time":   time.Now().Format(time.RFC3339),
        "method": r.Method,
    }

    json.NewEncoder(w).Encode(data)
}

func formHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == "POST" {
        // 解析表单数据
        r.ParseForm()

        username := r.FormValue("username")
        password := r.FormValue("password")

        fmt.Fprintf(w, "用户名: %s\n", username)
        fmt.Fprintf(w, "密码: %s\n", password)
        fmt.Fprintf(w, "原始Form: %v\n", r.Form)
    } else {
        // 显示表单页面
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
        fmt.Fprintf(w, `
<form method="POST" action="/form">
    <input name="username" placeholder="用户名">
    <input name="password" type="password" placeholder="密码">
    <button type="submit">提交</button>
</form>`)
    }
}

HTTP 客户端使用示例

GO
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
    "time"
)

func main() {
    // ========== GET 请求 ==========
    resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        fmt.Println("GET请求失败:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("状态: %s\n", resp.Status)
    fmt.Printf("状态码: %d\n", resp.StatusCode)

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("响应体:", string(body[:100]), "...")

    // ========== 带查询参数的GET请求 ==========
    params := url.Values{}
    params.Add("userId", "1")
    fullURL := "https://jsonplaceholder.typicode.com/posts?" + params.Encode()
    fmt.Println("带参数URL:", fullURL)

    // ========== POST 请求 (JSON) ==========
    jsonData := map[string]interface{}{
        "title":  "Go Tutorial",
        "body":   "Learning Go is fun",
        "userId": 1,
    }
    jsonBytes, _ := json.Marshal(jsonData)

    resp2, err := http.Post(
        "https://jsonplaceholder.typicode.com/posts",
        "application/json",
        bytes.NewBuffer(jsonBytes),
    )
    if err != nil {
        fmt.Println("POST请求失败:", err)
        return
    }
    defer resp2.Body.Close()
    fmt.Println("POST状态:", resp2.Status)

    // ========== POST 表单 ==========
    formData := url.Values{
        "username": {"gopher"},
        "password": {"secret123"},
    }
    resp3, err := http.PostForm(
        "https://httpbin.org/post",
        formData,
    )
    if err != nil {
        fmt.Println("POST表单失败:", err)
        return
    }
    defer resp3.Body.Close()
    fmt.Println("POST表单状态:", resp3.Status)

    // ========== 自定义请求(设置请求头) ==========
    req, _ := http.NewRequest("GET", "https://jsonplaceholder.typicode.com/posts/1", nil)
    req.Header.Set("User-Agent", "Go-HTTP-Client/1.0")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp4, err := client.Do(req)
    if err != nil {
        fmt.Println("自定义请求失败:", err)
        return
    }
    defer resp4.Body.Close()
    fmt.Println("自定义请求状态:", resp4.Status)

    // ========== 带超时的客户端 ==========
    timeoutClient := &http.Client{
        Timeout: 5 * time.Second,
        Transport: &http.Transport{
            MaxIdleConns:        10,
            IdleConnTimeout:     30 * time.Second,
            DisableCompression:  false,
        },
    }

    req2, _ := http.NewRequest("GET", "https://jsonplaceholder.typicode.com/posts", nil)
    resp5, err := timeoutClient.Do(req2)
    if err != nil {
        fmt.Println("超时客户端请求失败:", err)
        return
    }
    defer resp5.Body.Close()
    fmt.Println("超时客户端状态:", resp5.Status)

    // ========== 处理响应 ==========
    // 检查Content-Type
    contentType := resp5.Header.Get("Content-Type")
    fmt.Println("Content-Type:", contentType)

    if strings.Contains(contentType, "application/json") {
        var result []map[string]interface{}
        body, _ := io.ReadAll(resp5.Body)
        json.Unmarshal(body, &result)
        fmt.Printf("JSON数组长度: %d\n", len(result))
    }
}

8.12 context 包 —— 上下文管理

核心功能: 在goroutine之间传递请求范围的值、取消信号和超时控制。

主要函数

函数 签名 说明
Background func Background() Context 根Context(通常用于main函数)
TODO func TODO() Context 不确定用哪个Context时的占位符
WithCancel func WithCancel(parent Context) (ctx Context, cancel CancelFunc) 可取消的Context
WithDeadline func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) 截止时间的Context
WithTimeout func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) 超时时间的Context
WithValue func WithValue(parent Context, key, val any) Context 携带键值对的Context

Context 接口方法

方法 说明
Deadline() (deadline time.Time, ok bool) 返回截止时间
Done() <-chan struct{} 返回取消信号channel
Err() error 返回取消原因
Value(key any) any 返回关联的值
GO
package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // ========== WithCancel:手动取消 ==========
    ctx, cancel := context.WithCancel(context.Background())

    go func() {
        select {
        case <-ctx.Done():
            fmt.Println("goroutine 被取消:", ctx.Err())
        }
    }()

    time.Sleep(100 * time.Millisecond)
    cancel()  // 手动取消
    time.Sleep(50 * time.Millisecond)

    // ========== WithTimeout:超时取消 ==========
    ctx2, cancel2 := context.WithTimeout(context.Background(), 200*time.Millisecond)
    defer cancel2()  // 及时调用cancel释放资源

    select {
    case <-time.After(500 * time.Millisecond):
        fmt.Println("操作完成")
    case <-ctx2.Done():
        fmt.Println("超时:", ctx2.Err())
    }

    // ========== WithDeadline:截止时间 ==========
    deadline := time.Now().Add(300 * time.Millisecond)
    ctx3, cancel3 := context.WithDeadline(context.Background(), deadline)
    defer cancel3()

    select {
    case <-time.After(time.Second):
        fmt.Println("操作完成")
    case <-ctx3.Done():
        fmt.Println("到达截止时间:", ctx3.Err())
    }

    // ========== WithValue:传递数据 ==========
    type contextKey string

    ctx4 := context.WithValue(context.Background(), contextKey("userID"), 12345)
    ctx4 = context.WithValue(ctx4, contextKey("traceID"), "abc-def-123")

    processRequest(ctx4)

    // ========== Context 链式组合 ==========
    // 可以组合多个Context特性
    parentCtx := context.Background()
    valCtx := context.WithValue(parentCtx, contextKey("app"), "myapp")
    timeoutCtx, cancel5 := context.WithTimeout(valCtx, time.Second)
    defer cancel5()

    fmt.Println("链式Context值:", timeoutCtx.Value(contextKey("app")))
}

func processRequest(ctx context.Context) {
    userID := ctx.Value(contextKey("userID"))
    traceID := ctx.Value(contextKey("traceID"))
    fmt.Printf("处理请求: userID=%v, traceID=%v\n", userID, traceID)
}

// ========== Context 在HTTP中的应用模式 ==========
func handleRequest(ctx context.Context) {
    // 创建子Context,添加超时
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    // 将Context传递给下游操作
    resultCh := make(chan string, 1)
    go func() {
        // 模拟耗时操作
        time.Sleep(2 * time.Second)
        resultCh <- "操作结果"
    }()

    select {
    case result := <-resultCh:
        fmt.Println("成功:", result)
    case <-ctx.Done():
        fmt.Println("请求被取消或超时:", ctx.Err())
    }
}

8.13 log 包 —— 日志记录

核心功能: 提供简单的日志记录功能,包括日志级别设置、输出格式定制、输出目标设置等。

主要函数和类型

函数/类型 说明
log.Print(v ...any) 打印日志
log.Printf(format string, v ...any) 格式化打印日志
log.Println(v ...any) 打印日志并换行
log.Fatal(v ...any) 打印日志后调用 os.Exit(1)
log.Fatalf(format string, v ...any) 格式化Fatal
log.Panic(v ...any) 打印日志后调用 panic
log.Panicf(format string, v ...any) 格式化Panic
log.SetOutput(w io.Writer) 设置日志输出目标
log.SetFlags(flag int) 设置日志前缀标志
log.SetPrefix(prefix string) 设置日志前缀
log.New(out io.Writer, prefix string, flag int) *Logger 创建自定义Logger

日志标志(Flags)

常量 说明 示例输出
Ldate 日期 2024/06/15
Ltime 时间 14:30:00
Lmicroseconds 微秒 14:30:00.123456
Llongfile 完整文件路径和行号 /path/to/file.go:42
Lshortfile 文件名和行号 file.go:42
LUTC 使用UTC时间
LstdFlags 默认标志(Ldate Ltime)
GO
package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

func main() {
    // ========== 基本日志 ==========
    log.Print("这是一条普通日志")
    log.Printf("格式化日志: 用户=%s, 操作=%s", "张三", "登录")
    log.Println("带换行的日志")

    // ========== 设置日志标志 ==========
    log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
    log.Println("设置了日期+时间+短文件名标志")

    // 设置前缀
    log.SetPrefix("[MyApp] ")
    log.Println("带前缀的日志")

    // ========== 自定义Logger ==========
    // 写入到文件
    f, _ := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    defer f.Close()

    logger := log.New(f, "[INFO] ", log.Ldate|log.Ltime|log.Lshortfile)
    logger.Println("写入到文件的日志")

    // 同时输出到文件和标准输出
    multiWriter := io.MultiWriter(os.Stdout, f)
    multiLogger := log.New(multiWriter, "[APP] ", log.LstdFlags)
    multiLogger.Println("同时输出到控制台和文件")

    // ========== 不同级别的Logger ==========
    infoLogger := log.New(os.Stdout, "[INFO]  ", log.LstdFlags)
    warnLogger := log.New(os.Stdout, "[WARN]  ", log.LstdFlags)
    errLogger := log.New(os.Stderr, "[ERROR] ", log.LstdFlags|log.Lshortfile)

    infoLogger.Println("应用启动成功")
    warnLogger.Println("磁盘使用率达到80%")
    errLogger.Println("数据库连接失败")

    // ========== Fatal:打印后退出 ==========
    // log.Fatal("严重错误,程序退出")  // 会调用 os.Exit(1)
    // log.Fatalf("配置错误: %s", "缺少必需参数")

    // ========== Panic:打印后panic ==========
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到log.Panic:", r)
        }
    }()
    log.Panicln("Panic错误信息")
}

8.14 sort 包 —— 排序

核心功能: 提供切片排序和搜索功能。

排序函数

函数 说明
sort.Ints(x []int) 对int切片排序
sort.Float64s(x []float64) 对float64切片排序
sort.Strings(x []string) 对string切片排序
sort.IntsAreSorted(x []int) bool 检查int切片是否已排序
sort.Sort(data Interface) 对自定义类型排序
sort.Stable(data Interface) 稳定排序
sort.Slice(x any, less func(i, j int) bool) 对任意切片排序
sort.SliceStable(x any, less func(i, j int) bool) 稳定排序任意切片
sort.Reverse(data Interface) Interface 反转排序顺序
sort.Search(n int, f func(int) bool) int 二分搜索
sort.SearchInts(a []int, x int) int 在int切片中搜索
sort.SearchFloat64s(a []float64, x float64) int 在float64切片中搜索
sort.SearchStrings(a []string, x string) int 在string切片中搜索

sort.Interface 接口

GO
type Interface interface {
    Len() int           // 元素数量
    Less(i, j int) bool // i位置的元素是否小于j位置的元素
    Swap(i, j int)      // 交换i和j位置的元素
}
GO
package main

import (
    "fmt"
    "sort"
)

func main() {
    // ========== 基本类型排序 ==========
    ints := []int{64, 2, 128, 32, 16, 8, 4}
    sort.Ints(ints)
    fmt.Println("排序后:", ints)

    strings := []string{"banana", "apple", "cherry", "date"}
    sort.Strings(strings)
    fmt.Println("排序后:", strings)

    // ========== 降序排序 ==========
    sort.Sort(sort.Reverse(sort.IntSlice(ints)))
    fmt.Println("降序:", ints)

    // ========== sort.Slice:灵活排序 ==========
    people := []struct {
        Name string
        Age  int
    }{
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35},
        {"David", 20},
    }

    // 按年龄排序
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })
    fmt.Println("按年龄排序:", people)

    // 按名字排序
    sort.Slice(people, func(i, j int) bool {
        return people[i].Name < people[j].Name
    })
    fmt.Println("按名字排序:", people)

    // ========== 自定义类型排序(实现sort.Interface)==========
    type Book struct {
        Title  string
        Author string
        Pages  int
    }

    type ByPages []Book

    func (b ByPages) Len() int           { return len(b) }
    func (b ByPages) Less(i, j int) bool { return b[i].Pages < b[j].Pages }
    func (b ByPages) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }

    books := []Book{
        {"Go入门", "张三", 300},
        {"Python教程", "李四", 450},
        {"Java编程", "王五", 200},
    }

    sort.Sort(ByPages(books))
    fmt.Println("按页数排序:", books)

    // ========== 二分搜索 ==========
    sortedInts := []int{1, 3, 5, 7, 9, 11, 13}
    index := sort.SearchInts(sortedInts, 7)
    fmt.Printf("7在索引%d的位置(已找到: %v)\n", index, sortedInts[index] == 7)

    // 搜索不存在的元素会返回应该插入的位置
    index2 := sort.SearchInts(sortedInts, 6)
    fmt.Printf("6应该插入在索引%d的位置\n", index2)

    // ========== 自定义二分搜索 ==========
    // 找到第一个 >= 10 的位置
    index3 := sort.Search(len(sortedInts), func(i int) bool {
        return sortedInts[i] >= 10
    })
    fmt.Printf("第一个>=10的值在索引%d: %d\n", index3, sortedInts[index3])

    // ========== 检查是否已排序 ==========
    fmt.Println("ints已排序:", sort.IntsAreSorted(ints))
    fmt.Println("strings已排序:", sort.StringsAreSorted(strings))
}

8.15 math 包 —— 数学函数

核心功能: 提供基本的数学常量和函数。

数学常量

GO
math.E          // e = 2.718281828459045
math.Pi         // π = 3.141592653589793
math.Phi        // φ = 1.618033988749895
math.Sqrt2      // √2 = 1.4142135623730951
math.SqrtE      // √e = 1.6487212707001282
math.SqrtPi     // √π = 1.7724538509055160
math.Ln2        // ln2 = 0.6931471805599453
math.Log2E      // log₂e = 1.4426950408889634
math.Ln10       // ln10 = 2.302585092994046
math.MaxFloat64 // 最大float64值
math.SmallestNonzeroFloat64 // 最小正float64值

常用函数

函数 说明 函数 说明
Abs(x) 绝对值 Ceil(x) 向上取整
Floor(x) 向下取整 Round(x) 四舍五入
Trunc(x) 截断小数 Mod(x, y) 取模
Pow(x, y) x的y次方 Sqrt(x) 平方根
Cbrt(x) 立方根 Exp(x) e的x次方
Log(x) 自然对数 Log10(x) 10为底对数
Log2(x) 2为底对数 Hypot(x, y) sqrt(x²+y²)
Sin(x) 正弦 Cos(x) 余弦
Tan(x) 正切 Asin(x) 反正弦
Max(x, y) 最大值 Min(x, y) 最小值
Dim(x, y) max(x-y, 0) Inf(sign) 无穷大
NaN() 非数字 IsNaN(x) 判断NaN
IsInf(x, sign) 判断无穷 Signbit(x) 判断负号
FMA(x, y, z) x*y+z(精确) Erf(x) 误差函数
GO
package main

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

func main() {
    // ========== 基本计算 ==========
    fmt.Printf("Abs(-3.14): %.2f\n", math.Abs(-3.14))
    fmt.Printf("Ceil(3.14): %.0f, Floor(3.14): %.0f\n", math.Ceil(3.14), math.Floor(3.14))
    fmt.Printf("Round(3.5): %.0f, Trunc(3.9): %.0f\n", math.Round(3.5), math.Trunc(3.9))
    fmt.Printf("Mod(10, 3): %.0f\n", math.Mod(10, 3))
    fmt.Printf("Pow(2, 10): %.0f\n", math.Pow(2, 10))
    fmt.Printf("Sqrt(16): %.0f\n", math.Sqrt(16))

    // ========== 三角函数 ==========
    angle := math.Pi / 4  // 45度
    fmt.Printf("Sin(45°): %.4f\n", math.Sin(angle))
    fmt.Printf("Cos(45°): %.4f\n", math.Cos(angle))
    fmt.Printf("Tan(45°): %.4f\n", math.Tan(angle))

    // ========== 极限值 ==========
    fmt.Printf("Max(10, 20): %v\n", math.Max(10, 20))
    fmt.Printf("Min(10, 20): %v\n", math.Min(10, 20))
    fmt.Println("NaN:", math.NaN())
    fmt.Println("IsNaN(NaN):", math.IsNaN(math.NaN()))
    fmt.Println("Inf(1):", math.Inf(1))

    // ========== math/rand:随机数 ==========
    // Go 1.20+: 不再需要手动Seeding
    fmt.Println("随机整数:", rand.Intn(100))        // 0-99
    fmt.Println("随机浮点数:", rand.Float64())      // 0.0-1.0
    fmt.Println("随机Int31:", rand.Int31())

    // 创建独立的随机数生成器
    src := rand.NewSource(42)  // 固定种子用于可重复的随机序列
    rng := rand.New(src)
    fmt.Println("种子随机:", rng.Intn(100), rng.Intn(100))

    // 生成随机字节
    buf := make([]byte, 4)
    rand.Read(buf)
    fmt.Printf("随机字节: %x\n", buf)

    // Shuffle:随机打乱
    items := []int{1, 2, 3, 4, 5}
    rand.Shuffle(len(items), func(i, j int) {
        items[i], items[j] = items[j], items[i]
    })
    fmt.Println("打乱后:", items)
}

8.16 crypto 包 —— 加密

核心功能: 提供常用加密算法的实现,包括哈希、对称加密、非对称加密等。

主要子包

子包 功能
crypto/md5 MD5哈希(不安全,仅用于兼容)
crypto/sha1 SHA1哈希
crypto/sha256 SHA256哈希
crypto/sha512 SHA512哈希
crypto/hmac HMAC消息认证
crypto/aes AES对称加密
crypto/rand 加密安全的随机数生成器
crypto/rsa RSA非对称加密
crypto/ecdsa ECDSA椭圆曲线数字签名
crypto/ed25519 Ed25519签名
crypto/tls TLS/SSL协议实现
crypto/x509 X.509证书解析
GO
package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/hmac"
    "crypto/md5"
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
)

func main() {
    // ========== MD5 哈希 ==========
    data := "Hello, Go!"
    md5Hash := md5.Sum([]byte(data))
    fmt.Printf("MD5: %x\n", md5Hash)

    // ========== SHA256 哈希 ==========
    sha256Hash := sha256.Sum256([]byte(data))
    fmt.Printf("SHA256: %x\n", sha256Hash)

    // 使用hash.Hash接口流式处理
    h := sha256.New()
    h.Write([]byte("Hello, "))
    h.Write([]byte("Go!"))
    fmt.Printf("SHA256(流式): %x\n", h.Sum(nil))

    // ========== HMAC 消息认证 ==========
    secret := []byte("my-secret-key")
    mac := hmac.New(sha256.New, secret)
    mac.Write([]byte(data))
    expectedMAC := mac.Sum(nil)
    fmt.Printf("HMAC-SHA256: %x\n", expectedMAC)

    // 验证HMAC
    mac2 := hmac.New(sha256.New, secret)
    mac2.Write([]byte(data))
    if hmac.Equal(expectedMAC, mac2.Sum(nil)) {
        fmt.Println("HMAC验证成功")
    }

    // ========== 加密安全随机数 ==========
    randomBytes := make([]byte, 16)
    _, err := io.ReadFull(rand.Reader, randomBytes)
    if err == nil {
        fmt.Printf("安全随机字节: %x\n", randomBytes)
    }

    // 生成随机整数(0-99)
    var n [1]byte
    rand.Read(n[:])
    fmt.Printf("安全随机数: %d\n", int(n[0])%100)

    // ========== AES 加密 ==========
    // 32字节密钥 = AES-256
    key := sha256.Sum256([]byte("my-secret-password"))

    plaintext := []byte("这是一段需要加密的敏感数据")

    // 加密
    ciphertext, err := aesEncrypt(plaintext, key[:])
    if err != nil {
        fmt.Println("加密失败:", err)
        return
    }
    fmt.Printf("密文: %x\n", ciphertext)

    // 解密
    decrypted, err := aesDecrypt(ciphertext, key[:])
    if err != nil {
        fmt.Println("解密失败:", err)
        return
    }
    fmt.Printf("解密: %s\n", decrypted)

    // ========== 字符串哈希的十六进制表示 ==========
    str := "password123"
    hash := sha256Hex(str)
    fmt.Printf("SHA256(%s) = %s\n", str, hash)
}

func aesEncrypt(plaintext, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    // GCM模式(推荐,提供认证加密)
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    // 随机Nonce
    nonce := make([]byte, gcm.NonceSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }

    // 加密并认证
    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
    return ciphertext, nil
}

func aesDecrypt(ciphertext, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    nonceSize := gcm.NonceSize()
    if len(ciphertext) < nonceSize {
        return nil, fmt.Errorf("密文太短")
    }

    nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
    plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
    if err != nil {
        return nil, err
    }

    return plaintext, nil
}

func sha256Hex(s string) string {
    hash := sha256.Sum256([]byte(s))
    return hex.EncodeToString(hash[:])
}

8.17 reflect 包 —— 反射

核心功能: 运行时类型检查和操作,允许程序检查、修改自身的结构和行为。

主要类型

类型 说明
Type 表示Go类型的接口
Value 表示Go值的结构体
Kind 类型的种类(如Int、String、Struct等)
StructField 结构体字段信息
StructTag 结构体标签

常用函数

函数 说明
reflect.TypeOf(i any) Type 获取值的类型
reflect.ValueOf(i any) Value 获取值的反射Value
reflect.New(typ Type) Value 创建类型的新指针
reflect.DeepEqual(a, b any) bool 深度比较

Value 方法

方法 说明
Kind() Kind 返回类型的种类
Type() Type 返回类型
Interface() interface{} 还原为interface{}
Int() int64 返回值(int类型)
Float() float64 返回值(float类型)
String() string 返回值(string类型)
Bool() bool 返回值(bool类型)
NumField() int 结构体字段数
Field(i int) Value 获取第i个字段
FieldByName(name string) Value 按名称获取字段
NumMethod() int 方法数
Method(i int) Value 获取第i个方法
MethodByName(name string) Value 按名称获取方法
Call(in []Value) []Value 调用方法
CanSet() bool 是否可设置
SetInt(x int64) 设置int值
SetString(s string) 设置string值
Elem() Value 指针指向的值
IsNil() bool 是否为nil
IsValid() bool 是否有效
IsZero() bool 是否为零值
GO
package main

import (
    "fmt"
    "reflect"
)

type User struct {
    ID    int    `json:"id" validate:"required"`
    Name  string `json:"name" validate:"required,min=2,max=50"`
    Email string `json:"email,omitempty"`
    age   int    // 私有字段
}

func (u User) Greet() string {
    return "Hello, " + u.Name
}

func (u *User) SetName(name string) {
    u.Name = name
}

func main() {
    u := User{ID: 1, Name: "张三", Email: "zhangsan@example.com", age: 30}

    // ========== 获取类型和值 ==========
    t := reflect.TypeOf(u)
    v := reflect.ValueOf(u)

    fmt.Println("类型:", t)
    fmt.Println("类型名称:", t.Name())
    fmt.Println("类型种类:", t.Kind())
    fmt.Println("值:", v)

    // ========== 遍历结构体字段 ==========
    fmt.Println("\n遍历结构体字段:")
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)

        fmt.Printf("  字段%d: %s", i+1, field.Name)
        fmt.Printf("  类型: %s", field.Type)
        fmt.Printf("  值: %v", value.Interface())
        fmt.Printf("  标签: %s", field.Tag)
        fmt.Printf("  是否导出: %v", field.IsExported())
        fmt.Println()

        // 解析特定标签
        if jsonTag := field.Tag.Get("json"); jsonTag != "" {
            fmt.Printf("    json标签: %s\n", jsonTag)
        }
        if validateTag := field.Tag.Get("validate"); validateTag != "" {
            fmt.Printf("    validate标签: %s\n", validateTag)
        }
    }

    // ========== 遍历方法 ==========
    fmt.Println("\n遍历方法:")
    for i := 0; i < t.NumMethod(); i++ {
        method := t.Method(i)
        fmt.Printf("  方法%d: %s, 类型: %s\n", i+1, method.Name, method.Type)
    }

    // ========== 通过反射修改值 ==========
    // 需要通过指针
    uPtr := &User{Name: "李四"}
    v2 := reflect.ValueOf(uPtr).Elem()  // 获取指针指向的值

    if nameField := v2.FieldByName("Name"); nameField.IsValid() && nameField.CanSet() {
        nameField.SetString("王五")
    }
    fmt.Println("修改后:", uPtr.Name)

    // ========== 通过反射调用方法 ==========
    // 值接收者方法
    method := v.MethodByName("Greet")
    if method.IsValid() {
        results := method.Call(nil)
        fmt.Println("调用Greet:", results[0].String())
    }

    // 指针接收者方法
    method2 := reflect.ValueOf(uPtr).MethodByName("SetName")
    if method2.IsValid() {
        method2.Call([]reflect.Value{reflect.ValueOf("赵六")})
        fmt.Println("SetName后:", uPtr.Name)
    }

    // ========== Kind 判断 ==========
    func inspectKind(x interface{}) {
        switch reflect.TypeOf(x).Kind() {
        case reflect.Int, reflect.Int64:
            fmt.Println("整数类型")
        case reflect.String:
            fmt.Println("字符串类型")
        case reflect.Slice:
            fmt.Println("切片类型")
        case reflect.Struct:
            fmt.Println("结构体类型")
        case reflect.Ptr:
            fmt.Println("指针类型")
        default:
            fmt.Println("其他类型")
        }
    }

    inspectKind(42)
    inspectKind("hello")
    inspectKind([]int{1, 2, 3})
    inspectKind(User{})

    // ========== 动态创建对象 ==========
    // 从类型创建新实例
    newStruct := reflect.New(t).Elem()
    newStruct.FieldByName("Name").SetString("反射创建")
    newStruct.FieldByName("ID").SetInt(100)
    newUser := newStruct.Interface().(User)
    fmt.Printf("动态创建的用户: %+v\n", newUser)

    // ========== 判断是否实现接口 ==========
    type Greeter interface {
        Greet() string
    }
    greeterType := reflect.TypeOf((*Greeter)(nil)).Elem()
    fmt.Printf("User 是否实现了 Greeter: %v\n", t.Implements(greeterType))
}

九、测试与性能分析

9.1 单元测试

Go语言内置了轻量级的测试框架。

测试文件规范

  • 测试文件以 _test.go 结尾
  • 测试函数以 Test 开头,接收 *testing.T 参数
  • 示例函数以 Example 开头
  • 基准测试以 Benchmark 开头,接收 *testing.B 参数
GO
// calculator.go
package calculator

func Add(a, b int) int {
    return a + b
}

func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}
GO
// calculator_test.go
package calculator

import (
    "testing"
)

// ========== 表驱动测试(Table-Driven Tests)==========
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"正数相加", 2, 3, 5},
        {"负数相加", -1, -1, -2},
        {"正负数相加", -1, 1, 0},
        {"零相加", 0, 0, 0},
        {"大数相加", 1000000, 2000000, 3000000},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d, 期望 %d",
                    tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

func TestDivide(t *testing.T) {
    t.Run("正常除法", func(t *testing.T) {
        result, err := Divide(10, 2)
        if err != nil {
            t.Fatalf("不应出错: %v", err)
        }
        if result != 5.0 {
            t.Errorf("期望 5.0, 得到 %f", result)
        }
    })

    t.Run("除零", func(t *testing.T) {
        _, err := Divide(10, 0)
        if err == nil {
            t.Error("除零应该返回错误")
        }
    })
}

// ========== 子测试(Subtests)==========
func TestMath(t *testing.T) {
    t.Run("Add", func(t *testing.T) {
        if Add(1, 1) != 2 {
            t.Fatal("1+1 != 2")
        }
    })
}

// ========== 辅助函数(Helper)==========
func assertEqual(t *testing.T, got, want int) {
    t.Helper()  // 标记为辅助函数
    if got != want {
        t.Errorf("得到 %d, 期望 %d", got, want)
    }
}

func TestAddWithHelper(t *testing.T) {
    assertEqual(t, Add(2, 3), 5)
    assertEqual(t, Add(-1, 1), 0)
}

// ========== TestMain:测试入口 ==========
func TestMain(m *testing.M) {
    // 测试前初始化
    // setup()

    code := m.Run()  // 运行所有测试

    // 测试后清理
    // teardown()

    // os.Exit(code) // TestMain中不需要显式调用
}

9.2 基准测试(Benchmark)

GO
// calculator_bench_test.go
package calculator

import "testing"

func BenchmarkAdd(b *testing.B) {
    // b.N 由测试框架自动调整(目标运行至少1秒)
    for i := 0; i < b.N; i++ {
        Add(100, 200)
    }
}

func BenchmarkAddLarge(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(99999999, 88888888)
    }
}

// 重置计时器(跳过初始化时间)
func BenchmarkComplexOperation(b *testing.B) {
    // 昂贵的初始化操作
    data := make([]int, 10000)
    for i := range data {
        data[i] = i
    }

    b.ResetTimer()  // 重置计时器
    for i := 0; i < b.N; i++ {
        // 实际要测试的操作
        _ = Add(data[0], data[9999])
    }
}

运行测试和基准测试:

BASH
# 运行当前包所有测试
go test

# 详细输出
go test -v

# 显示测试覆盖率
go test -cover
go test -coverprofile=coverage.out
go tool cover -html=coverage.out   # 浏览器查看覆盖率

# 运行指定测试
go test -run TestAdd
go test -run TestAdd/正数相加

# 运行基准测试
go test -bench=.
go test -bench=Add
go test -bench=. -benchmem            # 显示内存分配
go test -bench=. -benchtime=5s        # 运行5秒
go test -bench=. -count=3             # 运行3次

# 并行测试
go test -parallel 4

# 输出JSON格式
go test -json

9.3 示例函数(Example)

GO
package calculator

import "fmt"

func ExampleAdd() {
    result := Add(2, 3)
    fmt.Println(result)
    // Output: 5
}

func ExampleAdd_negative() {
    result := Add(-1, -2)
    fmt.Println(result)
    // Output: -3
}

9.4 Fuzzing 模糊测试(Go 1.18+)

GO
package calculator

import "testing"

func FuzzAdd(f *testing.F) {
    // 种子数据
    f.Add(1, 2)
    f.Add(0, 0)
    f.Add(-1, 1)

    f.Fuzz(func(t *testing.T, a, b int) {
        result := Add(a, b)
        // 验证基本一致性
        if result != a+b {
            t.Errorf("Add(%d, %d) = %d, 期望 %d", a, b, result, a+b)
        }
    })
}
BASH
go test -fuzz=FuzzAdd -fuzztime=30s

十、项目实战与最佳实践

10.1 项目组织与分层架构

CODE
myproject/
├── cmd/
│   └── server/
│       └── main.go          # 程序入口
├── internal/
│   ├── handler/             # HTTP处理器层
│   │   └── user_handler.go
│   ├── service/             # 业务逻辑层
│   │   └── user_service.go
│   ├── repository/          # 数据访问层
│   │   └── user_repo.go
│   ├── model/               # 数据模型
│   │   └── user.go
│   └── config/              # 配置管理
│       └── config.go
├── pkg/                     # 可复用的公共库
│   └── middleware/
│       └── auth.go
├── api/                     # API定义
│   └── openapi.yaml
├── configs/                 # 配置文件
│   └── config.yaml
├── scripts/                 # 脚本
├── migrations/              # 数据库迁移
├── Dockerfile
├── docker-compose.yaml
├── Makefile
├── go.mod
└── go.sum

10.2 代码规范

GO
// ========== 命名规范 ==========
// 包名:小写,简洁,无下划线
package userservice

// 接口名:以 er 结尾(单方法接口)
type Reader interface {
    Read(p []byte) (n int, err error)
}

// 变量:驼峰式
var maxRetryCount = 3
var userID int64

// 常量:全大写(或驼峰式)
const DefaultTimeout = 30 * time.Second

// 错误变量:Err 开头
var ErrNotFound = errors.New("资源未找到")
var ErrTimeout = errors.New("操作超时")

// ========== 错误处理模式 ==========
// 1. 处理错误,不要忽略
result, err := someOperation()
if err != nil {
    return fmt.Errorf("操作失败: %w", err)
}

// 2. 使用 defer 确保资源释放
f, err := os.Open("file.txt")
if err != nil {
    return err
}
defer f.Close()

// 3. 使用 Sentinel Error 进行错误判断
if errors.Is(err, ErrNotFound) {
    // 处理未找到的情况
}

// ========== 函数设计原则 ==========
// 1. 接受接口,返回结构体
func NewReader(filename string) (*os.File, error) {
    return os.Open(filename)
}

// 2. 函数保持简短(不超过50行)
// 3. 单一职责
// 4. 避免过深的嵌套(早期返回)
func process(data []byte) ([]byte, error) {
    if len(data) == 0 {
        return nil, errors.New("空数据")
    }
    // 主逻辑
    return data, nil
}

// ========== Context 传递 ==========
func ProcessUser(ctx context.Context, userID int64) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        // 继续处理
    }
    return nil
}

// ========== 避免全局变量 ==========
// 使用依赖注入
type Service struct {
    repo   Repository
    config *Config
}

func NewService(repo Repository, config *Config) *Service {
    return &Service{repo: repo, config: config}
}

10.3 性能优化要点

GO
// 1. 预分配切片容量(减少扩容)
s := make([]int, 0, 1000)

// 2. 使用 strings.Builder 代替 + 拼接
var builder strings.Builder
for i := 0; i < 1000; i++ {
    builder.WriteString("hello")
}
result := builder.String()

// 3. 使用 sync.Pool 复用对象
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}

// 4. 避免不必要的内存分配
// 使用指针接收者,大结构体传指针
func (u *User) Process() {}

// 5. 使用 I/O 缓冲
writer := bufio.NewWriter(file)
reader := bufio.NewReader(file)

// 6. 并发控制:限制 goroutine 数量
sem := make(chan struct{}, 10)  // 最多10个并发
for _, item := range items {
    sem <- struct{}{}
    go func(item Item) {
        defer func() { <-sem }()
        process(item)
    }(item)
}

// 7. 使用 pprof 进行性能分析
// import _ "net/http/pprof"
// http.ListenAndServe(":6060", nil)
// go tool pprof http://localhost:6060/debug/pprof/heap
// go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

10.4 常见陷阱与注意事项

陷阱 说明 正确做法
nil 接口判断 接口值为(type=nil, value=nil) != nil 确保返回具体nil而非接口nil
切片共享底层数组 截取切片共享底层数据 使用copy或full slice expression
for range 变量捕获 旧版本(Go<1.22)循环变量复用 使用局部变量或传参
map 并发读写 非并发安全的map并发操作会panic 使用sync.Mutex或sync.Map
defer 参数求值 defer语句的参数在声明时求值 使用闭包延迟求值
goroutine 泄漏 未正确退出的goroutine 使用context或channel通知退出
时间比较 使用 == 比较Time值 使用t.Equal(other)
GO
// ========== 常见陷阱示例和修复 ==========

// 1. for range 中的goroutine变量捕获(Go<1.22)
// 错误:
for _, v := range []int{1, 2, 3} {
    go func() {
        fmt.Println(v)  // 可能全部打印3
    }()
}

// 正确:
for _, v := range []int{1, 2, 3} {
    v := v  // 创建局部变量
    go func() {
        fmt.Println(v)
    }()
}

// 2. nil 接口陷阱
// 错误:
func getError() error {
    var err *MyError = nil
    return err  // 返回的error不为nil!
}

// 正确:
func getError() error {
    return nil  // 直接返回 nil
}

// 3. 切片截取陷阱
base := []int{1, 2, 3, 4, 5}
sub := base[1:3]       // [2,3]
sub = append(sub, 99)  // 修改了base[3]!
fmt.Println(base)      // [1,2,3,99,5]

// 正确:使用全切片表达式限制容量
sub2 := base[1:3:3]    // 容量=3-1=2
sub2 = append(sub2, 99) // 触发扩容,不再影响base

十一、工具与命令参考

11.1 go 常用命令

BASH
# 构建与运行
go build                    # 编译当前包
go build -o output main.go  # 指定输出文件名
go run main.go              # 编译并运行
go install                  # 编译并安装到$GOPATH/bin

# 依赖管理
go mod init module-name     # 初始化模块
go mod tidy                 # 整理依赖
go mod download             # 下载依赖
go mod verify               # 验证依赖
go mod vendor               # 创建vendor目录

# 测试
go test ./...               # 测试所有包
go test -v                  # 详细输出
go test -cover              # 覆盖率
go test -bench=.            # 基准测试
go test -race               # 竞态检测

# 代码分析
go vet ./...                # 静态分析
go fmt ./...                # 格式化代码
go mod tidy                 # 整理模块
golint ./...                # 代码规范检查

# 工具
go version                  # 版本
go env                      # 环境变量
go doc fmt.Println          # 查看文档
go doc -http=:6060          # 启动文档服务器

十二、总结

12.1 Go语言核心优势

优势 说明
并发原生 Goroutine轻量且高效,Channel通信简洁安全
编译快速 大型项目编译仅需数秒
部署简单 编译为单个二进制文件,无运行时依赖
静态类型 编译时发现错误,代码可维护性高
垃圾回收 自动内存管理,极低STW时间
标准库丰富 覆盖网络、加密、测试等常用场景

12.2 学习路径

CODE
基础语法 → 复合类型 → 方法接口 → 并发编程 → 标准库 → 项目实践
    ↓          ↓          ↓           ↓          ↓          ↓
 变量控制   数组切片    嵌入泛型   Goroutine   fmt/os    Web服务
 函数defer  Map映射    接口多态   Channel     net/http   CLI工具
 包管理    结构体      类型断言   Select      加密       微服务
 错误处理              组合继承   同步原语    time       API开发

12.3 推荐学习资源

12.4 本书涵盖的标准库总览

包名 核心功能
fmt 格式化输入输出
os 操作系统接口、文件I/O
io 基础I/O接口
bufio 缓冲I/O
path/filepath 文件路径操作
strings 字符串操作
strconv 字符串类型转换
bytes 字节切片操作
encoding/json JSON编解码
time 时间处理
net/http HTTP客户端/服务器
sync 同步原语(锁、WaitGroup等)
sync/atomic 原子操作
context 上下文管理
log 日志记录
errors 错误处理工具
sort 排序和搜索
math 数学函数
math/rand 随机数
crypto 加密算法
reflect 反射机制
testing 测试框架
net 网络编程基础
flag 命令行参数解析
embed 嵌入静态文件(Go 1.16+)
database/sql 数据库操作
encoding/xml XML编解码
encoding/base64 Base64编解码
regexp 正则表达式
runtime 运行时信息
runtime/pprof 性能分析
text/template 文本模板
html/template HTML安全模板

祝你通过本书掌握Golang语言,成为一名优秀的Go开发者!