标签 Python 下的文章

被嘲笑比 Python 还慢?扒开 Go 正则表达式的底层,看看它为了防范“系统猝死”付出了什么

本文永久链接 – https://tonybai.com/2026/03/17/why-is-go-regex-so-slow

大家好,我是Tony Bai。

如果有人问你:在处理纯 CPU 密集型的文本匹配时,Go 和 Python 哪个快?

相信 99% 的 Go 开发者会毫不犹豫地把票投给 Go。毕竟,一门编译型的静态语言,怎么可能输给拖着 GIL 锁的解释型脚本语言?

但现实往往比小说更魔幻。

最近,在 Reddit 的 r/golang 论坛上,一张残酷的 Benchmark 跑分图引发了整个 Go 社区的剧烈震荡。一位开发者,使用极其常见的日志解析正则表达式(提取 IP、时间、URI 等),对各大语言进行了一次横评。

结果令人大跌眼镜:同样的数据集,Rust 跑了 3.9 秒,Zig 跑了 1.3 秒,而 Go 居然跑了整整 38.1 秒!整整比第一名 Zig 慢了接近 30 倍!

如果你再去翻看 Go 官方的 Issue #26623,会看到更绝望的数据:早在2018年的一次正则基准测试中,Go 不仅被 C++ 和 Rust 碾压,甚至连 Python 3、PHP 和 Javascript 都能在正则上把 Go 按在地上摩擦。

一时间,无数 Gopher 信仰崩塌:“为什么 Go 的标准库 regexp 这么慢?”、“连简单的正则都做不好,Go 凭什么做云原生霸主?”

今天,我们就来硬核扒开 Go 语言 regexp 包的底层设计和实现。你会发现,这不是 Go 团队的技术拉跨,而是一场关于“性能、安全与工程哲学”的博弈。

原罪:你以为的慢,其实是替 CGO 负重前行

面对“为什么 Go 的正则比 Python 还慢”的灵魂拷问,Go 核心团队成员 Ian Lance Taylor 给出了第一层解释。

在 Python、PHP 甚至 Node.js 中,你以为你是在运行脚本,其实它们底层都在悄悄“作弊”。这些语言的正则表达式引擎,几乎全部是用高度优化的 C 语言库(主要是 PCRE,Perl Compatible Regular Expressions)编写的。

当你在 Python 里调用 re.match() 时,它瞬间就穿透到了 C 语言的底层,享受着现代 CPU 指令集的极致加速。

那 Go 为什么不用 C?因为 Go 是一门有着“极度洁癖”的语言。

如果 Go 的标准库引入了 C 语言的 PCRE,就必须通过 CGO 来调用。而 CGO 的上下文切换成本极高,更致命的是,它会彻底破坏 Go 引以为傲的“跨平台交叉编译”能力。你再也不能在一个简单的 go build 后,把二进制文件无痛丢到任何 Alpine 容器里了。

因此,Go 团队做出了第一个艰难的决定:完全使用纯 Go 语言,从零手写一个正则表达式引擎。

脱离了 C 语言几十年的底层优化积累,用原生代码去硬刚别人的 C 引擎,这是 Go 看起来“慢”的表层原因。

但这,仅仅是冰山一角。

路线之争:为了防止系统“猝死”,Go 抛弃了速度

真正让 Go 正则变得“慢”的,是算法架构上的降维选择。这牵扯到 Go 语言的缔造者之一、大神 Russ Cox (rsc) 的一段往事。

在正则表达式的底层世界里,存在着两大流派:

  1. 基于回溯(Backtracking)的 NFA 引擎:代表人物是 PCRE(被 Python、Java、PHP 广泛使用)。
  2. 基于 Thompson NFA / DFA 的引擎:代表人物是 RE2(被 Go、Rust 采用)。

PCRE 引擎极快,它支持各种花里胡哨的语法(如前瞻断言 Lookaround、反向引用 Backreferences)。它的算法逻辑是“不撞南墙不回头”的深度优先搜索(DFS)。在匹配正常字符串时,它快如闪电。

但它有一个极其致命的死穴:ReDoS(正则表达式拒绝服务攻击)。

想象一下你写了一个看似无害的正则:

^([a-zA-Z0-9]+\s?)+$

如果黑客故意传入一个极其恶意的字符串:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!(注意最后的感叹号)。

