本文永久链接 – https://tonybai.com/2025/12/15/go-language-anti-patterns-10-donts

大家好，我是Tony Bai。

“有哪些‘不要做’的教训，是你花了好几年才学会的？”

近日，在 r/golang 社区，这个简单的问题，引爆了一场关于 Go 语言“反模式”与“最佳实践”的集体反思。帖子下数百条评论，汇集了无数 Gopher 在真实项目中用“血与泪”换来的宝贵经验。这些教训，往往不是关于某个高深的算法，而是关于那些看似“理所当然”，却在不经意间为代码埋下地雷的日常习惯。

这篇文章，正是对这场集体智慧的一次系统性梳理。我们从中提炼出 10 条最核心的“不要做”法则，它们如同一份“避坑指南”，能帮助你绕开那些最常见的陷阱，更快地从一名“会写 Go 的程序员”，成长为一名“懂 Go 的工程师”。

不要过度封装包

Don’t overpackage things

初学者往往有一种冲动，想把代码组织成“语义化”的、层层嵌套的包结构。internal/models, internal/services, internal/repositories…… 这种源自其他语言（如 Java）的模式，在 Go 的世界里，往往是一种过早的、不必要的复杂性。

社区忠告：从一个 main.go 文件开始。努力思考，是否真的有必要将代码拆分到多个文件/包中。Go 的包，其主要目的是封装和依赖管理，而不是单纯的文件夹分类。在小型或中型项目中，一个清晰的、扁平的包结构，远比一个复杂的“企业级”目录树更易于维护。

不要滥用 channel 和 goroutine

Don’t just add in channels

并发是 Go 的“名片”，这使得许多开发者（尤其是新手）有一种“锤子心态”——看到任何问题，都想用 goroutine 和 channel 来解决。然而，不必要的并发，是复杂性和 bug 的温床。

社区忠告：

• 先问“是否需要”：你真的需要并发吗？如果不需要在线程间传递消息，你可能根本不需要 channel。一个简单的 sync.WaitGroup 或 sync.Mutex，在很多场景下都比 channel 更简单、更直接。
• 并发不是免费的：Go 让创建 goroutine 变得异常简单，但这并不意味着它是零成本的。过多的 goroutine 会增加调度器的负担，而 channel 的滥用则会使数据流变得难以追踪和调试。

不要盲目追求 DRY

Don’t be zealous about DRY

DRY 是编程的基本原则，但在 Go 的哲学中，它有一个更重要的“上级”——清晰性。为了消除几行重复代码，而引入一个复杂的接口或一个晦涩的辅助函数，往往得不偿失。

社区忠告：“一点点复制，胜过一点点依赖 (a little copy-paste is better than a little dependency)。” 当你发现自己在为了 DRY 而绞尽脑汁时，请停下来问问自己：这份重复，是否真的带来了维护上的痛苦？如果不是，那么接受它，可能是一个更明智的选择。

不要在同一个 PR 中既重构又添加新功能

Don’t refactor and add features in the same PR

在添加一个新功能时，顺手“优化”一下周围的代码，这看起来很高效。但实际上，这会让 Code Review 变得异常痛苦。Reviewer 无法清晰地分辨，哪些改动是为新功能服务的，哪些是纯粹的重构。这不仅增加了审查的难度，也提高了引入新 Bug 的风险。

社区忠告：遵循“童子军军规”——“让营地比你来时更干净”——是好的。但请将它分解为两个独立的、目标明确的 PR：一个只做重构，另一个（基于重构后的代码）只添加新功能。

不要跳过写测试，“就这一次”

Don’t skip writing tests “just this once”

这是所有开发者都曾屈服过的诱惑。“这个改动太小了”、“我百分之百确定它是对的”、“项目赶时间”…… 每一次“就这一次”的妥协，都在为未来的“技术雪崩”添砖加瓦。

社区忠告：将测试视为代码不可分割的一部分。在 Go 中，编写测试是如此简单和自然，以至于没有任何借口可以跳过它。你今天节省下来的 10 分钟，可能会在未来，让你或你的同事，花费数天时间去调试一个本可避免的生产问题。

不要害怕使用 sync.Cond

channel 非常强大，但它并非解决所有并发同步问题的“银弹”。社区中有一种“反 sync”的情绪，认为所有同步都应该用 channel 来完成。

