Communitygithub.com

Go 模式

用于改变编码代理工作方式的技能、插件和钩子——支持 Claude Code、Codex、OpenCode、Antigravity。可度量,而非凭感觉。

Go 模式 是什么?

该技能为 Go 语言开发者提供了一套全面的设计模式和实践指南,专注于提升代码质量和可维护性。它涵盖了函数选项模式、小接口定义、依赖注入、并发模式(如工作池和上下文传播)、错误处理(包括错误包装、自定义错误和哨兵错误)、包组织结构以及测试模式(如表驱动测试和测试辅助函数)。技能基于可控研究验证,确保模式在实际项目中的可靠性和有效性。支持多个主流 AI 编码代理平台,包括 Claude Code、Codex、OpenCode 和 Antigravity。其核心价值在于帮助开发者做出明智的设计决策,而非仅仅避免低级错误。通过遵循这些模式,开发者可以编写更加地道、可测试和可扩展的 Go 代码,从而提升整体工程效率和代码质量。

兼容平台✓Claude Code✓Codex CLI~Cursor✓Antigravity✓OpenCode
npx skills add lawzava/megapowers

在你喜欢的 AI 中提问

打开一个已预加载此 Agent Skill 的新对话。

文档

Go 模式 是做什么的?

可度量: 当前前沿 以及 小型 Claude 模型已经能够单次正确地编写常见的并发机制(工作池、流水线阶段、通道关闭),无需此技能——一项对照研究发现零正确性提升空间,两组均通过 184/184 测试(仓库的 evals/RESULTS.md §2)。在设计 选择(接口、依赖注入、错误塑造、包布局)方面使用此技能,作为审查清单,或在驱动较弱模型时使用;并非因为当前模型否则会导致死锁。

范围:Go 文件、go.mod 和 go.sum。 来源:衍生自 Everything Claude Code(MIT 许可,(c) 2026 Affaan Mustafa)。

此技能提供全面的 Go 模式,将通用设计原则与 Go 特有的惯用方法相结合。

函数选项模式

使用函数选项模式实现灵活的构造函数配置:

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) { s.port = port }
}

func NewServer(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

好处:

  • 后向兼容的 API 演进
  • 带默认值的可选参数
  • 自文档化的配置

小接口

接口在使用处定义,而非实现处。

原则: 接受接口,返回结构体

// 好:小而专注的接口,在使用点定义
type UserStore interface {
    GetUser(id string) (*User, error)
}

func ProcessUser(store UserStore, id string) error {
    user, err := store.GetUser(id)
    // ...
}

好处:

  • 更易测试和模拟
  • 松耦合
  • 清晰依赖

依赖注入

使用构造函数注入依赖:

func NewUserService(repo UserRepository, logger Logger) *UserService {
    return &UserService{
        repo:   repo,
        logger: logger,
    }
}

模式:

  • 构造函数(New* 前缀)
  • 显式依赖作为参数
  • 返回具体类型
  • 在构造函数中验证依赖

并发模式

工作池

func workerPool(jobs <-chan Job, results chan<- Result, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processJob(job)
            }
        }()
    }
    // 在所有工作线程完成后关闭 results —— 在单独的 goroutine 中执行,这样此
    // 函数立即返回,调用者可以在工作线程仍在生产时对 results 进行 range。在此处内联
    // wg.Wait() 会导致死锁:工作线程在发送到 results 时阻塞,直到有读取者将其排空,但读取者
    // 只在 workerPool 返回后运行。
    go func() {
        wg.Wait()
        close(results)
    }()
}

上下文传播

始终将 context 作为第一个参数传递:

func FetchUser(ctx context.Context, id string) (*User, error) {
    // 检查上下文取消
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    // ... 获取逻辑
}

错误处理

错误包装

if err != nil {
    return fmt.Errorf("获取用户 %s 失败: %w", id, err)
}

自定义错误

type ValidationError struct {
    Field string
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Msg)
}

哨兵错误

var (
    ErrNotFound = errors.New("未找到")
    ErrInvalid  = errors.New("无效输入")
)

// 使用 errors.Is 检查
if errors.Is(err, ErrNotFound) {
    // 处理未找到
}

包组织结构

结构

project/
├── cmd/              # 主应用程序
│   └── server/
│       └── main.go
├── internal/         # 私有应用程序代码
│   ├── domain/       # 业务逻辑
│   ├── handler/      # HTTP 处理器
│   └── repository/   # 数据访问
└── pkg/              # 公共库

命名约定

  • 包名:小写,单个单词
  • 避免重复:user.User 而非 user.UserModel
  • 使用 internal/ 存放私有代码
  • 保持 main 包最小化

测试模式

表驱动测试

func TestValidate(t *testing.T) {
    tests := []struct {
        name    string
        input   string
        wantErr bool
    }{
        {"有效", "[email protected]", false},
        {"无效", "not-an-email", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := Validate(tt.input)
            if (err != nil) != tt.wantErr {
                t.Errorf("得到错误 %v,预期 wantErr %v", err, tt.wantErr)
            }
        })
    }
}

测试辅助函数

// 导入纯 Go 驱动:_ "modernc.org/sqlite"(注册为 "sqlite")。
// 不要使用 "sqlite3"(mattn/go-sqlite3)—— 它需要 CGO 并且会破坏 CGO_ENABLED=0
// 静态构建。greenfield-go-stack 包强制要求纯 Go / 无 CGO。
func testDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        t.Fatalf("打开测试数据库失败: %v", err)
    }
    // ":memory:" 数据库对于单个连接是私有的,并且 database/sql
    // 是一个懒连接池:如果没有这个设置,每个池连接都会获得自己独立的空
    // 数据库,因此在一个连接上创建的表在下一个连接上会缺失。
    // 将池固定到单个连接使得整个测试共享一个内存中数据库。
    // 注意:使用单个连接时,当 tx 打开时 (db.Begin),该 tx 持有唯一的连接——
    // 所有工作都应通过 tx 进行,直到 Commit/Rollback;
    // 对池的并发 db.Query 将阻塞等待它。如果测试确实需要多个实时连接,
    // 请改用共享缓存 DSN("file:testdb?mode=memory&cache=shared")并保持 >=1 个连接打开,
    // 以免内存数据库被删除。
    db.SetMaxOpenConns(1)
    t.Cleanup(func() { db.Close() })
    return db
}

何时使用此技能

  • 设计 Go API 和包
  • 实现并发系统
  • 结构化 Go 项目
  • 编写地道的 Go 代码
  • 重构 Go 代码库

相关技能