本文永久链接 – https://tonybai.com/2025/04/17/go-is-badly-designed

大家好，我是Tony Bai。

今天刷X (前Twitter) 的时候，看到Golang Insiders社区下面这条推文，真是差点扑哧一声笑出来，感觉说得太形象了，必须分享给大家：

这位叫Lyes的开发者回应 “Go is badly designed” (Go 语言设计得很糟糕) 的说法，他打了个比方：

这让我想起了我的高中物理老师，我们当时都恨他，因为他从不‘放水’简化物理知识。课难、考试难，大部分人在他手下分数都不高，所以他自然成了‘坏老师’。

Go 语言就有点像他。它从不‘放水’，直面问题。你可以很快用它变得高效，写出远比用 Python 或 JavaScript 写得更好的软件。

但你也得知道，这门语言不会‘溺爱’你。当你的服务器因为一个 nil map 或其他新手常犯的错误而 panic 时，别生气。

不像 Rust，Go 的编译器不会在你编程生涯的每一刻都‘牵着你的手’。它会给你足够的方向让你知道该往哪走，满足你 80% 的需求，同时仍然保持你的生产力。

怎么样？看完这段话，是不是像极了我们初学Go时，被nil pointer dereference 或 index out of range 当头棒喝的瞬间？ 像极了我们当年一边抱怨物理老师太严格、考试太变态，一边又不得不硬着头皮去啃那些公式和定理的样子？

Lyes 的这个比喻，可以说精准地戳中了 Go 语言的一些核心特质，也解释了为什么关于“Go是否设计糟糕”的争论从未停止。咱们今天就借着这个“物理老师”的比喻，好好聊聊Go的“坏脾气”和它背后的设计哲学。

那个从不“放水”的“严格老师”

Lyes 说 Go 不会 “dumb down anything(简化任何事物，去除复杂性)”，这太对了。Go语言的设计哲学里，“简洁”（Simplicity） 是核心原则之一，但这不代表“简单化”到隐藏问题的程度。相反，它选择直面问题：

• 显式的错误处理 (if err != nil)：不像某些语言用try-catch将错误“藏”起来，Go强迫你几乎在每次可能出错的操作后都检查错误。这很“烦”，但它逼着你思考每一步潜在的风险，就像物理老师逼着你弄懂每个公式的推导过程。

• 直白的运行时Panic：当你对一个 nil 的 map 或 slice 进行操作时，Go 不会帮你“优雅地”处理，而是直接给你一个运行时 panic，程序崩溃。这很“粗暴”，但它用最直接的方式告诉你：“同学，你这里犯了个基础错误，赶紧改！” 这不就是物理老师发现你基本概念没搞懂时，直接点名批评，让你印象深刻吗？

• 没有“溺爱”的语法糖：相比一些现代语言，Go 的语法糖相对较少。它没有泛滥的操作符重载，没有复杂的隐式转换。很多事情需要你明确地写出来。这让代码有时候显得“啰嗦”，但大大降低了阅读和理解他人代码时的歧义，保证了大规模团队协作的效率。就像物理老师坚持用标准的符号和单位，不允许自创“简写”，是为了保证科学的严谨性。

“坏老师”真的“坏”吗？—— 严格背后的价值

我们当年可能都偷偷抱怨过物理老师不近人情，但多年后回想，是不是反而感谢他的严格，才让我们打下了坚实的基础？Go 语言的“严格”同样如此：

1. 逼你养成好习惯：被 nil panic 搞崩溃几次后，你自然就学会了在使用 map/slice/pointer 前做检查，学会了初始化，学会了更严谨地思考边界条件。这种被“教训”出来的习惯，最终会融入你的编程血液，让你写出更健壮、更可靠的代码。这比那些“温柔”地帮你掩盖了问题，直到生产环境才爆发出更大危机的语言，是不是长期来看更负责任？

2. 简单直白，易于掌握核心：虽然会“当头棒喝”，但Go的核心概念相对较少，语法简洁。一旦你掌握了它的规则（比如错误处理模式、接口哲学、goroutine的使用），就能快速上手，并且写出的代码风格差异不会太大，易于团队维护。它不像某些语言，特性繁多，学习曲线陡峭，精通需要漫长时间。Go就像物理老师划定的核心考点，虽然难，但范围明确，努力就有回报。