社区忠告：sync.Cond 是一个被低估了的、极其强大的并发原语。当你需要基于某个特定条件来唤醒一个或多个等待的 goroutine 时（例如，一个任务队列的消费者在队列为空时等待），sync.Cond 往往比用 channel 实现的复杂信令机制，要更简单、更高效。不要因为不熟悉，就回避它。

不要返回接口

Returning interfaces. Don’t do it.

在函数签名中返回一个接口，看似遵循了“依赖倒置”的高级原则，甚至觉得这样更“灵活”。但实际上，这往往是一种过早的、有害的抽象。它剥夺了用户访问底层具体类型特有功能的能力，并且如果未来需要添加新方法，接口的变更会极其痛苦。

社区忠告：遵循 Go 的经典谚语：“接收接口，返回结构体 (Accept interfaces, return structs)。”

• 接收接口：让你的函数接收一个只包含其所需最小方法集的接口作为参数。这使得你的函数更容易被测试和复用（你可以传入任何满足该接口的实现，包括 Mock 对象）。
• 返回结构体：让你的函数返回一个具体的类型（通常是指针）。这给了调用者最大的灵活性。

经典范例：

看看标准库中的 os.Open，它返回的是 *os.File（具体结构体），而不是 io.Reader（接口）。
* 为什么这样做？ 因为 *os.File 不仅能读（Read），还能关闭（Close）、获取状态（Stat）、甚至改变权限（Chmod）。
* 灵活性：如果它返回的是接口，用户就无法使用 Chmod 等特有功能了。而返回结构体，用户既可以使用其全部功能，也可以在需要时，轻松地将其赋值给 io.Reader 接口来使用。这就是“返回结构体”带来的自由。

(注：只有当返回的类型是包内私有的、不希望外部直接访问的实现细节时，返回接口才是有意义的，例如 context.WithCancel 返回的是 Context 接口。)

不要过度依赖依赖

Don’t add dependencies without vetting

为了解决一个小问题，而引入一个庞大的、闪亮的第三方库。这在 Node.js 生态中很常见，但在 Go 社区，这通常被视为一种“危险信号”。

社区忠告：

• 先求诸标准库：在引入任何依赖之前，先问问自己：这个问题，标准库真的解决不了吗？
• 审慎评估：如果必须引入依赖，请仔细评估它：它的依赖树有多深？社区是否活跃？维护者是否可靠？一个简单的依赖，可能会为你整个项目，带来潜在的供应链安全风险和维护噩梦。

不要盲从

Don’t do [or not do] something simply because an authoritative voice recommended it

盲目地遵循某个“大神”、某篇“爆款”博客文章、或者某个“权威”推荐的模式，而没有结合自己的具体场景进行批判性思考。

社区忠告：上下文决定一切。YAGNI (You Aren’t Gonna Need It) 是一个好原则，但有时你确实需要提前设计。微服务很好，但有时单体就是最佳选择。没有银弹。最好的实践，是那些在你的团队、你的项目中，被证明行之有效的实践。

不要忘记，代码是给人读的

忘记了代码的最终读者是人类，而不是编译器。编写只有自己能看懂的“聪明”代码，或者忽略文档和注释的重要性。

社区忠告：

• 编写能让你的未来“自已”不会痛骂你的代码。
• 好的设计不是增加，而是保持本质的简单。代码即是负债 (Code is liability)。
• 不要忽视清晰文档的重要性。

小结：在“坑”里成长

这份清单，远非全部。社区的讨论中还充满了诸如“不要用 singleton 来做 mock”、“不要滥用 init 函数”、“不要在疲劳时 Review 代码”等无数宝贵的经验。

它们共同指向了一个核心思想：成为一名优秀的 Go 工程师，其过程不仅仅是学习语言的特性，更是一个不断反思、不断“踩坑”、并从“坑”中总结出属于自己“不要做”清单的修炼过程。希望这份来自社区的集体智慧，能让你在这条路上，走得更稳、也更远。

资料链接：https://www.reddit.com/r/golang/comments/1pib68y/whats_a_dont_do_this_lesson_that_took_you_years/

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

本文永久链接 – https://tonybai.com/2025/12/13/from-eiffel-contract-to-go-interface

大家好，我是Tony Bai。

20年前，当我第一次翻开 Bertrand Meyer 的那本巨著《面向对象软件构造》(Object-Oriented Software Construction) 时，一种醍醐灌顶的感觉油然而生。书中那个名为 Eiffel 的语言，以及它所倡导的 “契约式设计” (Design by Contract, DbC)，仿佛为当时混乱的软件开发世界点亮了一盏明灯。

