Go 概述与环境配置

1. Go 语言概述

Go（又称 Golang）是由 Google 的 Robert Griesemer、Rob Pike 和 Ken Thompson 于 2007 年开始设计，2012 年发布 1.0 版本的静态类型、编译型编程语言。Go 的诞生源于对 C++ 复杂性的反思以及对大规模系统开发效率的追求。

1.1 核心特点

1.2 设计哲学

Go 的设计哲学可以概括为以下几条原则：

• 少即是多：通过减少特性来降低复杂度，没有类、继承、异常、泛型（直到 1.18）
• 组合优于继承：通过嵌入（embedding）和接口组合实现代码复用
• 显式优于隐式：错误处理显式返回，类型转换必须显式
• 约定优于配置：go fmt 统一格式，项目结构约定（如 cmd/、pkg/、internal/）
• 内置电池：标准库功能丰富，HTTP 服务器、JSON 编解码、加密等开箱即用

1.3 Go 适用场景

• 云原生基础设施（Docker、Kubernetes、etcd、Terraform）
• 微服务与 API 服务
• 网络编程与代理（Caddy、Traefik）
• 命令行工具（Hugo、gh）
• 数据库（CockroachDB、InfluxDB、TiDB）
• DevOps 工具链

2. 发展历史与版本演进

2.1 里程碑版本

2.2 Go 1.22+ 重要新特性

Go 1.22 — for-range 整数：

// 之前需要写 for i := 0; i < 10; i++
// 现在可以直接：
for i := range 10 {
    fmt.Println(i) // 0, 1, 2, ..., 9
}

Go 1.22 — 增强的 HTTP 路由：

mux := http.NewServeMux()
mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
    fmt.Fprintf(w, "User: %s", id)
})
mux.HandleFunc("POST /users", createUser)

Go 1.23 — 迭代器（iter 包）：

// 自定义迭代器函数
func Backward[E any](s []E) iter.Seq2[int, E] {
    return func(yield func(int, E) bool) {
        for i := len(s) - 1; i >= 0; i-- {
            if !yield(i, s[i]) {
                return
            }
        }
    }
}

// 使用
for i, v := range Backward([]string{"a", "b", "c"}) {
    fmt.Println(i, v)
}

Go 1.24 — 泛型类型别名：

type Set[T comparable] = map[T]struct{}

var s Set[string] = make(Set[string])
s["hello"] = struct{}{}

3. 环境搭建

3.1 安装 Go

官方安装包：访问 https://go.dev/dl/ 下载对应平台安装包。

Linux 安装：

# 下载并安装
wget https://go.dev/dl/go1.24.3.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz

# 配置环境变量
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
echo 'export PATH=$PATH:$(go env GOPATH)/bin' >> ~/.bashrc
source ~/.bashrc

macOS 安装：

brew install go

Windows 安装：下载 .msi 安装包，按向导安装即可。

3.2 环境变量

# 查看当前配置
go env

# 关键环境变量
# GOROOT    — Go 安装路径（通常自动检测）
# GOPATH    — Go 工作空间路径（默认 $HOME/go）
# GOBIN     — 可执行文件安装路径
# GOPROXY   — 模块代理（国内推荐设置）
# GOMODCACHE — 模块缓存路径
# GOOS/GOARCH — 交叉编译目标

# 国内加速
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GONOSUMCHECK=*.corp.example.com

3.3 编辑器与 IDE

3.4 验证安装

go version
# 输出: go version go1.24.3 linux/amd64

go env GOPATH
# 输出: /home/user/go

4. Go Modules 模块系统

Go Modules 是 Go 1.11 引入、1.16 成为默认的依赖管理系统，通过 go.mod 文件声明模块路径和依赖。

4.1 创建模块

mkdir myproject && cd myproject
go mod init github.com/username/myproject
# 生成 go.mod 文件

go.mod 文件结构：

module github.com/username/myproject

go 1.24

require (
    github.com/gin-gonic/gin v1.10.0
    golang.org/x/text v0.21.0
)

require github.com/json-iterator/go v1.1.12 // indirect

4.2 常用模块命令

go mod init <module-path>   # 初始化模块
go mod tidy                  # 整理依赖（添加缺失、移除未使用）
go mod download              # 下载依赖到缓存
go mod vendor                # 将依赖复制到 vendor 目录
go mod graph                 # 查看依赖图
go mod verify                # 验证依赖完整性
go mod why <package>         # 解释为什么需要某个依赖

4.3 添加与更新依赖

# 添加依赖
go get github.com/gin-gonic/gin@latest
go get github.com/gin-gonic/gin@v1.10.0

# 更新依赖
go get -u github.com/gin-gonic/gin     # 更新到最新 minor/patch
go get -u=patch github.com/gin-gonic/gin  # 仅更新 patch

# 移除未使用依赖
go mod tidy

4.4 工作区模式（Workspace）

Go 1.18 引入工作区模式，支持多模块本地开发：

# 创建工作区
go work init ./module1 ./module2

# 生成 go.work 文件

go.work 文件：

go 1.24

use (
    ./module1
    ./module2
)

replace github.com/old/pkg => ./local/pkg

4.5 版本选择机制

Go 使用**最小版本选择（MVS）**算法：选择满足所有依赖约束的最小版本，而非最新版本。这确保了构建的可重复性。

A 依赖 B >= 1.2.0
A 依赖 C >= 1.0.0
C 依赖 B >= 1.1.0

→ MVS 选择 B v1.2.0（满足所有约束的最小版本）

5. Hello World

5.1 第一个 Go 程序

// main.go
package main

import "fmt"

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

5.2 运行与构建

# 直接运行
go run main.go

# 编译构建
go build -o hello main.go
./hello

# 安装到 GOPATH/bin
go install

5.3 项目结构

Go 项目推荐的标准布局：

myproject/
├── cmd/                # 可执行程序入口
│   └── server/
│       └── main.go
├── internal/           # 私有代码（不可被外部导入）
│   └── service/
│       └── user.go
├── pkg/                # 可被外部导入的公共库
│   └── utils/
│       └── helper.go
├── api/                # API 定义（protobuf、OpenAPI）
├── configs/            # 配置文件
├── go.mod
├── go.sum
└── Makefile

5.4 包（Package）基础

// 每个 Go 文件必须属于一个包
package math

// 大写开头 = 导出（public）
func Add(a, b int) int {
    return a + b
}

// 小写开头 = 未导出（private）
func subtract(a, b int) int {
    return a - b
}

// 导入并使用
package main

import (
    "fmt"
    "github.com/username/myproject/pkg/math"
)

func main() {
    fmt.Println(math.Add(1, 2))  // 3
    // math.subtract(1, 2)       // 编译错误：未导出
}

6. Go 程序执行流程

源码(.go) → go build → 可执行文件 → 运行
                ↓
        词法分析 → 语法分析 → 类型检查 → SSA → 机器码

程序启动顺序：

1. 导入所有依赖包（递归）
2. 执行各包的 init() 函数（按导入顺序）
3. 执行 main 包的 init() 函数
4. 执行 main() 函数

package main

import "fmt"

var name = initName()

func initName() string {
    fmt.Println("初始化 name 变量")
    return "Go"
}

func init() {
    fmt.Println("init 函数执行")
}

func main() {
    fmt.Println("main 函数执行")
    fmt.Println("name =", name)
}
// 输出顺序：
// 初始化 name 变量
// init 函数执行
// main 函数执行
// name = Go