3. 效率与务实：给你“80%的指引”：Lyes 提到了Go与Rust的对比，说Go不会“全程牵手”。这正是Go的务实之处。它在编译速度、开发效率和运行时安全之间做了一个取舍。它通过快速编译、垃圾回收、简洁的并发模型，让你能高效地构建系统，满足大部分（比如 80%）场景的需求。它相信开发者是成年人，应该为自己的代码负责，而不是让编译器承担所有检查的重任。这就像物理老师教会你核心原理和解题方法，但不会一步步带着你做完所有练习题，他相信你能举一反三，独立解决问题。

不是“设计糟糕”，而是哲学不同

所以，“Go is badly designed” 吗？

与其说是“糟糕”，不如说是设计哲学和目标受众的不同。

• 如果你期望一门语言能像 Rust 那样，在编译期就为你消除几乎所有内存安全和并发风险，愿意为此付出更陡峭的学习曲线和更长的编译时间，那么 Go 可能确实“不够好”。
• 但如果你追求的是快速构建、高效部署、简单可靠、易于维护的大型后端系统，能接受在运行时处理一些本可避免的错误（并通过良好的实践和工具来减少它们），那么Go的设计哲学可能恰恰是它的优点。

Go 就像那位严格的物理老师，他可能不会让你在学习过程中时刻感到“舒适”，甚至会让你经历挫败和“阵痛”。但他目标明确，方法直接，逼着你打好基础，养成严谨的习惯，最终让你能够独立、高效地解决实际问题。

那么，你怎么看？

• 你觉得Go语言像不像你当年“恨过”的某位老师？
• 你第一次遇到 nil panic 时是什么感受？是觉得Go设计糟糕，还是反思自己代码的问题？
• 你更喜欢 Go 这种“给你方向，但不全程牵手”的方式，还是 Rust 那种“无微不至的保护”？

欢迎在评论区留下你的看法，分享你和 Go “相爱相杀”的故事！

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格6$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式：

• 微博(暂不可用)：https://weibo.com/bigwhite20xx
• 微博2：https://weibo.com/u/6484441286
• 博客：tonybai.com
• github: https://github.com/bigwhite
• Gopher Daily归档 – https://github.com/bigwhite/gopherdaily
• Gopher Daily Feed订阅 – https://gopherdaily.tonybai.com/feed

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

指针是C语言中公认的最为强大的语法要素，但同时也是最难理解的语法要素，它曾给程序员带来了无数麻烦和痛苦，以致于在C语言之后诞生的很多新兴 语言中我们再也难觅指针的身影了。

下面是一个最简单的C语言指针的例子：
int a = 5;
int *p = &a;

其中p就是一个指针变量。如果C语言中仅仅存在这类指针，那显然指针不会形成“大患”。经常地我们会在代码中看到下面的情形：

int **q = &p;
int ***z = &q;

随着符号'*'个数的增加，C代码的理解复杂度似乎也曾指数级别增长似的。像q、z这样的指向指针的指针(pointer to pointer to …)变量，中文俗称“多级指针”。不过在一些正式的英文C语言教程中，我没能找到其正式的英文说法。在老外的这些书 中，它们多被称为pointer to pointer (to pointer to ….)。多级指针的确是很难理解的，特别当与函数、数组等联合在一起使用时。今天在写代码时恰好撞见了多级指针，于是就打算在这里说说对多级指针以及 其解引用的一些粗浅理解。

指针究竟是啥？

和普通变量想比，指针变量到底有何不同，究竟何为指针(变量)？我们来看一个例子：

int a = 5;
int *p = &a;

printf("a addr = [%p]\n", &a);
printf("a content = [%d]\n", a);
printf("p addr = [%p]\n", &p);
printf("p content = [%p]\n", p);
printf("*p = [%d]\n", *p);

*p = 6;
printf("after modify, *p = [%d]\n", *p);

编译这个小程序并执行，输出结果如下：

a addr = [0xbfb609b8]
a content = [5]
p addr = [0xbfb609bc]
p content = [0xbfb609b8]
*p = [5]
after modify, *p = [6]

通过两个变量的addr，我们可以看到a、p两个变量都是在栈上分配的变量。不同的是普通整型变量a对应的内存单元(a content)中存储的值为整型值5，是一个数值；而变量p对应的内存单元(p content)中存储的值为0xbfb609b8，是变量a的地址，用栈变量简图可以表示如下：