虽然 Eiffel 语言最终并未像 Java 或 C++ 那样统治世界，但它留下的思想遗产——前置条件、后置条件、不变量——却潜移默化地渗透进了现代软件工程的骨髓。

时光流转，当我们站在云原生时代的潮头，手握 Go 语言 这把利器时，你是否意识到：Go 的接口 (Interface) 设计，其实是一场跨越 20 年的、对契约精神的现代演绎与致敬。

今天，让我们重温经典，看看那些曾被奉为圭臬的“契约”，是如何在 Go 的代码世界里重生的。

什么是“契约”？—— 软件世界的商业法则

在人类社会中，商业活动的基石是合同（契约）。甲方（Client）和乙方（Supplier）通过一纸文书，明确了彼此的权利与义务。

Bertrand Meyer 的天才之处，在于他将这种商业隐喻完美地移植到了软件模块的交互中。他认为，软件的高可靠性不能靠“运气”或“防御性编程的堆砌”，而应靠明确定义的契约。

Eiffel 语言直接将这种契约内置到了语法层面，形成了著名的“三驾马车”：

1. 前置条件 (Preconditions / require)

   • 定义：在调用函数之前，调用方 (Client) 必须确保为真的条件。
   • 商业隐喻：你要坐飞机（调用服务），必须先买票且准时到达（满足前置条件）。如果没买票，航空公司（服务方）有权拒绝服务。

2. 后置条件 (Postconditions / ensure)

   • 定义：在函数执行之后，服务方 (Supplier) 承诺必须为真的条件。
   • 商业隐喻：只要你买了票且准时登机，航空公司必须把你安全送到目的地（满足后置条件）。

3. 不变量 (Invariants / invariant)

   • 定义：在对象的整个生命周期中（所有公开方法调用前后），始终保持为真的“真理”。
   • 商业隐喻：无论飞机怎么飞，乘客数量绝不能超过座位数。

“契约”的核心价值在于信任：如果每个人都遵守契约，我们就不需要在每一行代码里都写那种偏执的 if (x != null) 检查。代码将变得更干净、更高效、更健壮。

为了让你直观感受这种思想的冲击力，让我们看一段 Eiffel 代码。这是一个简单的字典（Dictionary）插入操作，请注意看它是如何用 require、ensure 和 invariant 将逻辑严丝合缝地包裹起来的：

class DICTIONARY [ELEMENT]

feature
    count: INTEGER
    capacity: INTEGER

    put (x: ELEMENT; key: STRING) is
        -- 将元素 x 插入字典，通过 key 检索
        require
            -- [前置条件]：调用者的责任
            not_full: count < capacity
            key_not_empty: not key.empty
        do
            -- ... 这里是具体的插入算法实现 ...
            -- ... 真正的业务逻辑代码 ...
        ensure
            -- [后置条件]：实现者的承诺
            element_added: has (x)
            key_associated: item (key) = x
            count_increased: count = old count + 1
        end

invariant
    -- [不变量]：始终为真的真理
    consistent_count: 0 <= count and count <= capacity

end

注：对于不熟悉 Eiffel 语法的同学，其实只需关注四个关键词：require 是对入参的“资格审查”，do 是干活的“核心逻辑”，ensure 是对结果的“质量验收”，而 invariant 则是贯穿始终的“宪法”。

看到这里，你是否感受到了一种秩序之美？

这段代码不仅仅是在“写程序”，它是在立法。require 明确了“什么情况下可以调”，ensure 明确了“调用后会发生什么”，而 invariant 则像定海神针一样稳住了对象的状态。

“契约”的核心价值在于信任：如果每个人都遵守契约，我们就不需要在每一行代码里都写那种偏执的 if (x != null) 检查。代码将变得更干净、更高效、更健壮。

Go 接口 —— 契约的“鸭子类型”演绎

Eiffel 选择了显式的、强硬的语法来强制契约；而 Go 语言，则选择了一种更为隐式、灵活，但也更具工程智慧的方式——接口 (Interface)。下面表格直观地展示了在契约这个概念上，Eiffel实现方式与Go的演绎方式上的方式：

下面我们再具体说一下。

行为即契约

Go 的接口设计哲学是：“如果它走起路来像鸭子，叫起来像鸭子，那它就是鸭子。”

在 Go 中，我们不关心一个类型“是谁”（继承了哪个父类），我们只关心它“承诺能做什么”。这种承诺，就是契约。

以标准库中最经典的 io.Reader 为例：

type Reader interface {
    Read(p []byte) (n int, err error)
}

这短短三行代码，实际上定义了一个极其强大的契约：

• 前置条件（隐式）：你需要给我一个切片 p。
• 后置条件（隐式）：我会尝试读取数据填入 p，并返回读取的字节数 n 和可能发生的错误 err。如果 n > 0，则 p[0:n] 包含了有效数据。

任何一个结构体，无论是 os.File、net.Conn 还是 bytes.Buffer，只要它签署（实现）了这个契约，就可以被无缝地替换和复用。这正是 DbC(Design by Contract) 理论中 Liskov 替换原则 在 Go 语言中的完美落地。

强类型的约束

虽然 Go 没有 require 关键字，但它利用强类型系统实施了最基础的契约检查。

在动态语言中，你可能需要写代码检查参数是否为数字。但在 Go 中，如果函数签名是 func Sqrt(x float64)，编译器就是你的契约执行官——它保证了绝不会有字符串类型的“非法移民”混入函数内部。

在 Go 中实践“契约精神”

在尝试将 DbC 落地到 Go 语言时，我们必须首先承认一个事实：Go 并非传统的面向对象语言。

Eiffel 是建立在类（Class）和继承（Inheritance）之上的。它的 invariant 依赖于类的状态封闭性，它的 require 和 ensure 依赖于方法重写时的“契约继承”规则（Liskov 替换原则的严格形式）。

而 Go 是基于组合和接口的。我们没有“类”，只有结构体；我们没有“继承”，只有嵌入。这种范式上的根本差异，注定了我们无法在 Go 中获得 Eiffel 那种“原生级”的契约支持，任何试图在语法层面 1:1 还原 Eiffel 的尝试，都会显得格格不入且笨拙。

但这并不意味着我们可以抛弃 DbC 的思想。相反，一个优秀的 Gopher，应当学会“神似而形不似”——利用 Go 的原生特性（Panic, Error, Defer, Testing），手动“编织”出健壮的契约网。

捍卫前置条件：Panic 还是 Error？

在 Go 中执行前置条件检查，通常有两种流派：

• 针对编程错误（Bug）—— 使用 panic

如果调用者违反了API的基本使用协议（例如，传入了一个 nil 的上下文，或者索引越界），这通常意味着调用方代码有 Bug。此时，快速失败（Fail Fast）是最好的选择。

func MustRegister(handler Handler) {
    if handler == nil {
        panic("http: nil handler") // 显式的前置条件检查
    }
    // ...
}

• 针对运行时错误 —— 返回 error

如果前置条件依赖于外部世界（如网络是否连通、文件是否存在），则应返回 error，让调用方决定如何处理。

验证后置条件：Defer 与测试

Eiffel 的 ensure 可以在运行时自动检查。在 Go 中，我们可以利用 defer 甚至构建标签（Build Tags）来模拟这种行为，特别是在调试模式下。

// 仅在调试构建中启用的断言逻辑
func (s *Stack) Push(item int) {
    if debug {
        // 捕获旧状态
        oldSize := s.size
        defer func() {
            // 验证后置条件
            if s.size != oldSize + 1 {
                panic("invariant violated: stack size did not increment")
            }
        }()
    }
    // ... 业务逻辑 ...
}

但更 Go Style 的做法是：将后置条件的验证移交给单元测试（Unit Test）和模糊测试（Fuzzing）。Go 强大的测试工具链，本质上就是一个外挂的“契约验证器”。

守护不变量：“构造函数”与封装

如何保证对象始终处于合法状态（不变量）？Go 给出的答案是：封装（Encapsulation）。

通过将结构体的字段设为私有（小写字母开头），并强制用户通过 New… 工厂函数来创建对象，我们可以确保对象在出生那一刻就是满足不变量的，并且在后续的生命周期中，外部无法破坏它。

package stack

type Stack struct {
    items []int // 私有，外部无法直接修改，保证了数据的安全性
}

// 工厂函数：保证初始状态的不变量
func New() *Stack {
    return &Stack{items: make([]int, 0)}
}

示例 —— 一个“契约式”的栈

让我们把上述思想综合起来，写一个简单的、充满“契约精神”的栈。

package stack

import "errors"

// StackInterface 定义了行为契约
type StackInterface interface {
    Push(v int) error
    Pop() (int, error)
    Size() int
}

type Stack struct {
    items []int
    cap   int
}

// New 创建栈，同时确立初始不变量
func New(capacity int) *Stack {
    if capacity <= 0 { // 前置条件检查
        panic("capacity must be positive")
    }
    return &Stack{
        items: make([]int, 0, capacity),
        cap:   capacity,
    }
}

func (s *Stack) Push(v int) error {
    // 前置条件：栈未满
    if len(s.items) >= s.cap {
        return errors.New("stack overflow")
    }

    s.items = append(s.items, v)

    // 后置条件（隐式）：len 增加了 1，且栈顶元素是 v
    // 在 Go 中，我们通常信任代码逻辑，或通过测试覆盖此条件
    return nil
}

func (s *Stack) Pop() (int, error) {
    // 前置条件：栈不为空
    if len(s.items) == 0 {
        return 0, errors.New("stack underflow")
    }

    v := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return v, nil
}

// 不变量：Size 永远不会超过 Capacity，也不会小于 0
// 这由 Push 和 Pop 的逻辑严密性以及私有字段的封装共同保证。

进阶思考：并发下的不变量

还有一点不能忽略：Go 是为并发而生的。在单线程模型中，封装或许足以维护不变量。但在 Go 的并发世界里，如果多个 goroutine 同时修改这个 Stack，竞态条件（Race Condition）瞬间就会破坏 count <= capacity 这样的“真理”。

因此，在 Go 的工程实践中，维护不变量往往还需要同步原语（如 sync.Mutex）的强力介入。只有配合了锁机制，才能确保对象在并发洪流的冲击下，依然能守住那份“不变”的契约。

小结：心中的契约

在结束这次跨越 20 年的时空对话之际，我想特别澄清一点：本文的目的，绝非鼓励大家在 Go 语言中笨拙地“模拟”一套 Eiffel 的语法糖。

Go 语言有其独特且自洽的设计哲学——简洁、组合、并发。强行在 Go 代码中堆砌 require() 或 ensure() 函数，往往会画虎不成反类犬，破坏 Go 代码原有的流畅性。

我们重温 DbC，是为了汲取思想的养分。Bertrand Meyer 教会了我们要对代码的“权利与义务”保持敏感：

• 当你写下一个函数时，你是否想清楚了它的前置条件？
• 你是否通过单元测试守护了它的后置条件？
• 你是否通过封装维护了对象的不变量？

这些思考方式，才是 DbC 留给非 DbC 语言(如 Go、Java、Python)最宝贵的遗产。Bertrand Meyer 在 20 年前种下的那颗种子，虽然没有长成 Eiffel 这棵参天大树，但它的花粉却飘散到了整个软件工程的花园里。

Go 语言选择了另一条更务实的道路：用接口定义契约，用封装保护契约，用测试验证契约。

作为一名 Gopher，当我们写下 type … interface，或者敲下 if err != nil 时，我们实际上是在履行一份神圣的职责。语言的特性在演进，但软件工程的核心——信任与责任的管理——从未改变。

真正的契约，不只写在代码里，更应刻在每一位工程师的心里。

参考资料

• Building bug-free O-O software: An introduction to Design by Contract – https://archive.eiffel.com/doc/manuals/technology/contract/
• Object-Oriented Software Construction(2nd) – https://book.douban.com/subject/1547078/
• Programming “By Contract” – https://www.cs.usfca.edu/~parrt/course/601/lectures/programming.by.contract.html

聊聊你心中的“代码契约”

这场跨越20年的思想对话，让我们重新审视了Go接口背后那份深刻的工程哲学。从Eiffel那严谨如“立法”的require/ensure，到Go语言“润物细无声”的interface/error/testing组合，我们看到的是不同时代背景下，对“信任与责任”这一软件工程核心母题的不同解答。

那么，在你日常的Go编程实践中，你是如何理解和贯彻“契约精神”的？

• 你是否也有过因为接口（契约）定义不清，而导致团队协作“踩坑”的经历？
• 除了文中提到的方法，你还有哪些维护代码“权利与义务”的独门心法？
• 你认为，Go语言在“契约”的表达上，还有哪些值得改进或探索的方向？

非常期待在评论区看到你的故事与真知灼见，让我们一起探讨如何成为更具“契约精神”的工程师！

如果这篇文章让你对Go接口或软件工程的理解更深了一层，别忘了点个【赞】和【在看】，并分享给更多热爱思考的同伴！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。