PCRE 引擎会陷入可怕的“灾难性回溯”。它会尝试所有可能的组合,时间复杂度瞬间飙升到 O(2^n) 级。短短几十个字符的输入,能让单核 CPU 满载运行几年都算不出结果!

2019 年,互联网巨头 Cloudflare 就因为在 WAF 防火墙中写错了一个极其简单的正则表达式,CPU资源瞬间耗尽,导致全球80% 的通过 Cloudflare 代理的网站受到影响,陷入瘫痪长达 27 分钟。这就是 PCRE 回溯引擎的恐怖破坏力。

Russ Cox 在设计 Go 的 regexp 包时,定下了一条铁律:系统安全与可预测性,绝对高于单次请求的极限性能。

因此,Go 彻底抛弃了危险的回溯引擎,选择了基于 Thompson NFA 的算法(源自他之前在Google主导设计的 C++ RE2 引擎)。这种算法保证了匹配时间永远是线性复杂度 O(n)

无论黑客传入多么恶意的字符串,Go 的正则引擎绝对不会发生灾难性回溯。它牺牲了在美好情况下的极致快感,换取了在极端恶劣环境下的金身不坏。

这算是 Go 团队最顶级的“克制”吧。

硬核剖析:Go 的正则,时间到底去哪了?

既然算法是 O(n) 的,为什么 Go 依然比同样采用 RE2/DFA 思想的 Rust 慢那么多呢?

如果你去追踪 Go 官方的 Issue #19629Issue #11646,通过 pprof 分析 Go 正则匹配的 CPU 耗时,你会看到几个令人头疼的瓶颈:

1. 沉重的 UTF-8 解析税

Rust 和 C 的很多正则引擎,底层是直接在“字节(Byte)”级别游走的。而 Go 为了贯彻它对 Unicode 的原生支持,regexp 包在内部极其频繁地将输入流解码为 Rune(Go 的 Unicode 字符单位)。这种逐个解析 Rune 的操作,带来了巨大的计算开销。

2. NFA 虚拟线程的内存震荡

在 Go 的底层源码中,你可以看到耗时最高的两个函数是 (machine).add 和 (machine).step。

Go 是通过维护两个“状态队列(稀疏集)”来模拟 NFA 的并行推进的。每读取一个字符,引擎就要把所有可能的状态添加到下一个队列中。这导致了海量的内存重分配(Allocation)和切片拷贝。哪怕是匹配一个简单的长字符串,底层都在疯狂地挪动内存。

既然这么慢,为什么不把 C++ RE2 里那个极速的 DFA(确定性有限状态自动机)移植到 Go 里呢?

Issue #11646 记录了这次尝试。开发者 Michael Matloob 曾经试图将 RE2 的 DFA 移植过来,但被 Russ Cox 拦下了。原因很直接:DFA 虽然快,但它在运行时会动态生成大量的状态,如果不加以严格限制,极易引发内存耗尽(OOM)。在 Go 带有 GC 的内存模型下,频繁创建和销毁庞大的 DFA 状态缓存,会让垃圾回收器不堪重负。

于是,Go 的标准库在“安全、内存、性能”的三角博弈中,选择了妥协于现状。

社区的探索:SIMD 降维打击与 100倍加速的 coregex

官方的克制固然令人敬佩,但对于身处一线的业务开发者来说,由于正则太慢导致的 CPU 告警,是实实在在的痛点。

“既然官方不愿意改,那我们就自己造轮子!”

在近期的 Issue #26623 中,一位名为 kolkov 的开发者带着他的开源库 coregex 杀入了战场,向 Go 标准库发起了直接的挑战。

coregex 是一个完全用纯 Go 编写的正则库,它的出现直接将 Go 的正则性能拉到了与 Rust 并驾齐驱,甚至在某些场景下超越 Rust 的境地。

它是怎么做到的?它在底层祭出了几个大杀器:

  1. SIMD 预过滤(Prefilters):它使用了手写的汇编代码(AVX2/SSSE3 指令集),将正则中的静态字符串提取出来,利用 CPU 的向量化指令,一次性对比 32 个字节。像匹配 .*.txt 这种正则,速度直接飙升了 1500倍
  2. 带缓存的 Lazy DFA:它绕过了标准库每次都重算 NFA 的毛病,在运行时动态构建 DFA 缓存,大幅消除了内存分配。
  3. 写时复制(COW)的捕获组:标准库在处理提取子串时会疯狂分配切片。coregex 通过切片状态共享,让内存分配直接减少了 50%。