| …      |
|0xbfb609b8| <- &p [0xbfb609bc]
|5         | <- &a [0xbfb609b8]
| …      |

可以看出指针变量的第一个特点是它是一种以存储其他变量地址为目的的变量。一个T类型的指针变量(一级指针)就是一个存储了某T类 型值变量的地址的内存单元。

例子中最后那个输出是对指针的解引用(dereference)操作，指针的解引用操作的结果是得到指针所指的地址上的变量的值。在这个例子中指 针所指到内存地址为0xbfb609b8，也就是a变量的位置，因此*p的结果为变量a的值，即5。因此我们得到指针变量的第二个特点： 通过对指针的解引用，我们可以获得其指向的内存单元所表示的值。

在例子中，我们看到了这行代码 *p = 6，并发现执行这行代码后，a变量的值变为了6。这就是指针的第三个特点：当解引用作左值时，它可以修改其所指内存地址上变量的值。a被修改后的栈变量分布简图：

| …      |
|0xbfb609b8| <- &p [0xbfb609bc]
|6         | <- &a [0xbfb609b8]
| …      |

二级指针

我们再来分析一下下面的示例程序的输出结果。

int a = 5;
int b = 13;
int *p = &a;
printf("*p = %d\n", *p); 
int **q = &p;
(*q) = &b;
printf("*p = %d\n", *p);

根据前面的分析，第一次*p输出时p指向a的地址，对p解引用的结果就是a所在内存单元的值，即5。接下来的代码分析起来就需要谨慎一些了。我们先来看看 int **q = &p这行代码。根据对一级指针的分析，我们可以将int **q理解成(int*) *q，这样q指向的地址就是一个int*型的变量的内存地址，该地址上的值本身也是一个地址值。在这个例子中，(int*) *q = &p; 也就是说q中存储的值就是变量p的地址。通过*q我们可以得到p中存储的地址值(&a)；而若*q作为左值，显然就是修改p中存储的地址值喽，因 此(*q) = &b则相当于p = &b，则第二个*p的输出结果为变量b所在内存单元的值，即13。

在修改*q前，栈上内存布局：

| …      |
|0xbf830ec8| <- &q [0xbf830ecc]
|0xbf830ec0| <- &p [0xbf830ec8]
|11        | <- &b [0xbf830ec4]
|5         | <- &a [0xbf830ec0]
| …      |

在修改*q的值后，栈上内存布局：

| …      |
|0xbf830ec8| <- &q [0xbf830ecc]
|0xbf830ec4| <- &p [0xbf830ec8] /* 通过*q修改 */
|11        | <- &b [0xbf830ec4]
|5         | <- &a [0xbf830ec0]
| …      |

再来分析一下**q的值又是啥呢？有了前面的铺垫：*q <=> p，那**q <=> *(*q) <=> *p，其值自然就明了了，就是b的值。

多级指针

有了一级指针和二级指针的分析打基础，当我们遇到更多*的时候，只是遵循这个方法耐心分析就是了，比如：

int a = 5;
int *p = &a;
int **q = &p;
int ***z = &q;

我们可以对比着前面一、二级指针的理解方法来理解这三个指针p、q和z：
    – 一级指针p自身存储的是整型值变量a的地址，对一级指针解引用(*p)得到的是值变量a的值；*p作左值，修改的是变量a的值；
    – 二级指针q自身存储的是一级整型指针变量p的地址，对二级指针解引用(*q)得到的是一级指针p自身存储的值(a的地址:&a)；*p作左值时，修改的一级指针p的指向；
    – 三级指针z自身存储的是二级整型指针变量q的地址，对三级指针解引用(*z)得到的是二级指针q自身存储的值，也就是p的地址(&p)；对*z再 解引用(**z)，相当于得到p自身存储的值，也就是a的地址&a；对**z再解引用，即***z，相当于得到a自身存储的变量值，即5。用一个 等价式可以更形象的表达：***z <=> **(*z) <=> **q <=> *(*q) <=> *p <=> 5。
    – 更高级别的指针可依次类推。不过如果再对***z解引用，即****z，那则相当于对整型数5（非地址）进行解引用，会出现编译错误： 一元 ‘*’参数类型无效(有‘int’)。