Blog | ahKevinXy

特性	Go Module	Go Work
核心目标	管理单个项目的依赖	管理多个模块的本地开发协作
核心文件	`go.mod` + `go.sum`	`go.work`（引用多个 `go.mod`）
适用场景	单项目开发、生产环境依赖管理	多模块本地开发（如微服务、库依赖）
依赖来源	优先从远端（proxy）拉取	优先使用本地模块代码
生产环境是否生效	是（核心依赖管理）	否（仅本地开发用，不会提交到仓库）

二、为什么需要 go work？（解决的痛点）

假设你有两个本地模块：

module A：github.com/yourname/project-a（业务项目）；
module B：github.com/yourname/project-b（A 依赖的工具库）。

没有 go work 时，修改 B 的代码后，要让 A 用上最新的 B，你需要：

在 A 的 go.mod 里加 replace github.com/yourname/project-b => ../project-b；
每次修改 B 后，若路径变化还要改 replace；
提交代码前还要删掉 replace，避免影响生产。

有了 go work 后：

只需创建 go.work 文件，声明两个模块的路径；
A 直接引用本地 B 的最新代码，无需 replace；
生产环境不受影响（go.work 不会提交到仓库）。

三、go work 实操步骤（完整示例）

前置条件

Go 版本 ≥ 1.18（执行 go version 检查）；
准备两个相互依赖的本地模块（示例结构）：

~/go-projects/  # 工作区根目录
├── project-a/  # 业务模块（依赖 project-b）
│   ├── go.mod
│   └── main.go
└── project-b/  # 工具库模块
    ├── go.mod
    └── utils.go

步骤 1：初始化两个 Go Module

1.1 初始化 project-b（工具库）

# 进入 project-b 目录
cd ~/go-projects/project-b
# 初始化模块（模块名自定义，建议用仓库路径）
go mod init github.com/yourname/project-b

创建 utils.go（工具库代码）：

package projectb

// 工具函数：返回字符串
func Hello() string {
    return "Hello from project-b!"
}

1.2 初始化 project-a（业务项目）

# 进入 project-a 目录
cd ~/go-projects/project-a
# 初始化模块
go mod init github.com/yourname/project-a
# 引入 project-b（此时拉取的是远端版本，后续用 go work 替换为本地）
go get github.com/yourname/project-b

创建 main.go（业务代码）：

package main

import (
    "fmt"
    "github.com/yourname/project-b"
)

func main() {
    // 调用 project-b 的函数
    fmt.Println(projectb.Hello())
}

步骤 2：创建 go work 工作区

2.1 初始化 go.work

# 回到工作区根目录
cd ~/go-projects
# 初始化工作区（生成 go.work 文件）
go work init ./project-a ./project-b

执行后，根目录会生成 go.work 文件，内容如下：

go 1.22  # Go 版本

# 引用的本地模块路径
use (
    ./project-a
    ./project-b
)

2.2 验证效果

# 在工作区根目录执行 project-a 的代码
go run ./project-a
# 输出：Hello from project-b!

# 修改 project-b 的 Hello 函数（比如返回 "Hello from local project-b!"）
# 再次执行，直接生效（无需 go get/replace）
go run ./project-a
# 输出：Hello from local project-b!

步骤 3：go work 核心命令（常用）

命令	作用
`go work init [模块路径]`	初始化工作区，添加指定模块
`go work use [模块路径]`	给工作区添加新模块（多个路径用空格分隔）
`go work edit`	编辑 go.work 文件（如手动添加 replace）
`go work sync`	将工作区的依赖同步到各模块的 go.mod
`go work env`	查看工作区的环境变量

步骤 4：高级用法（replace 临时替换依赖）

如果需要临时替换某个依赖为本地版本（比如 project-b 依赖的另一个库），可以在 go.work 里加 replace：

go 1.22

use (
    ./project-a
    ./project-b
)

// 临时将 github.com/yourname/project-c 替换为本地路径
replace github.com/yourname/project-c => ./project-c

四、go work 使用注意事项

不要提交 go.work 到仓库：
- go.work 是本地开发工具，添加到 .gitignore 即可；
- 生产环境依赖仍由 go.mod 管理，避免本地路径影响远端构建。
版本兼容：
- Go 1.18+ 才支持 go work，若团队有低版本 Go，需统一升级；
优先级：
- 工作区模式下，Go 会优先使用 go.work 里的本地模块，而非 go.mod 里的远端版本；
- 退出工作区（删除/重命名 go.work），自动恢复为 go module 模式。
多模块构建：
- 工作区根目录执行 go build ./...，可一次性构建所有模块；
- 执行 go test ./...，可一次性测试所有模块。

五、核心场景对比（什么时候用什么）

场景	用 Go Module	用 Go Work
开发单个独立项目	✅	❌
生产环境依赖管理/部署	✅	❌
本地开发多个相互依赖的模块	❌	✅
临时调试某个依赖的本地代码	❌（需 replace）	✅（更便捷）
微服务项目本地联调（多模块）	❌	✅

总结

Go Module 是「单项目依赖管理工具」，核心管依赖版本，生产环境必用；
Go Work 是「多模块本地开发工具」，核心解决本地多模块协作，无需频繁改 replace，仅开发用；
go work 使用流程：初始化工作区 → 引入多个模块 → 直接开发（本地代码实时生效），无需提交到仓库。

一、先搞懂核心概念​

1. Go Module（Go 模块）​

2. Go Work（Go 工作区）​

一句话总结核心区别​

二、为什么需要 go work？（解决的痛点）​

三、go work 实操步骤（完整示例）​

前置条件​

步骤 1：初始化两个 Go Module​

1.1 初始化 project-b（工具库）​

1.2 初始化 project-a（业务项目）​

步骤 2：创建 go work 工作区​

2.1 初始化 go.work​

2.2 验证效果​

步骤 3：go work 核心命令（常用）​

步骤 4：高级用法（replace 临时替换依赖）​

四、go work 使用注意事项​

五、核心场景对比（什么时候用什么）​

总结​

一、先搞懂核心概念

1. Go Module（Go 模块）

2. Go Work（Go 工作区）

一句话总结核心区别