在 kolkov 提供的 CI 跑分中,在 6MB 的输入下,coregex 处理邮箱、URI 的耗时仅为 1.5 毫秒,而标准库耗时高达 260 毫秒。足足快了 170 倍!

然而,这段极其硬核的改进,依然很难入Go团队法眼,更不用谈在短期内被合并进 Go 的标准库。

一方面,Go 官方目前正在推进自己的内建 SIMD 方案(Issue #73787),不想接入手写的汇编代码;另一方面,社区大牛 Ben Hoyt 在使用 coregex 时发现,如果开启 Longest() 模式(最长匹配模式),这个库的性能会发生严重退化。

这再次印证了标准库开发的残酷:在某几个特定场景下跑到全宇宙第一很容易,但要在一套 API 里无死角地兜底全世界所有的奇葩正则输入,难如登天。

在 Go 中写正则的正确姿势

大致了解了底层原理,回到日常开发中,我们该如何应对 Go 正则的性能瓶颈?作为高级 Go 开发者,请务必将以下三条军规刻在脑子里:

第一条:能不用正则,就坚决不用

如果你只是想检查字符串是否包含子串,或者进行简单的前后缀匹配,永远优先使用 strings.Contains()、strings.HasPrefix() 等内置函数。 它们底层有优化的实现,在这样简单场景下,速度是 regexp 包不可比拟的。

第二条:将编译前置,远离循环

如果你翻看新手代码,最常见的低级错误就是在 for 循环或者每次 HTTP 请求里调用 regexp.Compile()。

正则的编译过程(生成 NFA 字节码)极其消耗 CPU。请永远在全局变量或 init() 函数中使用 regexp.MustCompile(),将其编译好并复用。Go 的 Regexp 对象是并发安全的,随便多 Goroutine 调用。

第三条:在极端性能要求下,打破“洁癖”

如果你的核心业务(比如高频日志清洗、海量数据 ETL)确实被 regexp 卡住了脖子,不要硬抗。

你可以选择引入通过 CGO 调用 PCRE的Go binding库(比如https://github.com/GRbit/go-pcre),但要注意防范 ReDoS 攻击,或google/re2的Go binding(比如https://github.com/wasilibs/go-re2),又或是在业务侧尝试社区的野路子 coregex。在生存面前,架构的“洁癖”是可以适当妥协的。

小结

“为什么 Go 的正则这么慢?”

这并非一个简单的工程失误。它是一道分水岭,隔开了“追求跑分好看的玩具代码”与“守护千万级并发集群的生产级设计”。

Russ Cox 宁愿忍受整个开源界的群嘲,也没有为了刷榜而去引入危险的回溯引擎。这或许就是 Go 语言能够成为云原生时代头部语言的原因:不盲目追求上限的巅峰,而是死死守住安全下限。

参考资料

  • https://www.reddit.com/r/golang/comments/1rr2evh/why_is_gos_regex_so_slow/
  • https://github.com/golang/go/issues/26623
  • https://github.com/golang/go/issues/19629
  • https://github.com/golang/go/issues/11646
  • https://swtch.com/~rsc/regexp/

今日互动探讨:

在你的日常开发中,有没有被由于“写了糟糕的正则表达式”而导致 CPU 飙升 100% 的惨痛经历?你又是如何排查和优化的?

欢迎在评论区分享你的血泪史


认知跃迁:读懂底层机制,才能看透系统架构的本质

从放弃 CGO 选择纯 Go 实现,到防范 ReDoS 采用 NFA,再到社区为了榨干 CPU 性能而引入 SIMD。Go 语言的每一个看似“不合理”的设计背后,都隐藏着深邃的系统级考量。

然而,令人遗憾的是,很多开发者写了五六年的 Go 代码,遇到性能瓶颈依然只能靠“瞎猜”和“重启”。他们对 Go 的内存逃逸、Goroutine 调度机制以及标准库的底层数据结构一无所知。

如果你渴望突破“熟练调包侠”的瓶颈,想要像 Russ Cox 这样的顶级大厂架构师一样,看透 Go 语言背后的底层逻辑,建立起自己坚不可摧的技术护城河——

我的极客时间专栏 Tony Bai·Go语言进阶课 正是为你量身定制。

在这 30+ 讲极其硬核的内容中,我不仅带你剥开语法糖,深挖 Goroutine 调度、Channel 哲学;更会带你全面吃透 Go 的工程化实践,把底层性能调优背后的逻辑一次性讲透。

目标只有一个:助你完成从“Go 熟练工”到“能做顶级架构决策的 Go 专家”的蜕变!

扫描下方二维码,加入专栏。不要用战术上的勤奋,掩盖战略上的懒惰。让我们一起用架构师的视角,重新认识 Go 语言。


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

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

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


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

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

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

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

img{512x368}


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

硬核测评:哪门语言最受 AI 宠爱?13 种语言横向对比,Go 表现如何?

本文永久链接 – https://tonybai.com/2026/03/09/hardcore-review-13-languages-ai-favorite-go-performance

大家好,我是Tony Bai。

随着 Claude CodeGemini Cli、Codex 等 AI 编程工具的全面普及,“让 AI 写代码”已经从极客的玩具变成了日常的生产力。随之而来的是一个触及灵魂的问题:哪种编程语言最适合交给 AI 去写?

作为 Gopher,我们一直为 Go 语言的“极简语法”、“极速编译”和“强类型安全”感到自豪。我们理所当然地认为,这种没有任何隐式魔法、像白开水一样的语言,绝对是 LLM 的最爱。

然而,现实总是比直觉更骨感。近日,Ruby 核心提交者 Yusuke Endoh(@mame)发布了一份名为 ai-coding-lang-bench 的硬核定量测评报告。他使用 Claude Code(Opus 4.6 模型)对 13 种主流编程语言进行了系统性横向对比。

在这场涵盖了动态语言、静态语言和函数式语言的混战中,Go 语言的表现究竟如何? 是力压群雄,还是黯然失色?那些备受人类推崇的静态类型系统,在 AI 面前是否成了累赘?

本文和大家一起阅读和拆解这份报告,为你揭晓 AI 时代的语言偏好图谱。

实验设计:让 AI 写一个 Mini-Git

在评价这份报告之前,我们先来看看它的实验设计,这是目前业内少见的、针对 AI Agent 的工程化能力的量化评估。

任务目标:让 Claude Code (Opus 4.6) 从零开始实现一个 mini-git(简化版的 Git)。这是一个极具代表性的任务,它包含了文件 I/O、哈希计算、数据结构操作以及命令行接口,足以考验模型对语言生态的综合运用能力。

测试被巧妙地分为两个阶段,模拟了真实的软件生命周期:

  • v1 (新项目构建):实现基础的 init, add, commit 和 log。
  • v2 (特性扩展):在 v1 的基础上,增加 status, diff, checkout, reset, rm, show 等复杂指令。

提示词(Prompt)极其极简:“阅读 SPEC-v1.txt,实现它,并确保 test-v1.sh 测试通过。”这种设计最大程度地减少了人类指令的干预,纯粹考验 AI 代理在闭环环境下的自主编码、调试和测试能力。

参赛选手(13种语言/15种配置)

  • 动态语言:Python, Ruby, JavaScript, Perl, Lua
  • 动态+类型检查器:Python/mypy, Ruby/Steep
  • 静态语言:TypeScript, Go, Rust, C, Java
  • 函数式语言:Scheme (动态), OCaml (静态), Haskell (静态)

每种语言配置运行 20 次,以消除 LLM 生成的随机性带来的误差,并统计其耗时(Time)、成本(Cost,即 Token 消耗)和代码行数(LOC)。

核心发现:动态语言逆袭,Go 位居第二梯队

如果仅看总耗时和总成本(v1 + v2),测试结果呈现出了令人瞩目的阶梯式分布。

第一梯队:Ruby, Python, JavaScript 的绝对统治

在这场 AI 编程竞速中,Ruby(73.1s)、Python(74.6s)和 JavaScript(81.1s)组成了无可争议的第一阵营。

它们不仅生成速度最快、消耗 API 成本最低(均在 $0.40 以下),而且在 20 次测试中表现出了极高的稳定性(标准差极小)。

对于 AI 来说,生成这三种语言的代码就像呼吸一样自然。它们无需繁琐的项目初始化配置(如 Cargo.toml 或 package.json),可以做到“建个文件直接跑”,这种极简的工作流在 v1 阶段(新项目构建)优势极大。

第二梯队:被“强类型”拖慢脚步的 Go 与 Java

现在,来回答大家最关心的问题:Go 表现如何?

答案是:位居第二梯队。Go 的总耗时为 101.6s,平均成本 $0.50。中规中矩。Go 虽然在语法上非常克制,但依然落后于 Python 和 JS 等动态语言。与之类似,Java(115.4s)也因为繁琐的语法结构和强类型约束,留在了这一梯队。

尽管如此,Go 在整个 20 次测试中没有出现一次失败(0 次 fail),这证明了 Go 的编译器在防止 AI 产生“幻觉 Bug”方面,发挥了极其可靠的安全网作用

“后进生”阵营:Rust 与 C 的挣扎

备受人类极客推崇的 Rust(113.7s,且有 2 次失败)和底层的 C(155.8s)在测试中显得步履维艰。

尤为值得注意的是,在总共 600 次的独立运行中,只有 Rust (2次) 和 Haskell (1次) 出现了测试失败(未能最终跑通 Shell 脚本)的情况。这两门语言都以其极高的心智负担和“编译器教你做人”的严格程度而闻名。

这也是将Rust列入“后进生”阵营的主要原因。如果用《飞驰人生》的拉力赛来比喻,Rust 相当于在40站的赛季中,有两站没能完赛!

深度剖析:为什么 AI 更偏爱动态语言?

在传统的工程视角中,“静态类型防止低级 Bug”、“动态语言难以维护”是金科玉律。但在 LLM 驱动的 Agent 开发流中,这个逻辑为何失效了?作者 Yusuke Endoh 提出了几个关键的解释维度。

训练数据的“虹吸效应”

LLM 的能力直接取决于训练语料的规模和质量。Python、JavaScript 和 Ruby 是过去十几年 Web 开发的绝对主流。GitHub 上海量的这三种语言的开源代码、StackOverflow 上的问答,为 Claude Code 提供了极其丰富的“预训练肌肉记忆”。

当 AI 需要实现一个功能时,它在 Python 的隐空间(Latent Space)中寻找最优解的路径,远比在 Haskell 甚至 Rust 中要清晰、笔直得多。

静态类型的“双刃剑”与重构阻力

静态类型系统的初衷是约束人类,防止我们在重构时犯错。但在 AI 的“ Prompt -> 生成 -> 测试报错 -> 思考 -> 再生成”的迭代循环中,严格的类型检查反而成了巨大的“摩擦力”。

  • 编译成本与调试死锁:在 Rust 或 C 中,当 AI 生成的代码出现类型不匹配时,它需要花费大量的 Token 去阅读复杂的编译器报错信息。有时,为了解决一个简单的借用检查器(Borrow Checker)报错,AI 可能会陷入漫长的、无休止的“试错-编译失败”死循环。
  • 重构牵一发而动全身:在 v2 特性扩展阶段,往往需要修改现有的数据结构。对于 Python,AI 只需要在字典里加个 key;而对于 Rust 或 Java,这可能意味着需要重构一系列的 Struct、更新类型签名、甚至修改与之相关的无数个函数的参数声明。这种“爆炸半径”极大地增加了耗时。

“附加类型检查”的巨大损耗

报告中一个非常有意思的对照组是:原生动态语言 vs 附加类型检查器的动态语言。

  • Python (74.6s) vs Python/mypy (125.3s) —— 变慢了 1.6~1.7 倍。
  • Ruby (73.1s) vs Ruby/Steep (186.6s) —— 变慢了 2.0~3.2 倍!

这证明了,迫使 AI 在动态语言中编写严谨的类型注解(Type Annotations),是一项极其昂贵的任务。模型需要耗费额外的算力去推导类型、生成类型声明文件,并且在类型检查器报错时,还要去修复那些在纯动态模式下可能根本不影响运行的“伪 Bug”。

代码量(LOC)的迷思:越短越好吗?

我们通常认为,写得越少,跑得越快。但数据打破了这个迷思。

Haskell 和 OCaml 生成的最终代码行数(224行和 216行)是所有语言中最少的,甚至少于 Python 和 Ruby。然而,它们在生成时间上的表现却排在倒数(Haskell 耗时最长,达 174s)。

这表明,对于 AI 来说,函数式语言那种高度抽象、信息密度极大的代码,生成和推理的成本远高于像 Python、Go 那种稍微啰嗦但逻辑平铺直叙的“大白话”代码。浓缩的未必是精华,对于 LLM 来说,高度浓缩往往意味着更高的生成熵和更高的试错概率。

行业启示:我们需要重新思考 AI 时代的技术栈选型

面对这份详实的基准测试报告,无论你是 CTO 还是普通开发者,都必须开始重新审视未来的技术选型逻辑。

动态语言是快速原型的“绝对王者”

如果你正在启动一个新项目,或者需要用 AI Agent 快速验证一个业务流程,Python 和 TypeScript 是首选(报告中 JavaScript 表现优于 TS,但在实际工程中 TS 的综合权衡更佳)。

不要迷信“大型项目必须一开始就上强类型编译语言”。在需求快速变化的初期,让 AI 用动态语言狂飙突进,是获取业务反馈最高效的手段。

性能王者们的困境:Go 与 Rust 在 AI 时代掉队了吗?

看到测评数据,很多 Gopher 可能会感到失落:难道注重工程严谨性和系统级性能的静态语言,真的在 AI 时代掉队了吗?

结论并非如此悲观。我们需要明确一点:Agent 测评的速度,不等于软件最终运行的速度。

  • 业务试错 vs 基础设施:AI Agent 目前最擅长、也最快速能完成的,是写“胶水逻辑”和“业务 CRUD”。在这些领域,Python 确实快。但当你的系统涉及到高并发、内存精细控制、或者需要打包为轻量级容器部署时,人类依然需要 Go。
  • 容错的底线:在这场 600 次的庞大测试中,只有 Rust 和 Haskell 出现了最终测试失败,而 Go 保持了完美的 100% 成功率。这恰恰说明,Go 在“极度灵活(易幻觉)”与“极度严格(难生成)”之间,找到了一个非常微妙的平衡点。它可能不是 AI 写得最快的,但它一定是 AI 写出来最让人放心的系统级语言。

我们不应期待 AI Agent 能够像写 Python 脚本一样,如德芙般丝滑地生成出一个复杂的 Go 并发系统。但在 AI 给出的初稿之上,Go 语言极佳的可读性和统一的规范,将为人类工程师的最终审查(Code Review)节省巨大的精力。

小结:下一个十年的编程语言,长什么样?

ai-coding-lang-bench 给我们上了生动的一课。它揭示了当前 LLM 的偏好:它们喜欢有海量训练数据的、灵活的、不需要应对死板编译器的语言。

但我们必须认识到,这只是一份基于 2026 年初模型(Claude Opus 4.6)的快照。未来的 AI 编程语言形态,可能会朝着两个方向演进:

  1. AI Native 语言的诞生:抛弃目前设计给人类阅读的语法,出现一种专门为了降低 LLM 生成 Token 成本、且天然抗幻觉的机器中间语言。
  2. 现有静态语言的“Agent 友好化”编译模式:Go 和 Rust 可能会进化出一种特殊的编译模式。在这个模式下,编译器不仅是冷冰冰地报错,还能以结构化的、对 LLM 更友好的方式提供“修复建议”,从而大幅缩短 Agent 修复编译错误的反馈回路。

无论如何,浪潮已经来临。在 AI 主导代码生成的新时代,我们评价一门编程语言的标准,正在从“它对人类大脑是否友好”,悄然转变为“它对大模型推理是否友好”

而在这场新赛道上,动态语言们,已经抢跑了。

本文核心数据与图表均来源于 GitHub 项目 mame/ai-coding-lang-bench


你的 AI 编程初体验

看完这个排名,你是感到意外,还是早已感同身受?在你日常使用 AI 编程时,你觉得它写哪种语言最让你省心?你是否也曾为了修一个 AI 写的编译错误而陷入“死循环”?

欢迎在评论区分享你的“AI 协作”红黑榜!


“语言的严格性正在变成 AI 的摩擦力?在 AI 时代,掌握一套能驱动 Agent 自动化、自修复的‘工作流’比死磕语法更重要。我的新专栏 AI原生开发工作流实战 将教你如何利用 Claude Code 结合 Spec 驱动开发,构建真正高产出的‘软件工厂’。”

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

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


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

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

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

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

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


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

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

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

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

img{512x368}


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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言进阶课 AI原生开发工作流实战 Go语言精进之路1 Go语言精进之路2 Go语言第一课 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com
这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats