Go / Golang 专题：从入门到云原生生产的极致指南 on PlumePHP

Plumego Best Practices · 一个真实业务（用户中心）的完整示例

Mon, 29 Dec 2025 12:30:00 +0800

0. 这份示例解决什么问题

你已经有了 Plumego，但真正把它用进“用户中心”这种业务时，通常会卡在三件事：

模块边界：User / Auth / Project 怎么拆，拆完怎么组装，才不会越写越乱。
请求与错误模型：统一 JSON 输出、统一错误码、统一 trace/request id，把“可观察性”内建进骨架。
鉴权：最小可用、可扩展、可替换（未来可接 JWT / OAuth / SSO），但现在就能跑通。

Plumego 的定位是“标准库内的 Go HTTP 工具箱”，用 core.App 组合能力，而不是把你锁死在某种框架范式里。
你会看到本文的写法更接近 Birdor 的工程风格：少魔法、强边界、可演进。

一个真实业务（用户中心）的完整 Plumego 示例

Mon, 29 Dec 2025 12:00:00 +0800

目标与边界

你将得到一个可运行的用户中心（User Center）最小实现，覆盖：

注册：POST /api/auth/register
登录：POST /api/auth/login
刷新：POST /api/auth/refresh
当前用户：GET /api/me
更新资料：PUT /api/me
管理端用户：GET /api/admin/users（RBAC：admin 角色）

实现策略（Birdor 风格）：

Plumego Roadmap

Mon, 29 Dec 2025 11:30:00 +0800

状态说明

Plumego 的定位：完全基于 Go 标准库、零外部依赖、强调简单优雅与可组合。
本文为一份“可执行”的路线图提案，面向：

核心贡献者：明确优先级、版本节奏、退出/回滚策略
使用者：明确当前适用边界、未来能力方向、升级成本预期
生态建设：示例工程、文档、规范与工具链的逐步完善

路线图原则（Birdor 风格）

稳定优先：先把现有 API 固定，再扩展能力；避免频繁破坏性变更。
最小抽象：只抽象“不可避免的变化点”（store、auth、ws、codec、logger）。
显式组合：中间件、组件、模块装配应尽量显式，便于审计与调试。
性能与观测内建：默认提供 request-id/trace、结构化日志、recover。
示例驱动：每个核心能力必须配套“真实业务示例”（例如 user center）。

版本策略

v0.x：快速迭代期，允许小范围破坏性调整（但必须提供迁移说明）。
v1.0：API 稳定承诺（SemVer），破坏性变更进入 v2.0。
发布节奏：每 6–10 周一个 minor，每 2–4 周一个 patch（视缺陷密度）。

Roadmap 总览（2026）

下面按季度给出里程碑；后期将映射到 GitHub Milestones / Projects。

Plumego Docs 信息架构（IA）总览

Mon, 29 Dec 2025 11:00:00 +0800

定位：工程级框架文档，而不是教程集合

docs/
├── _index.md
├── intro/
├── getting-started/
├── concepts/
├── architecture/
├── core/
├── guides/
├── patterns/
├── advanced/
├── reference/
├── faq/
├── roadmap/
└── contributing/

下面逐层解释每一部分为什么存在、解决什么问题。

Plumego Best Practices

Mon, 29 Dec 2025 10:30:00 +0800

写在前面：这不是“技巧合集”

这份文档不是：

API 参数的穷举说明
所有功能的使用手册
为了“写得高级”而复杂化的套路

它是一份 工程级 Best Practices，核心目标只有一个：

让一个 Plumego 项目在 1～3 年后依然清晰、可控、可演进。

Plumego 入门：一个克制而清晰的 Go 服务框架

Mon, 29 Dec 2025 10:00:01 +0800

引言：为什么需要 Plumego？

在 Birdor 的工程实践中，我们反复遇到同一个问题：

当项目从“能跑”进入“要长期维护”阶段，Go Web 框架往往开始成为负担，而不是助力。

Plumego 的目标并不是“更快写完第一个接口”，而是帮助你在 6 个月、12 个月甚至 3 年后，依然能够清晰地理解、演进和重构你的服务。

什么时候不该使用 Plumego

Sun, 28 Dec 2025 07:30:00 +0800

引言：一个负责任的框架，必须明确“不适用场景”

任何一个认真对待工程质量的框架，都必须敢于回答一个问题：

在什么情况下，你不应该使用我？

如果一个框架声称：

适合所有团队
适合所有阶段
适合所有业务

那么它几乎可以确定是不可信的。

Plumego vs 常见 Go 框架：设计取舍说明

Sun, 28 Dec 2025 00:36:00 +0800

引言：框架对比，本质是在对比价值观

在技术社区中，“A 框架 vs B 框架”的讨论几乎从未停止。

但真正成熟的工程师往往知道：

框架之争，很少是技术对错，更多是价值取舍。

Plumego 并不是在一个“空白市场”中诞生的。
相反，它是在 Go 生态已经非常繁荣 的前提下，刻意选择了一条看起来“不讨巧”的道路。

Plumego：一个回归 Go 本质的极简服务框架

Sun, 28 Dec 2025 00:28:00 +0800

前言：为什么还要再做一个 Go 框架

在 Go 生态已经高度成熟的今天，“再做一个 Go Web 框架” 看起来既多余，又无趣。

我们已经有了：

功能极其完备、社区庞大的全栈式框架
极致性能导向、偏底层的 HTTP / RPC 框架
面向云原生、与 Kubernetes 深度绑定的应用运行时
为微服务量身定制的一整套工程体系

Plumego 并不是要和它们竞争。

Go 学习路线图：从入门到专家

Sat, 20 Dec 2025 10:00:00 +0800

Go 学习路线图：从入门到专家

朋友，恭喜你走到了这里。

这是本系列的第 100 篇文章，也是最后一篇。从 2020 年的第一篇《Go 语言开发环境搭建》开始，我们一起走过了五年多的旅程——从 Hello World 到 Kubernetes Operator，从变量声明到领域驱动设计，从 goroutine 初体验到 OpenTelemetry 全链路追踪。这 100 篇文章覆盖了 Go 语言的方方面面，但"学完"和"学会"之间，还隔着一条叫做"体系化"的鸿沟。

Go 2025 入门专题目录：从能写小程序到能维护小服务

Thu, 18 Dec 2025 10:16:00 +0800

2025 年这一组 Go 入门文章已经从零散技巧慢慢长成了一个专题库。单篇文章适合解决一个具体问题：怎么解析表单、怎么写 WaitGroup、怎么生成安全 Token、怎么做优雅关闭。但读者第一次打开时，未必知道应该先看哪一篇，也不容易判断哪些内容属于同一条学习线。

Go 入门：用 text/template 生成一份朴素报表

Fri, 05 Dec 2025 17:21:00 +0800

不是所有输出都需要 HTML。很多内部工具会生成纯文本日报、邮件正文、Markdown 摘要、配置片段或工单说明。直接用 fmt.Fprintf 拼字符串可以起步，但字段一多，换行和缩进就会变得难维护。Go 标准库的 text/template 很适合这类场景。

Go 入门：WaitGroup 不只等待，还要收好结果

Thu, 13 Nov 2025 09:49:00 +0800

sync.WaitGroup 是 Go 并发入门必学工具。它的职责很简单：等一组 goroutine 做完。但真实代码里，等待只是第一步。你还要拿到每个任务的结果、处理错误、控制并发数量，并保证 channel 正确关闭。很多初学者会写出“能等完，但结果偶尔丢失或死锁”的代码。

Go 并发 map 入门：mutex、sync.Map 和单 goroutine 管理

Tue, 28 Oct 2025 17:33:00 +0800

Go 的 map 很好用，但普通 map 不是并发安全的。多个 goroutine 同时读写同一个 map，可能触发 fatal error: concurrent map writes，也可能产生数据竞争。初学者常常在 HTTP handler、缓存、在线用户列表里踩到这个问题。

Go 表单解析入门：FormValue、ParseForm 和 PostForm 怎么选

Thu, 16 Oct 2025 19:31:00 +0800

不是所有 Web 请求都是 JSON。登录页、搜索框、后台表单、文件上传仍然会用表单。Go 标准库对表单解析支持很好，但几个 API 容易混：FormValue、PostFormValue、ParseForm、ParseMultipartForm。本文用登录表单讲清楚基本用法。

Go 代码审查指南：从检查清单到团队协作

Sun, 12 Oct 2025 12:00:00 +0800

Go 代码审查指南：从检查清单到团队协作

代码审查是软件开发流程中至关重要的环节，它不仅能发现潜在的 bug 和设计问题，还能促进团队知识共享、提升代码质量、统一编码规范。对于 Go 语言项目而言，良好的代码审查流程更是确保代码简洁、高效、可维护的关键。

Go 领域错误入门：errors.Is 和 errors.As 如何服务业务判断

Tue, 07 Oct 2025 11:47:00 +0800

Go 的 error 很简单，但业务系统里的错误并不简单：订单不存在、库存不足、余额不够、状态不允许、外部支付超时。这些错误需要被上层判断，映射成 HTTP 状态码、用户提示、重试策略。只靠字符串比较会非常脆弱。

Go TLS 客户端证书入门：什么时候需要 mTLS

Thu, 25 Sep 2025 10:26:00 +0800

普通 HTTPS 里，客户端验证服务器证书，确认自己连的是正确服务。mTLS，也就是双向 TLS，还要求客户端提供证书，服务器也验证客户端身份。内部服务调用、企业网关、支付接口、某些高安全 API 都可能要求客户端证书。

Go 入门：用 net/netip 处理 IP 地址更省心

Wed, 24 Sep 2025 15:33:00 +0800

处理 IP 地址时，很多旧代码会使用 net.IP。它能用，但类型是 []byte，可变、比较不方便，也容易在 IPv4 和 IPv6 之间绕晕。Go 1.18 引入了 net/netip，提供了更现代的 Addr 和 Prefix 类型。对新代码来说，优先学 netip 会更省心。

Go build tags 入门：为不同环境编译不同文件

Fri, 12 Sep 2025 10:09:00 +0800

Go 的 build tags 可以让某些文件只在指定构建条件下参与编译。它常用于平台差异、可选功能、集成测试和少量环境差异。初学者可能会把它当成配置系统使用，这是要谨慎的。build tags 是编译期选择，不是运行时配置。

Go embed 模板布局入门：base、partial 和页面模板怎么组织

Tue, 09 Sep 2025 15:18:00 +0800

Go 的 html/template 可以渲染页面，embed 可以把模板打进二进制。小型后台、内部工具、邮件预览页都很适合这种组合。问题是模板一多，如何组织 base layout、partial 和具体页面？如果随便 ParseGlob，很快会乱。

Go 反模式：常见陷阱与最佳实践

Sat, 30 Aug 2025 15:40:00 +0800

Go 反模式：常见陷阱与最佳实践

你是否遇到过这样的代码：一个函数返回 (T, error)，调用方却写了一堆 if err != nil { return err } 把错误直接吞掉；一个 Service 接口塞了 20 个方法，谁都不敢改；满屏 go func() 却没有等待机制，主进程退出时一堆 goroutine 还在后台游荡；为了"性能"手动拼字符串，结果 benchmark 一跑比 strings.Builder 慢 10 倍。

Go 内存限制入门：GOMEMLIMIT、GOGC 和容器里的服务

Thu, 21 Aug 2025 10:36:00 +0800

Go 有自动垃圾回收，但这不表示内存可以不管。容器里部署服务时，如果内存持续上涨，最终可能被 OOM kill。初学者常见误解是：只要没有内存泄漏，Go 会自动处理。现实是，GC 有策略，程序有峰值，容器有上限，你需要知道基本参数。

Go expvar 入门：给小服务加几个轻量指标

Wed, 20 Aug 2025 15:27:00 +0800

很多小服务一开始没有完整监控系统，但也需要知道一些基本状态：请求数、错误数、队列长度、缓存命中次数。Go 标准库里的 expvar 可以用很低成本暴露 JSON 指标。它不替代 Prometheus 这类监控体系，但很适合入门理解“服务应该给外界看哪些状态”。

Go 工作目录入门：为什么本地能读到文件，部署后却找不到

Thu, 07 Aug 2025 17:03:00 +0800

“本地能跑，部署后找不到文件”是 Go 初学者常见问题。代码里写了 templates/index.html，本地从项目根目录运行没事；部署成 systemd 服务后，工作目录变了，程序就报 open templates/index.html: no such file or directory。问题不在 Go 编译，而在当前工作目录。

Go 入门：随机数别乱用，Token 要用 crypto/rand

Wed, 06 Aug 2025 13:12:00 +0800

随机数是入门时很容易被低估的主题。抽一个测试样本、打乱列表、模拟掷骰子，用普通伪随机就可以；生成登录 Session、重置密码链接、邮箱验证 Token，就必须使用安全随机。两类需求看起来都叫“随机”，背后的要求完全不同。

Go 入门：用 slog 写可检索的结构化日志

Mon, 28 Jul 2025 08:54:00 +0800

日志不是程序最后随手加的一行 fmt.Println。线上排查问题时，日志经常是第一证据：哪个用户触发了请求、参数是什么、调用下游花了多久、错误发生在哪一层。纯文本日志能看，但不方便检索。结构化日志把关键信息放到字段里，日志平台可以按字段过滤、聚合和统计。

Go 数据库迁移：goose、golang-migrate 与最佳实践

Fri, 25 Jul 2025 08:30:00 +0800

Go 数据库迁移：goose、golang-migrate 与最佳实践

你有没有经历过这样的噩梦：凌晨两点上线新版本，代码部署成功了，结果打开页面一片空白——因为数据库少了一个字段。或者更惨，回滚代码后发现数据库结构已经被改得面目全非，数据也丢了。又或者团队协作时，同事 A 加了一个索引，同事 B 删了一张表，合并代码的时候数据库结构已经乱成一锅粥。

Go fs.FS 入门：让文件读取逻辑更容易测试

Wed, 23 Jul 2025 08:39:00 +0800

很多代码会直接 os.ReadFile("config.json")。这很简单，但测试时会依赖真实文件路径。Go 的 io/fs 提供了 fs.FS 接口，可以让函数从“文件系统”读取，而不关心这个文件系统来自磁盘、内存还是 embed。这样文件读取逻辑更容易测试。

Go 文件变化轮询入门：不用依赖也能做简单热加载

Tue, 15 Jul 2025 16:29:00 +0800

监听文件变化常见做法是使用 fsnotify 这类库。但有些小工具不想引入依赖，只需要每隔几秒检查配置文件是否变了。这时轮询修改时间是一个简单可控的方案。它不够实时，但容易理解，也适合入门。

Go 数据库迁移入门：SQL 文件、版本表和上线顺序

Tue, 08 Jul 2025 08:58:00 +0800

数据库表结构不会一开始就设计完。你会新增字段、加索引、拆表、修约束。初学项目常见做法是手工连数据库执行 SQL，短期快，长期危险：谁执行过、执行到哪一步、线上和本地是否一致，都说不清。数据库迁移的目标就是让结构变更有版本、有记录、可重复。

Go 与 Kubernetes：构建自定义 Operator

Fri, 20 Jun 2025 10:45:00 +0800

Go 与 Kubernetes：构建自定义 Operator

你有没有遇到过这样的场景：公司里有一套复杂的中间件，每次部署都需要手动配置一大堆 YAML 文件，稍有不慎就会配错。你心里想，如果 Kubernetes 能"认识"这个中间件，自动帮我管理该多好？

Go JSON 请求校验入门：不用框架也能写清楚规则

Thu, 19 Jun 2025 19:40:00 +0800

写 JSON API 时，校验是绕不开的。字段缺失、字符串太长、枚举值不合法、嵌套数组为空，这些都应该在进入业务逻辑前拦住。很多项目会使用校验库，这没问题；但初学者最好先理解不用框架时规则应该放在哪里、错误怎么组织。

Go 入门：用 time.Ticker 做一个朴素限速器

Wed, 18 Jun 2025 11:27:00 +0800

限速听起来像网关和高并发系统才需要的能力，其实入门项目也经常遇到。比如你要批量同步 5000 个客户资料到第三方 CRM，对方文档写着“每秒最多 5 次请求”。如果你开 50 个 goroutine 一口气打过去，很快就会收到 429，严重时还会被封禁。

Go os/exec 入门：调用外部命令时如何处理超时和输出

Wed, 11 Jun 2025 13:48:00 +0800

Go 程序有时需要调用外部命令：图片转换、压缩文件、调用已有脚本、执行系统工具。标准库的 os/exec 可以做到，但边界要清楚。最重要的是：不要把用户输入拼成 shell 命令；要设置超时；要处理 stdout 和 stderr。

Fyne的UI定制

Tue, 03 Jun 2025 10:44:07 +0800

Fyne 虽然默认的 UI 风格较为“简洁保守”，但它提供了完整的自定义接口（例如 fyne.Theme、自定义 CanvasObject、绘图 API 等），可以实现高度定制的 UI。如果你希望构建更现代、美观、甚至炫酷的界面，以下是 全面提升 Fyne UI 定制能力的技巧与实践：

Go TestMain 入门：为一组测试准备共享环境

Tue, 03 Jun 2025 10:44:00 +0800

大多数 Go 测试只需要普通 TestXxx。但有时一个包里的多组测试需要共享准备工作，比如创建临时目录、启动测试服务器、准备测试数据库连接。TestMain 可以在一个测试包运行前后执行统一逻辑。

Fyne跨平台的最佳实践

Tue, 03 Jun 2025 10:33:15 +0800

Fyne 是一个主打“纯 Go + 原生跨平台 GUI”的框架，因此特别适合开发需要快速部署、小巧轻便、无需额外依赖的跨平台桌面应用。为了最大程度发挥 Fyne 的跨平台优势，以下是 Fyne 跨平台开发的最佳实践，涵盖项目结构、UI设计、打包发布等方面。

Fyne和wails的详细对比

Tue, 03 Jun 2025 10:29:07 +0800

Fyne 和 Wails 是两个用于构建桌面应用的 Go 框架，它们在架构、使用方式、成熟度、生态和社区等方面都有显著差异。以下是对二者的详细对比分析：

架构对比

特性	Fyne	Wails
架构模式	纯 Go 原生 GUI	前端用 Web 技术（HTML/CSS/JS），后端 Go 提供服务
渲染机制	内置渲染引擎（基于 OpenGL）	内嵌浏览器（WebView2, WebKit, etc.）显示网页
平台支持	Windows, macOS, Linux, Android, iOS（实验性）	Windows, macOS, Linux
构建模式	单可执行文件，无需浏览器	前端需构建 Web 项目，最终打包为桌面应用

🌱 成熟度和生态对比

特性	Fyne	Wails
项目启动时间	2018 年	2019 年
最新稳定版本（2025 年）	v2.x，活跃更新中	v2.7+，活跃更新中
成熟度	较成熟，UI 库逐步完善	成熟，适合已有 Web 技术栈
社区活跃度	中等偏上，有官方 Slack 和 GitHub 活跃	高，社区、文档、插件生态活跃
文档完善度	完善，官方有完整 API 文档和教程	非常完善，示例多、教程丰富
插件/生态扩展	比较有限，主要靠官方和社区贡献的组件	丰富，可用所有 JS/HTML/CSS 前端生态
开发体验	类似 Flutter（声明式 GUI）	类似 Electron，但后端是 Go
UI 灵活性	中等，定制成本较高	极高，取决于 Web 前端能力

🖥️ UI 开发体验

特性	Fyne	Wails
UI 构建方式	纯 Go 编写 UI，类似 Flutter	用 Vue, React, Svelte, 甚至原生 HTML/CSS
热重载支持	有限（实验性）	支持前端热重载（例如 Vite）
响应式设计支持	有，基于容器布局	前端框架原生支持响应式
开发效率	中等，UI 设计需理解 Fyne 组件体系	高（前端开发者）、中（Go-only 开发者）
多语言支持	内建 i18n 模块	需前端自己处理（如 Vue-i18n）

性能和资源占用

特性	Fyne	Wails
启动速度	快，轻量运行	略慢（取决于嵌入 Web 引擎）
可执行文件大小	较小（10~20MB）	较大（50MB+，含 Web 引擎）
系统资源占用	少	多（嵌入浏览器内核）
GPU 加速	有 OpenGL 支持	由浏览器内核负责加速

🔒 安全性

特性	Fyne	Wails
攻击面	小，纯 Go 无浏览器漏洞	稍大，需注意前端代码安全、XSS 等
前端资源	编译进可执行文件	前端可嵌入也可从文件系统加载

🛠️ 使用场景推荐

场景	推荐框架
全 Go 项目、对前端技术不熟悉	✅ Fyne
需要跨平台快速构建简单 GUI 工具	✅ Fyne
有 Web 前端团队或项目已有 Web UI	✅ Wails
追求高度定制化 UI、美观交互体验	✅ Wails
构建现代桌面应用（类似 Electron）	✅ Wails
移动端开发需求	🚧 Fyne（实验性支持 Android/iOS）

🧪 实际项目对比建议

项目类型	推荐
内网企业小工具	Fyne（部署方便）
管理后台客户端	Wails（复用已有前端）
面向公众的桌面应用	Wails（现代 UI）
Go 教学/CLI GUI 包装工具	Fyne
高度交互的桌面应用	Wails

📦 示例项目与资源

Fyne 示例：

Go net/url 入门：安全地拼 URL 和查询参数

Tue, 27 May 2025 11:16:00 +0800

很多 HTTP 客户端 bug 都来自手写 URL。用户输入里有空格、斜杠、中文、&、?，一旦直接字符串拼接，就可能生成错误 URL，甚至改变参数含义。Go 标准库的 net/url 可以安全地处理路径和查询参数。

Go 与 WebAssembly：从浏览器到边缘计算

Thu, 22 May 2025 11:00:00 +0800

引言

如果说 Go 语言的"一次编译，到处运行"已经让人印象深刻，那么 WebAssembly（简称 WASM）把这个理念推向了极致——一次编译，任何地方都能运行。浏览器里、Node.js 中、服务器端、IoT 设备、CDN 边缘节点……只要有 WASM 运行时的地方，就有你的代码。

Go 后台任务重试入门：失败后怎么重试才不添乱

Wed, 14 May 2025 11:22:00 +0800

后台任务失败后要不要重试？答案通常是“要，但不能乱重试”。发送通知、同步数据、生成报表、调用第三方接口都可能遇到临时失败。如果完全不重试，偶发抖动会变成用户可见失败；如果无限重试，可能把一个小问题放大成队列堵塞或外部服务雪崩。

Go worker 取消入门：后台循环如何听懂 context

Fri, 09 May 2025 13:37:00 +0800

后台 worker 是 Go 服务里很常见的结构：消费队列、定时清理、同步外部数据、处理导入任务。很多 worker 写起来很简单，但停不下来。服务收到关闭信号后，HTTP server 已经退出，worker 还卡在 sleep、网络请求或 channel receive 上，进程迟迟不结束。

Go 入门：regexp 能做什么，不能替你做什么

Tue, 29 Apr 2025 16:05:00 +0800

正则表达式很容易让人又爱又怕。它写得好，可以快速从文本里找出订单号、清理多余空白、判断一个字段是否像手机号；写得太贪，就会变成没人敢改的一串符号。Go 的 regexp 包使用 RE2 语法，避免了某些语言里灾难性回溯的问题，但这不代表正则可以随便写。

Go HTTP 客户端上传文件入门：multipart 请求怎么构造

Tue, 22 Apr 2025 14:05:00 +0800

前面很多教程会讲服务端如何接收文件上传，但客户端怎么上传也很常见：你的 Go 程序要把图片传给素材服务，把 CSV 传给导入接口，或者把日志包传给诊断系统。这类请求通常使用 multipart/form-data。标准库可以完成，但写法比普通 JSON 请求稍微长一点。

Go 与领域驱动设计：构建复杂业务系统

Fri, 18 Apr 2025 13:30:00 +0800

Go 与领域驱动设计：构建复杂业务系统

你有没有遇到过这样的代码：一个 UserService 里有 3000 行代码，混杂着数据库查询、业务规则校验、发邮件、记录日志……每次改一个小需求都要小心翼翼地测试整个链路。新同事入职看到这种代码，第一反应是"这谁写的？“第二反应是"我也不敢动”。

Go HTTP 服务优雅关闭入门：停止接新请求，等旧请求收尾

Fri, 18 Apr 2025 08:42:00 +0800

HTTP 服务发布或重启时，如果直接杀进程，正在处理的请求可能被中断，用户看到连接错误，后台写入也可能只完成一半。Go 的 http.Server.Shutdown 可以帮助服务优雅关闭：停止接收新连接，等待已有请求完成，直到超时。

Go atomic 计数入门：比 mutex 更适合简单计数的场景

Wed, 09 Apr 2025 15:44:00 +0800

并发计数是 Go 服务里很常见的小需求：请求数、错误数、当前连接数、后台任务数量。用 mutex 可以实现，但对单个整数计数来说，sync/atomic 更轻便。较新的 Go 版本提供了类型化原子值，比如 atomic.Int64，比老式函数更好读。

Go SQL 预编译入门：PrepareContext 什么时候值得用

Thu, 27 Mar 2025 14:26:00 +0800

写 Go 数据库代码时，我们经常用 ExecContext 和 QueryContext 传 SQL 和参数。那 PrepareContext 是做什么的？简单说，它会创建一个预编译语句，后续可以多次执行，适合同一条 SQL 重复执行的场景，比如批量插入、批量更新。

Go sync.Pool 入门：复用临时对象前先看清边界

Wed, 19 Mar 2025 09:22:00 +0800

sync.Pool 经常出现在性能优化文章里。它可以复用临时对象，减少分配压力。比如高频请求里不断创建 bytes.Buffer，可以考虑用 pool 复用。但 sync.Pool 也很容易被滥用：代码复杂了，性能却没明显提升，甚至因为对象没清理干净引入 bug。

Go 入门：CSV 导入导出别只会 strings.Split

Wed, 12 Mar 2025 10:42:00 +0800

CSV 是最不起眼、也最容易出事故的数据格式。运营同事从后台导出一份表，财务系统给你一份结算明细，供应商发来一批商品编码，很多时候都是 CSV。初学者常犯的错误是用 strings.Split(line, ",") 处理。只要字段里出现逗号、换行或双引号，这个办法马上失效。

Go 与 AI：构建智能应用

Mon, 10 Mar 2025 14:20:00 +0800

引言

2025 年，如果你还觉得"AI 是 Python 的事"，那可就大错特错了。诚然，Python 在模型训练和数据科学领域占据统治地位，但当你需要把 AI 能力部署到生产环境、构建高性能的推理服务、或者开发面向用户的 AI 应用时，Go 的优势就凸显出来了：并发能力强、内存占用小、编译成单一二进制、部署简单。

Go context 值入门：请求范围数据可以放，业务参数不要乱塞

Thu, 06 Mar 2025 10:47:00 +0800

context.Context 是 Go 服务开发里绕不开的类型。它主要负责取消、超时和请求范围的数据。前两者很好理解，第三个“请求范围的数据”最容易被滥用。很多初学者会把业务参数、配置、数据库连接甚至 service 都塞进 context，最后代码变得像隐形全局变量。

RoadRunner项目介绍

Mon, 03 Mar 2025 12:50:04 +0800

RoadRunner 项目详细介绍

RoadRunner 是一个用 Golang 编写的高性能应用服务器和进程管理器，主要用于服务 PHP 应用程序，但其架构和插件机制也使得它适用于其它语言和多种应用场景。RoadRunner 的设计初衷是解决传统 PHP 应用在每次请求都要重复初始化环境（如引导文件、依赖注入、框架初始化等）所带来的性能瓶颈问题。借助 RoadRunner，可以将 PHP 应用以常驻进程的方式运行，从而大幅度降低请求响应时间，提高系统吞吐量。

Go HTTP gzip 压缩入门：什么时候压缩响应，什么时候不要压

Mon, 24 Feb 2025 18:05:00 +0800

HTTP 响应压缩是一个常见优化。JSON、HTML、CSS、文本日志这类内容通常能压缩很多，网络传输更省；图片、视频、已经压缩过的 zip 文件再压缩意义不大，还会浪费 CPU。Go 标准库有 compress/gzip，可以写一个简单中间件理解压缩流程。

Grpc Gateway初探

Mon, 24 Feb 2025 11:57:41 +0800

1. 引言

在微服务架构中，gRPC 作为一种高性能、跨语言的远程过程调用（RPC）框架被越来越多的项目采用。gRPC 默认使用 Protocol Buffers 作为数据序列化格式，具有数据紧凑、解析速度快等优点。但在实际生产环境中，我们常常需要同时支持传统的 RESTful API 接口，原因包括兼容历史系统、满足前端或移动端使用 HTTP/JSON 协议等。为此，grpc‑gateway 应运而生，它可以通过极少的额外配置，将 gRPC 服务暴露为标准的 RESTful 接口，从而实现“写一次，跑多端”的目标。

Go JSON 流式响应入门：边查边写，避免一次性占满内存

Tue, 18 Feb 2025 09:51:00 +0800

很多列表接口一开始会把所有数据查出来，放进切片，再 json.NewEncoder(w).Encode(slice)。数据少时没问题，数据一多，内存会飙升，用户也要等全部数据准备好才能收到响应。对于导出类接口，可以考虑流式 JSON 响应：边查、边编码、边写给客户端。

Go1.24发布说明

Mon, 17 Feb 2025 17:03:34 +0800

以下是 Go 1.24 的详细功能和变更说明，结合语言特性、性能优化、标准库改进等核心内容整理而成：

一、语言特性与语法变更

1. 泛型类型别名正式支持

在 Go 1.24 中，带类型参数的泛型类型别名从实验特性转正为默认支持。开发者可以为泛型类型定义别名，简化代码编写：

Go 可观测性：OpenTelemetry 完全指南

Sat, 15 Feb 2025 16:10:00 +0800

Go 可观测性：OpenTelemetry 完全指南

你有没有经历过这样的夜晚：凌晨两点被报警电话叫醒，服务出了故障，但你盯着满屏的日志，完全搞不清楚请求到底经过了哪些服务、在哪个环节出了问题、为什么突然变慢？如果你有微服务架构的经验，这个场景一定不陌生。

Go sync.Once 入门：懒加载资源时只初始化一次

Mon, 10 Feb 2025 16:18:00 +0800

Go 服务里经常有一些资源只需要初始化一次：解析模板、加载规则、创建昂贵对象、读取本地配置。你可以在程序启动时全部准备好，也可以第一次使用时再懒加载。懒加载时最怕并发：多个请求同时进来，发现资源还没初始化，于是重复执行。sync.Once 就是用来保证某段初始化逻辑只执行一次的。

Go 入门：Cookie、Session 和一个简单登录状态

Fri, 07 Feb 2025 14:18:00 +0800

登录状态是 Web 开发绕不开的话题。很多初学者一听到 Session，就会把它想成某种神秘机制。其实从 HTTP 角度看，Cookie 是浏览器保存并自动带回服务端的一小段数据；Session 是服务端用这段数据找到用户状态的一种做法。Cookie 在客户端，Session 数据通常在服务端。

Go http.ServeContent 入门：文件下载、修改时间和断点续传

Tue, 28 Jan 2025 10:12:00 +0800

很多 Go 初学者写文件下载接口时，会直接 os.ReadFile 把文件读进内存，再 w.Write 返回。文件很小时这样能跑，但报表、日志包、图片、压缩文件一大，就会浪费内存，也错过了 HTTP 已经提供的能力：修改时间、Range 请求、缓存协商、内容长度。标准库的 http.ServeContent 正是为这类场景准备的。

Go 入门：用 flag 写一个不慌不忙的命令行配置

Fri, 24 Jan 2025 09:36:00 +0800

很多人第一次写 Go 程序，是从一个 HTTP 服务开始。但在真实团队里，命令行小工具同样常见：清理过期文件、导入一批 CSV、生成报表、检查接口是否可用。小工具看起来简单，最容易写成“先能跑再说”的样子：路径写死在代码里，超时时间散落在函数里，出了错只打印一行“failed”。等这个工具被同事拿去每天跑，问题就来了。

Go 1.25 前瞻：持续进化的 Go 生态

Sat, 18 Jan 2025 09:30:00 +0800

引言

各位 Go 友人们，新年好！2025 年才刚刚开始，Go 社区已经热闹起来了——按照 Go 团队雷打不动的发布节奏，Go 1.25 预计在 2025 年 8 月正式发布。还记得当初 Go 1.18 泛型发布时整个社区的狂欢吗？每半年的版本迭代，Go 都在悄无声息地变强，就像一个低调的武林高手，每次出手都让人眼前一亮。

Go httptest.Server 入门：给 HTTP 客户端写可信测试

Thu, 16 Jan 2025 09:34:00 +0800

很多 Go 初学者会给 HTTP handler 写测试，却不知道怎么给 HTTP 客户端写测试。比如你的服务要调用一个用户中心接口，代码里有 http.Client、URL、请求头和 JSON 解码。测试时不可能真的去调用线上用户中心，也不应该为了单元测试启动一整套依赖。标准库里的 net/http/httptest 提供了一个很实用的工具：httptest.Server。

Go 语言学习路线图：从入门到精通

Wed, 15 Jan 2025 09:00:00 +0800

🗺️ Go 语言学习路线图

欢迎来到 Go 语言的学习之旅！本系列包含 100 篇精心编写的教程文章，涵盖从基础语法到前沿技术的完整知识体系。这份学习路线图将帮助你：

Go 时区处理入门：time.Location、UTC 和用户本地时间

Thu, 09 Jan 2025 11:08:00 +0800

时间处理是后端里最容易“本地没问题，线上出事故”的部分。尤其是预约、提醒、账单、报表这类功能，用户看到的是本地时间，系统存储和计算却最好使用统一时间。Go 的 time 包很强，但初学者如果只会 time.Now() 和 Format，很容易在时区上踩坑。

Go 配置分层入门：默认值、环境变量和启动校验

Thu, 19 Dec 2024 19:04:00 +0800

配置是后端服务里最容易被低估的部分。初学者常常先把端口、数据库地址、超时时间写死在代码里，等部署到不同环境时再匆忙改成环境变量。结果是默认值散落各处，启动时不校验，线上才发现某个配置拼错了。

Go 小项目发布前检查清单：从能跑到敢交付

Thu, 12 Dec 2024 17:02:00 +0800

能跑和敢交付之间还有一段路

很多 Go 小项目写到最后，go run . 能跑，接口也能返回结果，于是就想直接上线或交给别人使用。可是真正交付前，还应该做一轮基础检查：测试是否通过，代码是否格式化，构建是否可复现，配置是否清楚，日志是否足够，外部调用是否有超时，错误是否会泄露敏感信息，README 是否告诉别人怎么运行。

Go 项目实战：从零构建完整的 Web 应用

Fri, 15 Nov 2024 10:00:00 +0800

Go 项目实战：从零构建完整的 Web 应用

学了这么多 Go 的理论和零散的知识点，是时候来一个完整的项目实战了。今天，我们将从零开始构建一个真实的项目——在线任务管理系统（TaskMaster）。

Go 轻量分层入门：Handler、Service、Store 怎么刚刚好

Tue, 05 Nov 2024 10:44:00 +0800

分层不是为了画图好看

Go 项目写到一定规模后，总会遇到一个问题：HTTP handler 里东西越来越多。它既解析 JSON，又校验参数，又查数据库，又拼响应，还打日志。短期写得快，长期很难改。于是很多人开始学习“Clean Architecture”“DDD”“六边形架构”。这些思想有价值，但入门项目照搬全套目录，很容易过度设计。

Go 测试替身入门：用小接口写出容易测试的业务代码

Thu, 24 Oct 2024 09:46:00 +0800

很多初学者一听到“单元测试”，就想到 mock 框架。其实 Go 里最常用、最舒服的测试替身，往往只是一个小结构体。你定义一个刚好够用的小接口，测试里手写 fake 或 spy，就能验证业务逻辑，而不用真的发邮件、调支付或连外部 API。

Go 日志脱敏入门：不要把密码、Token 和身份证写进日志

Thu, 17 Oct 2024 11:28:00 +0800

日志是排查问题的基础，但日志也很容易泄露敏感信息。密码、验证码、session ID、访问 token、身份证号、银行卡号、完整手机号，如果进入日志系统，就可能被更多人看到，也很难彻底删除。初学者常见错误是为了调试方便，把整个请求体或结构体直接打印出来。

Go 黄金文件测试入门：适合输出很长的文本和 JSON

Tue, 08 Oct 2024 10:12:00 +0800

有些函数的输出很长，比如生成 Markdown、渲染配置文件、格式化 JSON、生成 SQL。你当然可以在测试里写一个很长的字符串常量，但测试文件会变得难读。黄金文件测试，也叫 golden file test，就是把期望输出放在单独文件里，测试时读取文件并比较。

Go 与区块链：从概念到实现

Mon, 30 Sep 2024 12:00:00 +0800

Go 与区块链：从概念到实现

区块链，这个听起来很神秘的技术，其实核心思想非常简单：去中心化的、不可篡改的数据账本。你可能听说过比特币、以太坊，但你知道区块链的底层原理吗？

Go HTTP 中间件入门：日志、恢复、鉴权和请求 ID 怎么串起来

Fri, 27 Sep 2024 18:31:00 +0800

中间件本质上是在包装 Handler

Go 的 HTTP handler 是：

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

中间件就是接收一个 handler，返回一个新的 handler。新 handler 可以在调用原 handler 前后做事情，比如记录日志、恢复 panic、检查登录状态、加请求 ID、统计耗时、设置响应头。

Golang1.23版本功能说明

Tue, 24 Sep 2024 10:37:42 +0800

主要更新内容

Go 1.23 版本带来了许多新特性和改进，以下是一些重点更新：

用户定义的迭代器：Go 1.23 支持了用户定义的迭代器，这意味着你可以创建自定义的迭代行为。例如，你可以使用 func(func(K) bool) 这样的函数来定义一个迭代器，这为处理任意序列提供了可能。

下面是一个简单的例子，展示了如何定义一个迭代器，并在 for 循环中使用它。在这个例子中，我们定义了一个 IntIterator 类型，它有一个 Next 方法。

Go 泛型集合入门：自己写 Set 和 Stack 时要注意什么

Wed, 18 Sep 2024 15:52:00 +0800

Go 有了泛型以后，很多人第一反应是写集合库。虽然实际项目里不要急着造大而全的数据结构库，但写一个小 Set 和 Stack 很适合理解泛型：类型参数怎么写，comparable 是什么，方法接收者怎么设计，零值能不能直接用。

Go 部分更新 API 入门：区分未提交、空值和清空字段

Thu, 05 Sep 2024 17:19:00 +0800

创建接口比较简单，用户提交什么就创建什么。更新接口尤其是部分更新，会遇到一个麻烦问题：字段没提交、提交空字符串、提交 null，这三件事含义可能不同。比如昵称没提交表示不改，提交空字符串表示设置为空字符串，提交 null 表示清空昵称。

Go 1.23 迭代器入门：range over func 能解决什么问题

Fri, 30 Aug 2024 15:33:00 +0800

Go 1.23 让 range 可以遍历函数形式的迭代器。对初学者来说，这个特性第一眼可能有点陌生：既然我们已经能遍历切片、map、channel，为什么还需要遍历函数？答案通常和“惰性生成”和“避免一次性装进内存”有关。

Go GC 调优实战：从理论到实践

Sun, 25 Aug 2024 15:40:00 +0800

Go GC 调优实战：从理论到实践

你有没有遇到过这样的场景：你的 Go 服务跑着跑着，CPU 突然飙高，响应延迟抖动明显，过了几十毫秒又恢复正常？恭喜你，你遇到了 GC pause。

Go slices 和 maps 包入门：少写一点重复集合代码

Mon, 19 Aug 2024 09:15:00 +0800

集合工具终于进入标准库

Go 早期处理切片和 map 时，经常要自己写一些小工具函数：克隆切片、判断相等、删除元素、提取 map 的 key、排序。后来随着泛型进入语言，标准库也逐步提供了 slices 和 maps 这类集合辅助包。它们不会把 Go 变成链式集合语言，但能减少很多重复样板代码。

Go 信号处理入门：让 CLI 和服务收到 Ctrl+C 后体面退出

Wed, 14 Aug 2024 11:09:00 +0800

你在终端里按 Ctrl+C，程序会收到中断信号。如果程序只是立刻退出，可能会留下半写入文件、未完成请求、没有关闭的连接。对小脚本来说这不一定严重，但对长期运行的服务、消费者、同步工具来说，体面退出很重要。

Go 配置热重载入门：哪些配置能重载，哪些不该重载

Tue, 06 Aug 2024 09:43:00 +0800

配置热重载听起来很诱人：不用重启服务，改配置就生效。但不是所有配置都适合热重载。日志级别、开关、限流阈值通常可以；数据库连接地址、监听端口、加密密钥就要谨慎。入门阶段最重要的是先划清边界。

Go语言优秀资源整理

Thu, 01 Aug 2024 14:59:39 +0800

go-awesome

Go 语言优秀资源整理，为项目落地加速🏃

在 GitHub 上稳定更新，觉得不错请点个 Star ❤️

如转载分享，请保留出处，谢谢 😆

原文地址: https://shockerli.net/post/go-awesome

GitHub: https://github.com/shockerli/go-awesome

官网: https://golang.org

国内官网镜像(访问快): https://golang.google.cn

GitHub: https://github.com/golang/go

适合新手入门的Golang开源项目推荐

Fri, 26 Jul 2024 11:54:31 +0800

用golang实现一个并发爬虫

Wed, 24 Jul 2024 22:53:23 +0800

在Go语言中实现一个并发爬虫，可以使用标准库中的net/http包来发送HTTP请求，使用golang.org/x/net/html包来解析HTML，以及使用sync包中的WaitGroup来同步并发的goroutines。下面是一个简单的并发爬虫示例，它会并发地访问网页，并打印出网页中的所有链接。

Golang进阶教程

Tue, 23 Jul 2024 20:27:55 +0800

Go 语言进阶教程将涵盖一些高级主题和最佳实践，这些是超越基础语法和常规用法的。以下是一些进阶主题的详细介绍：

1. 接口（Interfaces）

接口在 Go 中是一种强大的方式来实现多态和动态派发。接口是一个定义了一组方法的类型。

如何使用Go实现生产者-消费者模式

Tue, 23 Jul 2024 18:18:11 +0800

在 Go 语言中，使用 channels 实现生产者-消费者模式是一种常见的并发编程模式。生产者负责生成数据，消费者负责处理数据。通过 channels，生产者和消费者可以安全地交换数据。

Go语言中的并发模型简介

Tue, 23 Jul 2024 18:15:08 +0800

Go 语言的并发模型主要基于 goroutines 和 channels。下面我将分别解释它们是如何工作的，并提供一个简单的例子。

1. Goroutines

Goroutines 是 Go 语言实现并发的核心。它们是 Go 程序中轻量级的执行线程，由 Go 运行时管理。Goroutine 的调度是由 Go 运行时进行的，与操作系统的线程调度是分开的。

Golang快速入门

Tue, 23 Jul 2024 13:16:38 +0800

Go 语言（通常称为 Golang）是一种开源编程语言，由 Google 的 Robert Griesemer、Rob Pike 和 Ken Thompson 在 2007 年设计并开发。它以简洁、高效、性能优异而著称，特别适合用于构建大型软件系统、网络服务和并发程序。

Golang学习路线参考

Tue, 23 Jul 2024 13:11:46 +0800

Go 语言（Golang）是一种静态类型、编译型语言，设计上注重简洁和高效，非常适合用来构建大型软件系统。以下是一份详细的 Go 语言学习路线：

2025 Go 入门专题入口

如果你希望按具体场景学习标准库和工程实践，可以先打开这份专题目录：Go 2025 入门专题目录：从能写小程序到能维护小服务。它把 2025 年的 Go 入门文章按基础工具、HTTP、数据文件、并发、测试、安全网络、观测部署等方向整理成阅读路径，适合在掌握基础语法后继续系统练习。

Go channel 流水线入门：生产、处理、取消和关闭怎么配合

Mon, 22 Jul 2024 08:49:00 +0800

channel 是 Go 很有代表性的特性，但很多初学者会把它写成“能跑就行”的并发代码：谁关闭 channel 不清楚，错误怎么返回不清楚，取消后 goroutine 会不会退出也不清楚。短期看只是偶尔卡住，长期看就是 goroutine 泄漏和线上不稳定。

Go 与消息队列：Kafka 和 RabbitMQ 实战

Sat, 20 Jul 2024 13:30:00 +0800

Go 与消息队列：Kafka 和 RabbitMQ 实战

凌晨三点，你的电商系统正在做促销活动。突然，订单量暴增 10 倍。数据库扛不住了，CPU 飙到 100%，订单服务开始超时，支付回调丢失，库存扣减不一致……整个系统像多米诺骨牌一样倒下了。

Go 内存缓存入门：TTL、并发安全和清理策略

Tue, 16 Jul 2024 16:07:00 +0800

不是所有缓存都需要 Redis。很多小型服务只想把低频变化的配置、字典表、权限规则在进程内缓存几分钟，减少数据库查询。Go 里写一个简单内存缓存并不难，但要注意并发安全、过期时间和清理策略。

Go 构建版本信息入门：把 commit、版本号和构建时间写进程序

Tue, 09 Jul 2024 14:28:00 +0800

程序上线后，最常见的排查问题之一是：现在跑的到底是哪一个版本？代码仓库里修了 bug，不代表服务器已经部署了。镜像构建成功，不代表线上实例都更新了。把版本号、Git commit 和构建时间写进程序，是一个很小但很有用的习惯。

Go 分页 API 入门：limit、cursor 和稳定排序

Thu, 27 Jun 2024 13:25:00 +0800

列表接口一开始很容易写成“查全部”。数据少时没问题，数据变多后就会慢、占内存，还会让前端一次拿到太多无用数据。分页是 API 的基本功。Go 写分页不难，难的是把参数校验、排序稳定性和响应结构设计清楚。

Go context 取消原因入门：让超时和主动取消更容易排查

Fri, 21 Jun 2024 08:57:00 +0800

取消不只是停止，还要知道为什么停止

Go 的 context.Context 常用于请求范围控制：客户端断开，请求超时，后台任务停止，外部调用取消。早期我们通常只能通过 ctx.Err() 知道是 context.Canceled 还是 context.DeadlineExceeded。这已经有用，但在复杂服务里，有时还想知道更具体的原因：是用户主动取消，还是权限检查失败后取消后续任务，还是上游熔断导致停止。

Go 文件上传入门：限制大小、校验类型和安全保存

Tue, 18 Jun 2024 18:26:00 +0800

文件上传看起来只是接收一个 multipart 表单，但真正写到服务里，会遇到不少边界：用户上传超大文件怎么办，文件名里带路径怎么办，扩展名能不能信，保存失败如何处理，旧文件要不要删除。初学者最容易写出能跑但不安全的代码。

Go 1.24 新特性：持续进化的 Go

Mon, 10 Jun 2024 11:00:00 +0800

Go 1.24 新特性：持续进化的 Go

2024 年 8 月，Go 1.24 正式发布。这是 Go 语言诞生 15 年来的又一个"稳步前行"的版本。

如果说 Go 1.23 的迭代器是"重大突破"，那 Go 1.24 就是"精雕细琢"。这个版本没有改变语言的核心语法，但在标准库、性能、工具链方面做了大量改进。weak 包的引入让弱引用终于有了官方支持，net/http 的增强让标准库的路由能力更上一层楼，PGO 的成熟让性能优化变得更加自动化。

Go 邮件模板入门：把验证码和通知邮件渲染清楚

Mon, 03 Jun 2024 10:31:00 +0800

邮件模板听起来像前端工作，但后端经常要负责生成验证码、邀请链接、账单通知和任务提醒。很多初学项目一开始直接用 fmt.Sprintf 拼 HTML，写到第二封邮件时就会变得难维护。Go 的 html/template 很适合渲染 HTML 邮件，因为它会自动转义用户数据。

Go 密码重置 Token 入门：随机数、过期时间和一次性使用

Tue, 28 May 2024 08:52:00 +0800

找回密码看起来是一个普通功能：用户输入邮箱，系统发送链接，用户点开后设置新密码。真正实现时，最关键的是 token。它必须足够随机，不能长期有效，最好一次性使用，数据库里也不应该明文保存。

Go database/sql 上下文入门：QueryContext、超时和连接释放

Thu, 23 May 2024 11:21:00 +0800

database/sql 是 Go 标准库里非常重要的包。它的 API 看起来不复杂，但初学者常常在几个地方踩坑：查询没有超时、忘记关闭 Rows、把 context.Background() 写在仓储层、扫描错误处理不完整。短期看只是代码能不能跑，长期看会影响连接池、请求取消和线上稳定性。

Go 模糊测试入门：让工具帮你发现边界输入

Thu, 16 May 2024 11:33:00 +0800

有些 bug 不是你能手写用例想到的

普通单元测试依赖我们自己列举输入。表驱动测试已经能覆盖很多边界，但面对解析器、编码转换、路径处理、压缩数据、模板变量、协议字段这类函数，人很难穷尽所有奇怪输入。模糊测试的思路是：你写出基本性质和种子用例，让工具不断生成新输入，尝试触发 panic、越界、死循环或违反性质的结果。

Go 与微服务：服务发现与注册实战

Sun, 12 May 2024 10:45:00 +0800

Go 与微服务：服务发现与注册实战

想象一下这样的场景：你的电商系统从单体架构拆成了 20 个微服务。用户服务、订单服务、支付服务、库存服务……它们分布在不同的服务器上，IP 地址随时可能变化（容器重启、自动扩缩容）。这时候问题来了：订单服务怎么知道支付服务的地址？

Go CSV 导入入门：逐行读取、校验和错误报告

Fri, 10 May 2024 17:45:00 +0800

CSV 导入是很多后台系统都会遇到的功能。用户从表格软件导出一份文件，上传到系统里批量创建用户、商品或订单。Go 标准库的 encoding/csv 能完成大部分基础工作，但真正难的是边界：表头不对怎么办，某一行邮箱为空怎么办，转换失败怎么告诉用户，文件很大时能不能逐行处理。

Go 结构化错误入门：错误码、包装和 HTTP 映射

Mon, 29 Apr 2024 08:39:00 +0800

Go 的错误处理很直接：函数返回 error，调用方检查它。但项目变大后，如果所有错误都只是 fmt.Errorf("bad request")，HTTP 层就很难判断该返回 400、404 还是 500；日志里也很难分清用户错误和系统错误。结构化错误的目标不是复杂化，而是让错误携带稳定语义。

Go 工作区入门：用 go work 同时开发多个本地模块

Wed, 24 Apr 2024 16:19:00 +0800

多模块本地联调不一定要改 go.mod

很多团队会把通用库和业务服务放在不同仓库或不同模块里。比如你正在开发 user-api，它依赖本地的 kit 模块。以前常见做法是在 user-api/go.mod 里写 replace：

replace example.com/kit => ../kit

这能工作，但如果你不小心把个人本地路径提交了，其他同事可能无法构建。go work 提供了另一种方式：在本地创建工作区，把多个模块临时组合起来开发，而不必修改每个模块的 go.mod。

Go 与 GraphQL：构建灵活的 API

Thu, 18 Apr 2024 08:30:00 +0800

Go 与 GraphQL：构建灵活的 API

你用过 REST API 吗？肯定用过。但你有没有遇到过这样的场景：前端需要用户信息、用户的订单列表、以及每个订单的商品详情。用 REST 的话，你可能需要调用 /users/123、/users/123/orders、然后对每个订单再调用 /orders/456/products。这就是经典的 N+1 请求问题。

Go 临时文件入门：os.CreateTemp、MkdirTemp 和清理责任

Wed, 17 Apr 2024 18:40:00 +0800

临时文件经常出现在后端任务里：下载一个文件后解析，生成报表后上传，图片转换时落盘，或者调用某个只接受文件路径的外部工具。很多初学者会手写 /tmp/demo.txt，这在并发和安全上都不稳。Go 标准库提供了 os.CreateTemp 和 os.MkdirTemp，应该优先使用它们。

Go 超时和重试入门：context、退避和幂等性一起看

Thu, 11 Apr 2024 14:08:00 +0800

写后端服务时，外部调用失败是常态。网络会抖，依赖会慢，网关会返回 502，数据库也可能短暂不可用。初学者最容易写出两种极端代码：一种完全不重试，偶发错误直接暴露给用户；另一种无脑重试很多次，把一个小抖动放大成更大的压力。正确做法不是“永远重试”或“永不重试”，而是把超时、退避和幂等性一起考虑。

Go JSON API 入门：Handler、请求解析和统一响应怎么组织

Tue, 26 Mar 2024 09:37:00 +0800

Go 标准库写 JSON API 并不难，难的是写到第十个接口时还能保持清楚。很多初学项目一开始把所有逻辑塞进 handler：解析 JSON、校验字段、查数据库、拼响应、写错误。前两个接口还行，接口多了以后，错误格式不统一，测试也不好写。

Go io.Pipe 入门：边生成边上传的流式处理

Mon, 18 Mar 2024 10:57:00 +0800

很多导出功能会先把全部数据生成到内存或临时文件，再上传到对象存储。数据少时没问题，数据大时就会占用很多内存或磁盘。Go 的 io.Pipe 可以把写入端和读取端连接起来：一边生成，一边被另一边读取，适合流式处理。

Go 1.23 回顾：迭代器与新标准库

Fri, 15 Mar 2024 14:20:00 +0800

Go 1.23 回顾：迭代器与新标准库

如果说 Go 1.18 的泛型是"众望所归"，那 Go 1.23 的迭代器就是"姗姗来迟"。

2024 年 8 月，Go 1.23 正式发布。这个版本最引人注目的特性，莫过于 range over function（即迭代器模式）的全面开放。除此之外，unique 包、time 的改进、slices 和 maps 包的新方法，以及持续的性能优化，都让这个版本值得一探究竟。

Go ServeMux 路由入门：用标准库写更清楚的 HTTP 路由

Tue, 12 Mar 2024 09:42:00 +0800

标准库路由也能写得很舒服

很长一段时间里，很多人写 Go Web 服务会直接选择 Gin、Echo、Chi 这类框架。它们当然好用，但标准库 net/http 也一直在进步。现代 Go 的 ServeMux 已经能表达更清楚的路由模式，包括 HTTP 方法和路径参数。对于小型 JSON API、内部工具和学习项目，标准库完全可以胜任。

Go 限流入门：用令牌桶保护一个 HTTP 接口

Thu, 07 Mar 2024 20:17:00 +0800

限流不是大公司才需要的功能。一个公开表单、一个登录接口、一个 AI 调用入口，如果没有任何限制，很容易被误用、刷爆或拖垮下游依赖。对 Go 初学者来说，限流最值得先理解的是“保护边界”：限制请求进入系统的速度，而不是等数据库或外部服务扛不住后再处理错误。

构建现代 CLI 工具：cobra 框架完全指南

Wed, 28 Feb 2024 16:10:00 +0800

构建现代 CLI 工具：cobra 框架完全指南

你有没有用过 kubectl、hugo、docker 这些命令行工具？它们的用户体验堪称一流：清晰的帮助信息、自动补全、子命令嵌套、丰富的标志参数……每次使用都感觉丝滑得不可思议。你有没有想过，这些工具是怎么做到的？

Go slog 入门：用结构化日志记录更清楚的服务行为

Tue, 27 Feb 2024 15:08:00 +0800

日志从字符串变成结构

传统日志经常这样写：

log.Printf("user %d login failed: %v", userID, err)

它能看，但机器不太好解析。后来很多服务会输出 JSON 日志，字段里有 level、time、user_id、path、duration_ms。这样日志平台可以按字段搜索、聚合和告警。Go 标准库里的 log/slog 就是为了结构化日志提供统一接口。

Go singleflight 思路入门：避免缓存击穿时重复查询

Wed, 21 Feb 2024 09:18:00 +0800

缓存能减轻数据库压力，但缓存失效那一刻也可能制造压力。比如热门用户资料过期，突然来了 200 个请求，如果每个请求都发现缓存没有，然后同时查数据库，数据库会被瞬间打满。这类问题常被称为缓存击穿。

Go HTML 模板安全入门：自动转义、模板函数和页面渲染边界

Fri, 16 Feb 2024 16:42:00 +0800

很多人第一次用 Go 写 Web 页面，会在 text/template 和 html/template 之间犹豫。两个包 API 很像，名字也很像，但用途不一样。只要输出的是 HTML 页面，通常就应该使用 html/template。它最重要的能力是自动上下文转义：用户输入出现在 HTML 文本、属性、JavaScript 或 URL 位置时，模板引擎会按位置做不同处理，降低 XSS 风险。

Go Cookie 和 Session 入门：登录态到底放在哪里

Thu, 08 Feb 2024 13:56:00 +0800

做 Web 应用时，登录态是绕不开的话题。很多初学者会问：用户登录后，是不是把用户 ID 放到 Cookie 里？Session 和 Cookie 有什么区别？退出登录时要删什么？这些问题看似简单，但如果边界没想清楚，很容易留下安全隐患。

Go 1.22 循环变量入门：为什么子测试和 goroutine 更不容易踩坑了

Mon, 29 Jan 2024 10:18:00 +0800

Go 里有一个经典坑：在循环里启动 goroutine，或者在表驱动测试里写 t.Run，最后所有闭包都拿到了同一个循环变量。很多老 Go 程序员都会下意识写一行 tt := tt，这行代码看起来有点奇怪，但它曾经非常重要。到了 Go 1.22，循环变量的语义发生了调整，很多这类问题会自然消失。

Go httptrace 入门：看清一次 HTTP 请求慢在哪里

Thu, 25 Jan 2024 15:36:00 +0800

写 Go 服务时，调用外部接口慢是很常见的问题。日志里只看到“请求花了 2 秒”，但这 2 秒到底花在哪里？是 DNS 慢、建立连接慢、TLS 握手慢、服务端处理慢，还是响应体下载慢？如果只能靠猜，排查会很痛苦。

Go 1.22 新特性：range over integers 和 math/rand/v2

Sat, 20 Jan 2024 09:30:00 +0800

Go 1.22 新特性：range over integers 和 math/rand/v2

2024 年 2 月，Go 1.22 正式发布。这是 Go 语言进入第 15 个年头后的第一份"新年礼物"。

如果你以为这又是一个"修修 bug、调调性能"的小版本，那你可能会大吃一惊。Go 1.22 带来了几个让社区讨论热烈的改动——for range 终于支持整数了，math/rand 终于有了 v2 版本，net/http.ServeMux 终于能按 HTTP Method 路由了。

Go 泛型入门：从重复函数到类型参数的自然过渡

Thu, 18 Jan 2024 10:26:00 +0800

泛型不是为了把所有代码都写成抽象

Go 很长时间没有泛型，所以早期 Go 代码大量依赖具体类型、小接口、函数参数和适度重复。后来 Go 加入类型参数后，很多重复工具函数终于可以写得更自然，比如 Contains、Map、Filter、Set 这类集合操作。但泛型并不意味着所有代码都应该泛型化。

Go HTTP Basic Auth 入门：用中间件保护内部页面

Thu, 11 Jan 2024 09:24:00 +0800

很多小型 Go 服务都有一个内部页面：查看任务队列、触发一次同步、检查缓存状态。它不一定值得接入完整登录系统，但也不能裸奔在公网。HTTP Basic Auth 是一个简单选择。浏览器会弹出用户名密码框，请求头里带上凭据，服务端验证后再允许访问。

2023 年 Go 语言年度回顾与展望

Wed, 20 Dec 2023 10:00:00 +0800

2023 年 Go 语言年度回顾与展望

2023 年是 Go 语言发展历程中非常重要的一年。从 2009 年开源至今，Go 已经走过了 14 个年头。这一年，Go 发布了两个重要版本（1.20 和 1.21），生态系统持续壮大，社区活跃度再创新高。

Go 配置校验入门：让服务启动时就发现问题

Thu, 07 Dec 2023 09:26:00 +0800

配置错误应该在启动时暴露

很多线上问题不是代码逻辑错，而是配置错：端口写错，数据库地址为空，第三方 API URL 少了协议，生产环境打开了调试开关，超时时间是 0。最糟糕的情况是服务启动成功，直到请求进来才暴露配置问题。

Go 子测试组织入门：表驱动、t.Run 和测试命名怎么写

Mon, 04 Dec 2023 14:27:00 +0800

Go 的测试工具很朴素，没有复杂的断言 DSL，也没有必须学习一整套框架的压力。你只要创建一个 xxx_test.go 文件，写一个 func TestXxx(t *testing.T)，再运行 go test，就已经能开始了。也正因为它朴素，很多初学者会在项目变大后遇到另一个问题：测试越写越散，失败信息不清楚，新增一个场景要复制一段函数，最后大家都不太愿意补测试。

Go Worker 队列入门：用 channel 和 context 处理后台任务

Fri, 20 Oct 2023 15:39:00 +0800

后台任务不应该都塞在 HTTP 请求里

很多 Web 服务会遇到一些不适合在请求里同步完成的事情：发送邮件、生成报表、处理图片、同步第三方数据、写审计日志。简单项目里，你可能先在 handler 里直接调用这些逻辑，但请求会变慢，也更容易受外部系统影响。

Go 基准测试和分配入门：用 -benchmem 看清楚优化是否值得

Fri, 13 Oct 2023 09:44:00 +0800

刚开始写 Go 的时候，很多人会把“性能优化”理解成一种直觉游戏：我觉得这个写法少了一层函数调用，应该更快；我觉得这个循环里用了 append，应该会慢；我觉得字符串拼接换成 strings.Builder，一定更专业。直觉有时候能帮你发现问题，但它不能替代测量。尤其在 Go 里，编译器、逃逸分析、运行时分配器都在悄悄做事，很多看上去“聪明”的写法，实际效果可能很小，甚至更差。

Go 安全编程：防范常见漏洞

Thu, 12 Oct 2023 15:40:00 +0800

Go 安全编程：防范常见漏洞

安全是软件开发中最容易被忽视，却又最重要的环节。你可能写出功能完美、性能卓越的代码，但只要一个安全漏洞，就可能让整个系统崩溃，甚至导致用户数据泄露。

Go 1.21 工具链管理入门：go.mod 里的 go 和 toolchain 怎么理解

Thu, 14 Sep 2023 18:08:00 +0800

为什么同一个项目在不同机器上表现不一样

Go 项目通常从 go.mod 开始。你可能早就见过这一行：

go 1.21

很多初学者会把它理解成“必须用 Go 1.21 才能构建”。这个理解有一部分对，但不完整。go 指令描述的是模块使用的 Go 语言版本语义和模块行为。到了 Go 1.21，工具链管理也变得更明确，toolchain 指令开始进入一些项目的 go.mod。

Go 1.23 迭代器：range over func 的革命

Tue, 05 Sep 2023 11:00:00 +0800

Go 1.23 迭代器：range over func 的革命

Go 语言有一件事一直让人又爱又恨：for range 循环。

爱它是因为它简洁、安全、没有 C 语言那种 for (int i = 0; i < n; i++) 的啰嗦；恨它是因为它能遍历的东西太少了——数组、切片、map、字符串、channel，就这几样。

Go CLI 子命令入门：用 flag.FlagSet 写清楚的命令行工具

Mon, 28 Aug 2023 20:22:00 +0800

一个命令变多后，main 很容易乱

Go 很适合写命令行工具。最开始你可能只有一个参数：

todo -file tasks.json

后来需求变成：

todo add -title "学习 Go"
todo list
todo done -id 1

这时如果还把所有参数都塞进全局 flag，main.go 会很快变乱。标准库 flag.FlagSet 可以为每个子命令单独解析参数。你不一定要马上引入 Cobra 这类库，小工具用标准库就能组织得很清楚。

Go SQL 事务入门：把转账、订单和库存写得更可靠

Fri, 11 Aug 2023 10:52:00 +0800

事务保护的是一组必须一起成功的动作

数据库事务的核心不是“高级数据库功能”，而是一个很朴素的需求：几步操作要么全部成功，要么全部失败。转账时，从 A 扣钱和给 B 加钱必须一起发生；创建订单时，写订单和扣库存也必须保持一致。如果前一步成功，后一步失败，就会留下脏数据。

Go 项目结构：构建可维护的大型项目

Tue, 25 Jul 2023 13:15:00 +0800

Go 项目结构：构建可维护的大型项目

你是否遇到过这样的场景：打开一个 Go 项目，看到所有代码都堆在 main.go 里，或者目录结构混乱得像一盘意大利面？随着项目规模增长，这种混乱的结构会让你每次修改代码都像是在拆炸弹——稍有不慎就会引发连锁反应。

Go 数据库 NULL 值入门：sql.NullString、指针和业务语义

Fri, 14 Jul 2023 09:12:00 +0800

NULL 不是空字符串，也不是 0

数据库里经常会有 NULL。用户昵称可能未设置，文章发布时间可能为空，订单取消时间可能不存在。Go 里字符串零值是 ""，整数零值是 0，时间零值是 time.Time{}。这些零值和数据库 NULL 不是一回事。把 NULL 粗暴扫进普通字段，轻则报错，重则丢失业务语义。

Go 测试覆盖率入门：数字之外更重要的是关键路径

Wed, 28 Jun 2023 15:17:00 +0800

覆盖率是信号，不是目标本身

Go 自带测试覆盖率工具。你可以很容易知道哪些代码被测试执行过，哪些没有。这对补测试很有帮助，但覆盖率数字本身并不等于质量。80% 覆盖率可能没有测到最关键的支付路径，40% 覆盖率也可能把核心业务规则保护得很好。

Go 1.21 泛型增强：cmp 包与内置 min/max

Thu, 15 Jun 2023 09:30:00 +0800

Go 1.21 泛型增强：cmp 包与内置 min/max

Go 1.18 引入泛型后，社区反响热烈，但也伴随着一些疑问：“泛型是好东西，但标准库什么时候能用上？”

Go HTTP 客户端中间件入门：给外部调用加日志、重试和请求 ID

Fri, 09 Jun 2023 10:48:00 +0800

客户端也需要中间件

我们经常给 HTTP 服务端写中间件：请求日志、鉴权、恢复 panic、请求 ID。其实 HTTP 客户端也有类似需求。调用外部 API 时，你可能希望统一加 User-Agent、加请求 ID、记录耗时、对 502/503 做有限重试。Go 标准库通过 http.RoundTripper 支持这种扩展。

Go HTTP ResponseController 入门：更明确地控制响应写入

Thu, 25 May 2023 10:31:00 +0800

有些响应不是一次写完的

大多数 HTTP handler 都是一次性返回 JSON：

json.NewEncoder(w).Encode(response)

但有些场景需要更细的控制：服务端持续推送日志，下载大文件时分块写入，长任务边执行边返回进度，或者你希望主动 flush 已写内容。Go 的 net/http 里有 ResponseController，它把一些响应控制能力以更明确的方式暴露出来。

Go 测试进阶：从单元测试到基准测试

Thu, 18 May 2023 08:30:00 +0800

Go 测试进阶：从单元测试到基准测试

“我的代码能跑就行，测试是浪费时间。”

这句话我听过无数次。每次听到，我都想把这个人的手机拿过来，翻翻他的 Git 提交历史——我敢打赌，里面一定有不少 fix bug、fix again、really fix this time 这样的提交信息。

Go JSON 流式处理入门：不用一次把大文件读进内存

Wed, 17 May 2023 15:13:00 +0800

大 JSON 不应该总是 ReadAll

很多入门代码会这样解析 JSON：

data, err := io.ReadAll(r)
if err != nil {
	return err
}

var users []User
if err := json.Unmarshal(data, &users); err != nil {
	return err
}

小数据没问题，但如果请求体或文件很大，这会一次性把所有内容读进内存。导入几万行用户、处理日志导出、读取大数组时，更好的方式是使用 json.Decoder 流式处理。它可以从 io.Reader 一边读一边解码，不必先把全部数据变成 []byte。

Go 1.21 集合操作三剑客：cmp、slices 与 maps 标准库实战

Sat, 22 Apr 2023 14:20:00 +0800

Go 1.21 集合操作三剑客：cmp、slices 与 maps 标准库实战

如果你写过足够多的 Go 代码，那么下面这些场景你一定不陌生：

// 检查 slice 是否包含某元素 —— 又是一个 5 行的 for 循环
found := false
for _, v := range names {
 if v == "Alice" {
 found = true
 break
 }
}

// 获取 map 的所有 key —— 又是一个 5 行的 for 循环
keys := make([]string, 0, len(m))
for k := range m {
 keys = append(keys, k)
}

// 求 slice 的最小值 —— 又是一个 5 行的 for 循环
min := numbers[0]
for _, v := range numbers[1:] {
 if v < min {
 min = v
 }
}

这些"样板代码"就像每个 Go 开发者都必须缴纳的"语法税"。每交一次，代码就啰嗦一点；每交一次，项目里就多出一堆长得几乎一模一样的辅助函数。

Go 1.21 slices、maps 和 cmp 入门：集合工具终于标准化

Tue, 18 Apr 2023 16:06:00 +0800

很多小工具终于不用自己写

Go 早期处理切片和 map 时，经常要自己写辅助函数：判断切片是否包含元素、克隆切片、比较切片、复制 map、按字段排序。每个项目都会有一组差不多的 utils。Go 1.21 把 slices、maps、cmp 等包带进标准库，让这些常见集合操作更统一。

Go pprof 入门：给 HTTP 服务找 CPU 和内存热点

Mon, 03 Apr 2023 09:20:00 +0800

性能问题要靠数据，不靠感觉

服务慢了以后，很多人第一反应是猜：是不是 JSON 慢？是不是数据库慢？是不是某个循环太多？猜测可以提供方向，但真正优化前要有证据。Go 的 pprof 可以帮助你看到 CPU 时间花在哪里、内存分配集中在哪里、goroutine 是否堆积。

Go 1.21 slog 入门：不用第三方库也能写结构化日志

Thu, 30 Mar 2023 09:42:00 +0800

日志最好能被机器读懂

过去很多 Go 小项目使用标准库 log：

log.Printf("user %d login failed: %v", userID, err)

这种日志给人看没问题，但给日志系统分析不够方便。如果你想按 user_id 搜索，按 status 聚合，按 duration_ms 排序，结构化日志会更好。Go 1.21 引入了标准库 log/slog，让结构化日志成为标准能力。

Go 1.21 slog：标准库的结构化日志

Fri, 10 Mar 2023 10:45:00 +0800

Go 1.21 slog：标准库的结构化日志

日志，是每个后端工程师绕不开的话题。你可能用过 logrus、zap、zerolog 这些第三方库，也可能还在用标准库的 log 包拼接字符串。不管怎样，Go 1.21 给你带来了一个"迟到但正确"的礼物——log/slog 包。

Go 竞态检测入门：用 -race 找出并发读写问题

Wed, 08 Mar 2023 11:27:00 +0800

并发 bug 最怕偶尔出现

Go 写并发很方便，go func() 一启动就是一个 goroutine。但多个 goroutine 同时读写同一份数据时，如果没有同步，就会产生数据竞争。数据竞争的麻烦在于它不一定每次都出错。你本地跑十次正常，线上高并发时偶尔错一次，排查成本很高。

HTTP 服务器模式：从入门到生产

Tue, 28 Feb 2023 16:10:00 +0800

HTTP 服务器模式：从入门到生产

“我的 HTTP 服务器能跑就行了，为什么要搞那么多花样？”

如果你还在用 http.ListenAndServe(":8080", mux) 一行代码打天下，那你一定还没经历过这些场景：

Go 1.20 context 取消原因入门：让并发任务知道为什么停下

Tue, 21 Feb 2023 14:05:00 +0800

取消任务时，只知道 canceled 有时不够

context.Context 是 Go 并发和服务端代码里非常核心的工具。它可以传递超时、取消信号和请求范围数据。以前我们通常通过 ctx.Err() 判断 context 为什么结束，常见结果是 context.Canceled 或 context.DeadlineExceeded。这对很多场景已经够用，但在复杂任务里，有时你还想知道更具体的原因。

Go embed 入门：把模板和静态文件打进二进制

Fri, 10 Feb 2023 19:35:00 +0800

为什么要把资源打进二进制

Go 程序发布时常常是一个二进制文件，这很方便。但只要你的程序依赖模板、CSS、默认配置、SQL 迁移脚本或静态图片，发布就不再只是复制一个文件。你需要保证资源目录也在正确位置，工作目录也正确。很多“小工具在我机器上能跑，复制到服务器就找不到模板”的问题都来自这里。

Go HTTP 服务超时入门：ReadTimeout、WriteTimeout 和请求上下文

Fri, 27 Jan 2023 10:16:00 +0800

没有超时的服务很容易被慢请求拖住

很多 Go 入门 HTTP 服务都是这样启动的：

log.Fatal(http.ListenAndServe(":8080", mux))

这段代码能跑，但它没有显式配置超时。开发环境里看不出问题，到了真实网络环境就可能遇到慢客户端、半开连接、上传请求迟迟不结束、响应写不出去等情况。一个服务如果没有基本超时保护，就可能被少量异常连接占住资源。

Go 1.20 新特性：让错误处理更优雅

Wed, 18 Jan 2023 09:30:00 +0800

Go 1.20 新特性：让错误处理更优雅

2023 年 2 月，Go 1.20 正式发布。虽然不像 1.18 那样引入了泛型这样的重大特性，但 1.20 在错误处理、类型转换和性能方面带来了许多实用的改进。

Go 1.20 多错误处理入门：errors.Join 怎么用才自然

Mon, 16 Jan 2023 09:18:00 +0800

一个操作可能不只产生一个错误

Go 代码里最常见的错误处理方式是返回一个 error。这很清楚：函数成功返回 nil，失败返回错误。可是有些场景并不只有一个失败点。比如导入 CSV 时，100 行里有 5 行格式错误；关闭多个资源时，文件关闭失败，网络连接关闭也失败；并发执行多个任务时，几个任务都返回了错误。过去很多代码会只返回第一个错误，或者手写一个 []error，再把它格式化成字符串。

错误处理的高级技巧：从基础到企业级

Thu, 15 Dec 2022 13:40:00 +0800

错误处理的高级技巧：从基础到企业级

Go 的错误处理以其简洁性著称，但简洁不等于简单。在实际项目中，我们需要处理复杂的错误场景：错误包装、错误链、错误分类、错误监控等。

本文将带你从基础的错误处理进阶到企业级的错误处理策略。

Go 小服务可观测性入门：日志、指标和健康检查先做到位

Fri, 09 Dec 2022 17:04:00 +0800

小服务也需要知道自己发生了什么

可观测性听起来像大系统话题，容易让初学者联想到复杂的指标平台、分布式追踪和日志集群。其实对一个 Go 小服务来说，最基础的可观测性很朴素：服务是否还活着？请求进来了多少？哪些请求失败？外部调用耗时多久？启动时用了什么配置？

Go 泛型切片工具入门：自己写 Filter、Map 和 Reduce

Thu, 06 Oct 2022 09:37:00 +0800

从切片工具函数学习泛型最自然

Go 1.18 有了泛型后，最容易上手的练习就是切片工具函数。因为切片处理在业务代码里非常常见：过滤活跃用户、提取 ID、计算总金额、把数据库结果转成响应结构体。过去这些函数要么针对具体类型写，要么使用 interface{} 损失类型安全。泛型让它们变得更自然。

Go any 和 interface{} 入门：新名字背后的老概念

Thu, 18 Aug 2022 15:46:00 +0800

any 只是 interface{} 的别名

Go 1.18 引入泛型时，也引入了一个新预声明标识符：any。很多初学者会以为它是新类型，其实它只是：

type any = interface{}

也就是说，any 和 interface{} 完全等价。它的出现主要是为了让泛型代码更易读：

Go 1.19：稳定中求进步

Fri, 05 Aug 2022 10:20:00 +0800

Go 1.19：稳定中求进步

2022 年 8 月，Go 1.19 正式发布。虽然不像 1.18 那样引入了泛型这样的重大特性，但 1.19 在稳定性、性能和开发体验方面做了大量改进。

这篇文章带你了解 Go 1.19 的重要变化。

Go atomic 入门：什么时候需要原子计数，什么时候该用锁

Wed, 27 Jul 2022 11:09:00 +0800

并发计数不是 count++ 那么简单

多个 goroutine 同时修改一个变量时，普通 count++ 不是安全操作。它看起来是一行，实际包含读取、加一、写回多个步骤。两个 goroutine 交错执行时，更新可能丢失。Go 的 race detector 也会报告数据竞争。

Channel 模式：掌握 Go 并发编程的精髓

Fri, 08 Jul 2022 16:20:00 +0800

Channel 模式：掌握 Go 并发编程的精髓

Go 语言的 Channel 是并发编程的核心，但仅仅知道如何创建和使用 Channel 是不够的。掌握各种 Channel 模式（Channel Patterns）才能让你写出优雅、高效、可维护的并发程序。

原子操作：无锁并发编程的艺术

Sat, 18 Jun 2022 14:30:00 +0800

原子操作：无锁并发编程的艺术

在并发编程中，我们经常需要保护共享数据。传统的做法是使用互斥锁（mutex），但锁会带来性能开销和死锁风险。原子操作提供了一种无锁的替代方案，在某些场景下性能更优。

Go 构建信息入门：在程序里查看版本、依赖和构建来源

Tue, 14 Jun 2022 18:21:00 +0800

线上运行的到底是哪一版

当用户反馈问题时，第一件事往往不是看代码，而是确认版本。你以为线上跑的是刚发布的二进制，实际可能是旧版本；你以为某个依赖已经升级，实际构建产物里还是旧依赖。Go 程序可以读取自身构建信息，这对命令行工具、HTTP 服务和排查问题都很有用。

Go TLS 和 HTTP 客户端安全入门：证书、超时和最小信任边界

Sun, 22 May 2022 10:47:00 +0800

HTTPS 不是把 URL 改成 https 就结束

Go 调用外部 API 很方便，一个 http.Client 就能请求 HTTPS 服务。标准库默认会验证服务端证书，这对大多数场景是正确的。但在真实开发中，你可能遇到自签名证书、内网服务、测试环境证书过期、域名不匹配等问题。最危险的解决方式是随手写 InsecureSkipVerify: true，让证书验证完全失效。

逃逸分析：理解 Go 的内存分配策略

Thu, 12 May 2022 09:15:00 +0800

逃逸分析：理解 Go 的内存分配策略

在 Go 中，你不需要像 C/C++ 那样手动管理内存，但这并不意味着你可以忽视内存分配。理解逃逸分析（Escape Analysis）对于编写高性能的 Go 代码至关重要。

Go netip 入门：更清楚地处理 IP 地址和网段

Fri, 29 Apr 2022 16:12:00 +0800

IP 地址不只是字符串

很多 Web 服务都会遇到 IP 处理：记录客户端 IP、判断内网地址、做白名单、解析 CIDR 网段、限制管理后台来源。初学时你可能会把 IP 当成字符串处理，比如 strings.HasPrefix(ip, "192.168.")。这种写法很脆弱，遇到 IPv6、前导格式、网段判断时很容易错。

Go 1.18 any 类型：告别 interface{} 的冗长

Sun, 10 Apr 2022 11:15:00 +0800

Go 1.18 any 类型：告别 interface{} 的冗长

Go 1.18 引入了一个简单但意义重大的改进：any 类型。它是 interface{} 的内置别名，让代码更加简洁易读。

虽然只是一个小的语法改进，但它体现了 Go 团队对开发者体验的持续关注。

性能分析实战：pprof 从入门到精通

Fri, 25 Mar 2022 14:30:00 +0800

性能分析实战：pprof 从入门到精通

当你的 Go 程序运行缓慢或内存占用过高时，你需要一个强大的工具来找出问题所在。pprof 是 Go 标准库提供的性能分析工具，它能帮你精确定位 CPU、内存、Goroutine 等性能瓶颈。

Go 1.18 Fuzz 测试：发现隐藏 Bug 的利器

Fri, 25 Mar 2022 09:20:00 +0800

Go 1.18 Fuzz 测试：发现隐藏 Bug 的利器

Go 1.18 引入了一个令人兴奋的新特性：Fuzz 测试（模糊测试）。这是一种自动化的软件测试技术，通过生成大量随机输入来发现程序中的隐藏 Bug。

Go 工作区入门：go work 如何解决本地多模块联调

Thu, 17 Mar 2022 09:55:00 +0800

多个模块一起改时，go.mod 不一定要被污染

Go Modules 解决了单个项目依赖管理问题，但当你同时开发多个本地模块时，仍然会遇到麻烦。比如 user-api 依赖 company-kit，你现在要同时修改两边。过去常见做法是在 user-api/go.mod 里写：

Go 模糊测试基础流程：从一个字符串解析函数开始

Wed, 23 Feb 2022 14:38:00 +0800

模糊测试适合找你没想到的输入

普通测试需要我们自己写输入和预期。表驱动测试已经很强，但它仍然依赖人的想象力。解析函数、路径处理、编码转换、协议拆包这类代码，输入空间很大，你很难手写覆盖所有奇怪情况。模糊测试的思路是：你给工具一些种子样本和一个必须保持的性质，让工具不断生成新输入，尝试触发 panic 或违反性质。

Go Workspaces：多模块开发的利器

Sun, 20 Feb 2022 14:45:00 +0800

Go Workspaces：多模块开发的利器

在大型项目中，我们经常需要同时开发多个相互依赖的 Go 模块。在 Go 1.18 之前，这需要使用 replace 指令，非常繁琐。Go 1.18 引入的 workspace 模式彻底解决了这个问题。

Go 1.18 泛型初体验：先从三个小函数开始理解

Wed, 19 Jan 2022 09:24:00 +0800

为什么 2022 年大家都在讨论泛型

如果你在 2022 年学习 Go，很难绕开一个话题：Go 1.18 带来了泛型。对很多从 Java、C#、TypeScript 转过来的人来说，泛型并不陌生；但对长期写 Go 的人来说，这是语言风格里一次很重要的变化。过去 Go 社区习惯用具体类型、小接口、代码生成和适度重复来解决复用问题。泛型出现后，一些集合类和算法类代码终于可以写得更自然。

Go 1.18 泛型：期待十年的类型参数

Sat, 15 Jan 2022 10:30:00 +0800

Go 1.18 泛型：期待十年的类型参数

2022 年 3 月，Go 1.18 正式发布，这是 Go 语言诞生以来最重要的一次更新——泛型（Generics）终于来了！

从 2010 年社区开始讨论泛型，到 2022 年正式落地，整整 12 年的时间。这期间，Go 团队尝试了无数种方案，最终选择了"类型参数"（Type Parameters）这个设计。

性能优化实战：让你的 Go 应用飞起来

Sat, 29 May 2021 10:00:00 +0800

性能优化实战：让你的 Go 应用飞起来

Go 语言本身性能优秀，但不当的编码方式仍会导致性能问题。本文将介绍如何通过分析和优化，让你的 Go 应用达到最佳性能。

性能优化原则

在开始优化之前，记住以下原则：

分布式追踪：跨服务调用链路分析

Wed, 26 May 2021 16:30:00 +0800

分布式追踪：跨服务调用链路分析

在微服务架构中，一个用户请求可能经过多个服务。当出现问题时，如何快速定位是哪个环节出了问题？分布式追踪就是解决这个问题的利器。

本文将介绍如何使用 OpenTelemetry 实现分布式追踪。

Prometheus 监控：让你的应用可观测

Sun, 23 May 2021 09:45:00 +0800

Prometheus 监控：让你的应用可观测

在生产环境中，了解应用的运行状态至关重要。Prometheus 是一个开源的监控系统，配合 Grafana 可以实现强大的指标收集和可视化。

数据库事务：保证数据一致性的关键

Thu, 20 May 2021 14:15:00 +0800

数据库事务：保证数据一致性的关键

在数据库操作中，我们经常需要执行多个相关的操作，这些操作要么全部成功，要么全部失败。事务（Transaction）就是用来保证这种原子性的机制。

gRPC 基础：构建高性能微服务通信

Mon, 17 May 2021 11:30:00 +0800

gRPC 基础：构建高性能微服务通信

在微服务架构中，服务间通信是关键。RESTful API 虽然流行，但在性能、类型安全和代码生成方面存在局限。gRPC 作为 Google 开源的高性能 RPC 框架，提供了更优的解决方案。

Redis 集成：高性能缓存与数据存储

Fri, 14 May 2021 16:20:00 +0800

Redis 集成：高性能缓存与数据存储

Redis 是一个高性能的内存数据库，广泛用于缓存、会话存储、消息队列等场景。在 Go 应用中集成 Redis，可以显著提升系统性能和响应速度。

JWT 身份验证：构建安全的 API 认证系统

Tue, 11 May 2021 13:45:00 +0800

JWT 身份验证：构建安全的 API 认证系统

在构建现代 Web API 时，身份验证是不可或缺的一环。传统的 Session 认证方式在分布式系统中面临诸多挑战，而 JWT（JSON Web Token）提供了一种优雅、无状态的解决方案。

WebSocket 实时通信：构建交互式应用

Sat, 08 May 2021 10:30:00 +0800

WebSocket 实时通信：构建交互式应用

传统的 HTTP 请求-响应模型无法满足实时应用的需求。想象一下聊天室、股票行情、在线游戏这些场景，客户端需要即时收到服务器的消息，而不是不断轮询。

RESTful API 设计：构建优雅的 Web 接口

Wed, 05 May 2021 14:20:00 +0800

RESTful API 设计：构建优雅的 Web 接口

在当今的软件开发中，API（应用程序接口）已经成为连接不同系统和服务的桥梁。RESTful API 因其简单性、灵活性和可扩展性，成为了最流行的 API 设计风格之一。

中间件模式：构建灵活的 Web 应用

Sun, 02 May 2021 09:15:00 +0800

中间件模式：构建灵活的 Web 应用

在 Web 开发中，有很多横切关注点（cross-cutting concerns）需要在每个请求中处理：日志记录、身份验证、权限检查、请求限流、CORS 处理等等。如果把这些逻辑都写在每个 handler 里，代码会变得冗余且难以维护。

项目架构：构建可维护的 Go 应用

Wed, 28 Apr 2021 10:50:00 +0800

项目架构：构建可维护的 Go 应用

当你的 Go 项目从几十行代码的小工具，成长为成千上万行代码的大型应用时，一个清晰的项目架构就变得至关重要了。

好的架构能让代码：

易于理解：新人能快速找到相关代码
易于测试：各层职责清晰，便于单元测试
易于维护：修改一处不会影响其他部分
易于扩展：新功能可以无缝集成

今天我们就来学习如何设计和组织一个可维护的 Go 项目。

Go 最佳实践：写出优雅的 Go 代码

Mon, 26 Apr 2021 16:10:00 +0800

Go 最佳实践：写出优雅的 Go 代码

学习一门语言不仅仅是掌握语法，更重要的是理解这门语言的设计哲学和最佳实践。Go 语言有其独特的风格和约定，遵循这些实践能帮你写出更清晰、更健壮、更易维护的代码。

设计模式：Go 语言中的实践

Sun, 25 Apr 2021 14:28:00 +0800

设计模式：Go 语言中的实践

设计模式是软件开发中经过验证的解决方案。它们不是具体的代码，而是一种思路，帮助你解决特定场景下的常见问题。

但是，不同的语言有不同的特性，设计模式的实现方式也会有所不同。Go 语言没有类、继承、泛型（1.18 之前），这让很多传统的面向对象设计模式需要"Go 化"。

性能分析：pprof 和 trace 工具

Thu, 22 Apr 2021 14:20:00 +0800

性能分析：pprof 和 trace 工具

“我的程序很慢”——这是开发者最常遇到的问题之一。但"慢"是一个模糊的描述，真正的瓶颈在哪里？是 CPU 计算太慢？是内存分配太多？是 I/O 等待太久？还是锁竞争太严重？

Docker 部署：让你的应用随处运行

Thu, 22 Apr 2021 09:55:00 +0800

Docker 部署：让你的应用随处运行

“在我的机器上能跑啊！"——这大概是开发者说过最多的一句话了。

不同的开发环境、不同的依赖版本、不同的操作系统……这些问题让应用的部署变得复杂而痛苦。Docker 的出现彻底改变了这一局面：把你的应用和它的所有依赖打包成一个容器，在任何地方都能以相同的方式运行。

信号处理：让你的应用优雅地退出

Mon, 19 Apr 2021 16:05:00 +0800

信号处理：让你的应用优雅地退出

你有没有遇到过这样的情况：

你的 Web 服务器正在处理请求，突然被 Ctrl+C 终止，正在处理的请求直接断开
你的后台任务正在写数据库，进程被 kill 了，数据写了一半
你的应用收到 SIGTERM 信号（比如 Kubernetes 要重启你的 Pod），但应用直接退出了，没有做任何清理工作

这些问题都可以通过优雅退出（Graceful Shutdown）来解决。

内存管理：Go 的垃圾回收机制

Sun, 18 Apr 2021 09:45:00 +0800

内存管理：Go 的垃圾回收机制

在 C/C++ 中，你需要手动管理内存：malloc 分配，free 释放。忘记释放就会内存泄漏，释放两次就会程序崩溃。

Go 语言采用了自动垃圾回收（Garbage Collection, GC），让你不再为内存管理烦恼。但理解 GC 的工作原理，能帮你写出更高效的代码。

缓存：让应用飞起来

Fri, 16 Apr 2021 13:40:00 +0800

缓存：让应用飞起来

缓存是提升系统性能最有效的手段之一。当你的应用频繁访问数据库、调用远程 API 或执行复杂的计算时，缓存可以显著减少响应时间和系统负载。

Go 提供了多种缓存方案：从简单的内存缓存到强大的分布式缓存（如 Redis）。今天我们就来学习如何在 Go 中实现和使用缓存。

CGO 入门：Go 与 C 的桥梁

Thu, 15 Apr 2021 15:30:00 +0800

CGO 入门：Go 与 C 的桥梁

Go 语言虽然强大，但有时候你不得不和 C 语言打交道：

使用一个只有 C 版本的库（如 libjpeg、libpng）
调用系统底层的 API
集成遗留的 C 代码
追求极致性能的关键路径

这时候，CGO 就是你的桥梁。CGO 是 Go 提供的一种机制，允许 Go 代码调用 C 代码，反之亦然。

配置管理：让你的应用更灵活

Tue, 13 Apr 2021 11:18:00 +0800

配置管理：让你的应用更灵活

写代码时，你一定遇到过这样的场景：

开发环境用本地数据库，生产环境用云数据库，难道要改代码？
API 密钥、数据库密码这些敏感信息能硬编码在代码里吗？
修改一个配置就要重新编译部署吗？

这些问题的答案都是——配置管理。

reflect 包：运行时的魔法镜子

Mon, 12 Apr 2021 13:15:00 +0800

reflect 包：运行时的魔法镜子

想象一下，你面前有一面魔法镜子。当你把任何东西放在它面前，它都能告诉你：这是什么类型？有哪些字段？有哪些方法？甚至能帮你修改它的值。

GORM：Go 的 ORM 利器

Sun, 11 Apr 2021 15:30:00 +0800

GORM：Go 的 ORM 利器

在之前的文章中，我们学习了如何使用 database/sql 直接操作数据库。虽然这种方式灵活且性能高，但在实际项目中，大量的 CRUD 操作写起来非常繁琐，而且容易出错。

unsafe 包：Go 的潘多拉魔盒

Fri, 09 Apr 2021 10:20:00 +0800

unsafe 包：Go 的"潘多拉魔盒"

在 Go 的世界里，安全性是第一优先级。类型检查、边界检查、垃圾回收……这些机制保护你免受大多数底层错误的困扰。

网络编程：用 Go 构建底层网络应用

Thu, 08 Apr 2021 10:45:00 +0800

网络编程：用 Go 构建底层网络应用

虽然我们平时写 Web 应用大多数时候都在用 HTTP，但 HTTP 本身也是建立在 TCP/IP 协议之上的。有时候我们需要更底层的控制，比如写一个游戏服务器、一个物联网设备的数据收集器，或者一个自定义的 RPC 框架，这时候就需要直接操作 TCP 或 UDP 了。

构建约束：条件编译的艺术

Wed, 07 Apr 2021 16:45:00 +0800

构建约束：条件编译的艺术

你有没有想过：Go 是怎么做到一份代码编译出 Windows、Linux、macOS 等多个平台的可执行文件的？当你在 Linux 上调用系统特有的 API 时，Windows 上那段代码是怎么被"忽略"的？

加密与安全：让你的 Go 程序固若金汤

Mon, 05 Apr 2021 14:22:00 +0800

加密与安全：让你的 Go 程序固若金汤

安全不是事后补救，而是从一开始就应该考虑的事情。

当你存储用户密码时，你有没有想过：如果数据库泄露了，用户的密码会不会被直接看到？当你传输敏感数据时，你有没有想过：中间人会不会窃听你的通信？当用户登录时，你有没有想过：怎么确保这个请求真的来自他本人？

go:embed：把文件打包进二进制

Mon, 05 Apr 2021 11:30:00 +0800

go:embed：把文件打包进二进制

你有没有遇到过这样的烦恼？

编译好的 Go 程序发给别人，结果对方说：“怎么打开是 404 啊？” 你一看，原来是因为 HTML 模板、CSS 文件、图片这些静态资源没有一起打包过去。

错误处理的高级技巧

Sat, 03 Apr 2021 09:15:00 +0800

错误处理的高级技巧

如果你写过 Go 代码，一定对这样的代码不陌生：

result, err := doSomething()
if err != nil {
 return err
}

Go 的错误处理方式一直备受争议。有人认为它太啰嗦，有人认为它很清晰。不管你怎么看，Go 1.13 引入的错误包装机制让错误处理变得更加优雅和强大。

字符串处理：那些被忽略的细节

Fri, 02 Apr 2021 09:38:00 +0800

字符串处理：那些被忽略的细节

你可能觉得字符串处理是编程中最简单的事情——不就是拼拼字符串、查查子串、做个替换嘛。直到你遇到中文乱码、emoji 长度不对、URL 编码错误这些坑，才会意识到：字符串处理远没有看起来那么简单。

接口组合：Go 的设计哲学

Thu, 01 Apr 2021 14:22:00 +0800

接口组合：Go 的设计哲学

在学习 Go 的过程中，你可能会发现一个有趣的现象：Go 标准库中的接口都非常小。io.Reader 只有一个方法，io.Writer 也只有一个方法，fmt.Stringer 同样只有一个方法。

性能优化：让 Go 程序飞起来

Mon, 29 Mar 2021 17:20:00 +0800

性能优化：让 Go 程序飞起来

Go 语言本身就很快，但"快"是没有上限的。当你的应用面临高并发、大数据量或严格延迟要求时，性能优化就变得至关重要。

日志处理：构建可观测的应用

Fri, 26 Mar 2021 14:30:00 +0800

日志处理：构建可观测的应用

日志是应用程序的眼睛。良好的日志系统能帮助我们调试问题、监控系统状态、追踪用户行为。Go 提供了多种日志解决方案，从简单的标准库到强大的第三方框架。

gRPC：构建高性能微服务

Tue, 23 Mar 2021 10:15:00 +0800

gRPC：构建高性能微服务

在微服务架构中，服务之间的通信至关重要。传统的 RESTful API 虽然简单易用，但在性能、类型安全和代码生成方面存在不足。gRPC 是 Google 开源的高性能 RPC 框架，它使用 Protocol Buffers 作为接口定义语言和序列化格式，为微服务通信提供了更好的解决方案。

WebSocket：实现实时通信

Sat, 20 Mar 2021 16:45:00 +0800

WebSocket：实现实时通信

HTTP 是请求-响应模式，客户端必须主动发起请求才能获取数据。但在很多场景中（聊天室、实时游戏、股票行情、在线协作等），我们需要服务器主动推送数据给客户端。

模板引擎：text/template 和 html/template

Wed, 17 Mar 2021 11:30:00 +0800

模板引擎：text/template 和 html/template

在构建 Web 应用、生成配置文件、发送电子邮件等场景中，我们经常需要把数据填充到预定义的模板中。Go 的标准库提供了两个模板引擎：

text/template：用于生成纯文本（邮件、配置文件、代码等）
html/template：用于生成 HTML，自动处理转义防止 XSS 攻击

今天我们就来全面学习 Go 的模板引擎。

泛型：Go 的类型参数革命

Sun, 14 Mar 2021 15:20:00 +0800

泛型：Go 的类型参数革命

Go 1.18 引入了一个期待已久的特性——泛型（Generics）。这是 Go 语言诞生以来最大的语法变化之一。

泛型让你能写出更通用、更灵活的代码，而不需要牺牲类型安全。今天我们就来深入学习 Go 的泛型。

命令行工具：用 Go 构建优雅的 CLI 应用

Thu, 11 Mar 2021 09:45:00 +0800

命令行工具：用 Go 构建优雅的 CLI 应用

Go 语言非常适合构建命令行工具。事实上，很多知名的 CLI 工具都是用 Go 写的：Docker、Kubernetes、Hugo、Terraform……

反射：Go 的元编程魔法

Mon, 08 Mar 2021 14:30:00 +0800

反射：Go 的元编程魔法

反射（Reflection）是一种强大的元编程技术，它允许程序在运行时检查和操作自身的结构。在 Go 中，反射主要用于处理未知类型的值、实现通用函数、构建框架等场景。

时间处理：掌握 Go 的 time 包

Sat, 06 Mar 2021 10:15:00 +0800

时间处理：掌握 Go 的 time 包

时间是程序中最常用也是最容易出错的概念之一。时区转换、格式化、时间计算、定时任务……每一个都是坑。

幸运的是，Go 的 time 包设计得非常优雅和实用。今天我们就来全面学习它。

数据库操作：Go 与 SQL 的完美邂逅

Wed, 03 Mar 2021 14:25:00 +0800

数据库操作：Go 与 SQL 的完美邂逅

几乎每一个真实的应用都需要和数据库打交道。无论是用户信息、订单数据还是日志记录，数据库都是我们存储和查询数据的核心工具。

Go 语言通过 database/sql 包提供了一个优雅而强大的数据库访问接口。它不直接实现任何数据库驱动，而是定义了一套标准接口，让各种数据库驱动（MySQL、PostgreSQL、SQLite 等）来实现具体的连接和操作。

正则表达式：文本处理的瑞士军刀

Sat, 27 Feb 2021 16:05:00 +0800

正则表达式：文本处理的瑞士军刀

如果你要在代码里验证邮箱格式、提取日志中的时间戳、替换文本中的敏感信息、或者解析复杂的配置文件——正则表达式（Regular Expression，简称 regex）就是你的瑞士军刀。

Go Modules：现代化的依赖管理

Wed, 24 Feb 2021 11:40:00 +0800

Go Modules：现代化的依赖管理

在 Go 1.11 之前，Go 的依赖管理一直是个痛点。所有的代码都要放在 GOPATH 下，版本号管理很麻烦，同一个包的不同版本不能共存。社区出现了很多第三方工具——glide、dep、govendor——但每个都有自己的问题。

Go 测试：让代码更可靠的秘密武器

Sun, 21 Feb 2021 15:18:00 +0800

Go 测试：让代码更可靠的秘密武器

“我的代码能跑就行，为什么要写测试？”

如果你有过这样的想法，那你还没经历过这样的场景：凌晨三点，客户报告生产环境出了一个 bug，你翻遍了代码也找不到问题在哪；或者你修改了一个看似无关的函数，结果整个系统都崩溃了。

HTTP 编程：用 Go 构建 Web 服务

Thu, 18 Feb 2021 10:50:00 +0800

HTTP 编程：用 Go 构建 Web 服务

如果你要问"用 Go 能做什么"，最常见的答案之一就是——Web 服务。

Go 的标准库 net/http 提供了强大的 HTTP 客户端和服务器实现。你不需要依赖任何第三方框架，就能构建出生产级的 Web 应用。事实上，很多知名的 Go Web 框架（如 Gin、Echo）底层都是基于标准库实现的。

JSON 处理：Go 与数据交换的桥梁

Tue, 16 Feb 2021 13:10:00 +0800

JSON 处理：Go 与数据交换的桥梁

如果你在做 Web 开发，那你几乎每天都会和 JSON 打交道。JSON（JavaScript Object Notation）已经成为当今互联网最流行的数据交换格式——API 返回 JSON，配置文件用 JSON，消息队列里传输的也是 JSON。

文件 I/O：Go 的文件操作全攻略

Sat, 13 Feb 2021 11:28:00 +0800

文件 I/O：Go 的文件操作全攻略

几乎所有程序都需要和文件打交道——读配置文件、写日志、处理用户上传的图片、导出数据到 CSV……文件操作是编程中最基础也最实用的技能之一。

Context：并发控制的指挥棒

Wed, 10 Feb 2021 16:20:00 +0800

Context：并发控制的指挥棒

在构建真实的 Go 应用时，你经常会遇到这样的场景：

一个 HTTP 请求处理到一半，客户端断开了连接——你应该停止后续的工作
一个数据库查询跑了太久——你应该在超时后取消它
一个微服务调用了另一个微服务——你应该传递请求 ID 方便追踪

这些场景都涉及到跨 goroutine 的控制流管理——怎么告诉一组相关的 goroutine “该停了"或"带上这个信息”。

sync 包：Go 的同步工具箱

Mon, 08 Feb 2021 09:45:00 +0800

sync 包：Go 的同步工具箱

前两篇文章我们学了 goroutine 和 channel——Go 并发编程的两大利器。但现实中，不是所有并发问题都适合用 channel 来解决。

有时候你只需要保护一小段临界区代码，用 channel 反而显得笨重。这时候，传统的同步原语——互斥锁、读写锁、等待组等——就是你的好朋友。

Channel：Go 并发的灵魂

Fri, 05 Feb 2021 14:30:00 +0800

Channel：Go 并发的灵魂

上一篇我们学了 goroutine，但只学会了启动它们。有一个问题还没解决：goroutine 之间怎么交流？

在传统的并发编程中，线程之间通常通过共享内存来通信——比如共享变量加锁。这种方式容易出错，你忘了加锁、忘了释放锁、不小心造成死锁……各种坑。

Goroutine：Go 的并发魔法

Tue, 02 Feb 2021 10:15:00 +0800

Goroutine：Go 的并发魔法

如果你问我 Go 语言最酷的特性是什么，我会毫不犹豫地回答：goroutine。

在当今这个多核 CPU 普及的时代，并发编程已经不是什么新鲜事了。但传统的并发模型——不管是 Java 的线程、Python 的多进程，还是 Node.js 的事件循环——都有各自的痛点：要么太重、要么太复杂、要么性能不够。

Go 跨平台路径入门：filepath、path 和文件名处理

Sat, 30 May 2020 15:28:00 +0800

路径问题经常在换系统后暴露

很多 Go 初学者在 macOS 或 Linux 上写路径时，会直接拼字符串：

path := dir + "/" + filename

这在类 Unix 系统上通常能跑，但到了 Windows，路径分隔符、盘符、绝对路径规则都可能不同。Go 标准库提供了 path/filepath 专门处理本地文件路径，提供了 path 处理 URL 路径这类斜杠分隔路径。分清它们，能避免很多跨平台问题。

Go 构建参数入门：版本号、环境变量和交叉编译怎么处理

Wed, 27 May 2020 11:52:00 +0800

从 go run 到可发布二进制

开发时我们常用：

go run .

但真正发布命令行工具或服务时，通常会构建二进制：

go build -o app .

Go 的发布体验很直接。很多程序构建后就是一个可执行文件，复制到目标机器就能运行。入门阶段除了 go build，还值得了解几个常见话题：如何指定输出名，如何注入版本号，如何交叉编译，运行时配置和构建时信息应该怎么分。

Go 随机数入门：math/rand、crypto/rand 和安全 Token

Sun, 24 May 2020 18:06:00 +0800

随机数也分场景

很多程序都需要随机数：生成验证码、抽样、打乱列表、测试数据、游戏掉落、会话 token、密码重置链接。它们看起来都叫“随机”，但安全要求完全不同。Go 里常见两个包：math/rand 和 crypto/rand。前者适合模拟、测试、非安全业务随机；后者适合安全 token、密钥、密码重置码这类不能被预测的场景。

Go 密码处理入门：为什么不能明文保存密码

Thu, 21 May 2020 10:17:00 +0800

密码不是普通字符串

做用户系统时，最危险的错误之一是把密码当普通字符串存进数据库。数据库一旦泄漏，所有用户密码都会直接暴露。更糟的是，很多用户会在多个网站重复使用密码，你的泄漏会影响他们在其他服务上的账号。

Go 压缩和归档入门：gzip、tar 和 zip 的基本用法

Mon, 18 May 2020 14:39:00 +0800

压缩和归档是很多后台工具的基础能力

服务端程序经常需要处理文件：日志按天压缩，报表打包下载，备份目录归档，上传的 zip 解开检查。Go 标准库提供了 compress/gzip、archive/tar、archive/zip 等包，足够覆盖很多入门和中小项目需求。

Go XML 处理入门：用 encoding/xml 解析配置和旧系统数据

Fri, 15 May 2020 09:06:00 +0800

XML 还没有从工程世界消失

现在很多新接口都用 JSON，但 XML 依然存在于不少地方：老系统接口、支付或银行协议、配置文件、RSS、Sitemap、办公文档格式。Go 标准库提供了 encoding/xml，可以像处理 JSON 一样把 XML 映射到结构体，也可以用流式方式逐个 token 解析。

Go CSV 处理入门：读取表格数据、清洗字段和导出报表

Tue, 12 May 2020 16:22:00 +0800

CSV 是最朴素也最常见的数据交换格式

很多系统导入导出数据时，最后都会落到 CSV：用户列表、订单明细、库存表、运营报表、日志统计结果。CSV 看起来只是逗号分隔文本，但真正处理时会遇到引号、换行、空字段、表头、编码和字段数量不一致等问题。不要自己用 strings.Split(line, ",") 解析 CSV，标准库已经提供了 encoding/csv。

Go io.Reader 和 io.Writer 入门：理解标准库里的数据流

Sat, 09 May 2020 08:48:00 +0800

两个小接口撑起了很多标准库

Go 标准库里有两个非常重要的接口：io.Reader 和 io.Writer。它们看起来小到不能再小，却贯穿文件、网络、压缩、HTTP、模板、JSON、命令行工具和测试。理解它们后，你会发现很多 API 的设计突然变得一致。

Go 空接口和类型断言入门：什么时候需要 interface{}

Wed, 06 May 2020 20:14:00 +0800

空接口能装任何值，但代价是你要自己判断

Go 里 interface{} 是一个很特别的类型。因为它没有要求任何方法，所以所有类型都实现了它。字符串、整数、结构体、切片、指针，都可以赋给 interface{}。这让它很灵活，也很容易被滥用。

Go 泛型之前怎么复用代码：接口、函数参数和清楚的重复

Sun, 03 May 2020 09:31:00 +0800

没有泛型时，Go 依然能写可维护代码

在 2020 年学习 Go，一个经常被问到的问题是：Go 没有泛型，遇到重复代码怎么办？比如要写 []int 的查找，又要写 []string 的查找；要写通用队列，又要处理不同类型；要写工具函数，又不想复制很多版本。这个问题很真实，但答案不是“到处用 interface{}”，也不是“所有重复都必须消灭”。

Go 静态文件服务入门：在没有 embed 之前如何组织资源

Tue, 28 Apr 2020 18:22:00 +0800

静态资源也是 Web 服务的一部分

写 Go Web 服务时，你可能需要提供 CSS、图片、下载文件、HTML 模板和前端打包结果。现在很多人会想到 embed，但在 2020 年 4 月的 Go 语境里，embed 还不是标准库能力。那时更常见的做法是把静态资源作为目录随程序一起部署，用 http.FileServer 提供访问。

Go 调试入门：从 fmt.Println 到 go test、race 和 Delve

Sun, 26 Apr 2020 09:44:00 +0800

调试不是乱试，而是缩小问题范围

写 Go 时，bug 可能来自很多地方：变量被遮蔽、切片共享底层数组、map 遍历顺序不稳定、JSON 字段没导出、goroutine 没退出、并发写 map、错误被忽略。初学阶段最重要的调试能力不是记住某个高级工具，而是学会缩小范围：问题在哪个函数发生？输入是什么？预期是什么？实际是什么？

Go 依赖管理入门：go mod、版本号、replace 和 tidy 怎么用

Thu, 23 Apr 2020 15:09:00 +0800

依赖管理是项目长期维护的一部分

Go Modules 让 Go 项目摆脱了早期强依赖 GOPATH 的方式。现在一个项目只要有 go.mod，就能记录模块名、Go 版本和外部依赖。你可以在任意目录开发，也能让团队成员拉代码后得到一致依赖版本。

Go 排序和搜索入门：sort 包、稳定排序和业务列表处理

Mon, 20 Apr 2020 11:36:00 +0800

业务代码里到处都是排序

文章按发布时间倒序，订单按金额排序，排行榜按分数排序，后台列表按状态和创建时间排序。排序看起来是基础算法，但在业务代码里非常常见。Go 标准库的 sort 包提供了常用能力：排序字符串、整数、浮点数，按自定义规则排序结构体切片，做稳定排序和二分搜索。

Go 正则表达式入门：用 regexp 做校验、提取和替换

Fri, 17 Apr 2020 19:13:00 +0800

正则很好用，但不要让它变成谜语

正则表达式适合处理文本模式：校验格式、提取字段、替换内容、扫描日志。Go 标准库提供了 regexp 包，使用起来比较直接。你可以编译一个正则，判断字符串是否匹配，也可以查找子匹配，把日志行拆成结构化数据。

Go bufio 入门：逐行读取、缓冲写入和处理大文件的基本功

Tue, 14 Apr 2020 08:51:00 +0800

不是所有文件都应该一次读进内存

入门时我们常用：

data, err := os.ReadFile("access.log")

这很简单，适合小文件。但如果文件有几百 MB，甚至几个 GB，一次读进内存就不合适。日志分析、CSV 处理、文本转换、命令行过滤工具，都更适合边读边处理。Go 标准库的 bufio 包就是为这类场景准备的。

Go 服务优雅关闭入门：让 HTTP 服务收到信号后稳稳退出

Sat, 11 Apr 2020 13:27:00 +0800

服务退出也需要设计

很多入门 HTTP 服务最后都是这样：

log.Fatal(http.ListenAndServe(":8080", mux))

它能启动服务，但没有认真处理停止过程。你按 Ctrl+C，或者部署平台发送 SIGTERM，进程可能立刻退出，正在处理的请求被中断，日志没来得及刷，后台任务也不知道该停。小练习问题不大，真实服务就不够稳。

Go HTTP Handler 测试入门：不用启动端口也能测接口

Wed, 08 Apr 2020 10:05:00 +0800

Handler 不一定要启动服务才能测试

很多人测试 HTTP 接口时，会先 go run . 启动服务，再用 curl 或浏览器访问。这种手动测试有用，但不适合长期保护代码。每次改 handler 都手动点一遍，很快会漏。Go 标准库提供了 net/http/httptest，可以在测试里构造请求、记录响应，不需要真的监听端口。

Go JSON 解码细节：字段缺失、未知字段、流式读取和接口边界

Sun, 05 Apr 2020 17:42:00 +0800

JSON 能解析成功，不代表业务就安全

前面学习 Go JSON 时，我们通常会写：

var req CreateUserRequest
err := json.NewDecoder(r.Body).Decode(&req)

这确实是 Go Web API 里很常见的代码。但真实接口里，JSON 解码有很多细节：字段缺失时是什么值？客户端多传字段会怎样？数字会不会溢出？请求体里有两个 JSON 对象怎么办？空字符串和字段不存在能不能区分？这些问题不处理，接口表面能跑，边界却不稳。

Go 反射和结构体标签入门：看懂 JSON、校验和框架背后的机制

Thu, 02 Apr 2020 09:18:00 +0800

为什么入门阶段也值得理解一点反射

很多 Go 初学者第一次看到反射，并不是因为主动想学它，而是因为结构体字段后面那一串标签：

type User struct {
	ID int64 `json:"id"`
	Email string `json:"email"`
}

你可能会好奇：encoding/json 为什么知道要把 Email 变成 email？Web 框架为什么能自动把请求体绑定到结构体？校验库为什么能通过 validate:"required" 判断字段必填？这些能力背后都和反射有关。

Go 性能入门：基准测试、pprof 和先测量再优化

Sun, 29 Mar 2020 15:33:00 +0800

性能优化最怕凭感觉

Go 运行速度通常不错，但这不意味着所有 Go 代码天然高效。字符串拼接、JSON 编码、数据库查询、锁竞争、内存分配、网络超时，都可能成为瓶颈。初学者常见问题不是不会优化，而是太早优化，或者凭感觉优化。结果代码变复杂了，性能却没变好。

Go 项目结构入门：什么时候需要 cmd、internal 和分层目录

Thu, 26 Mar 2020 09:58:00 +0800

项目结构不是越复杂越专业

Go 新手很容易被各种项目模板吓到：cmd、internal、pkg、api、configs、deployments、scripts、services、repositories。有些结构来自大型项目，有些只是团队习惯。如果你刚写一个小服务，一开始就照搬复杂模板，反而会让代码分散、跳转困难。

Go 命令行程序结构：从一个 main.go 整理成可维护工具

Mon, 23 Mar 2020 11:29:00 +0800

命令行工具也需要结构

Go 很适合写命令行工具。编译成一个二进制，复制就能运行，启动快，标准库也覆盖了参数解析、文件读写、HTTP 请求和 JSON 编解码。很多团队会用 Go 写内部运维工具、数据迁移脚本、报表生成器和代码生成器。

Go 模板入门：用 html/template 生成安全的 HTML 页面

Fri, 20 Mar 2020 16:41:00 +0800

不是所有 Web 页面都需要前端框架

Go 经常被用来写 JSON API，但它也很适合生成简单服务端页面。后台管理、内部工具、报表页、文档页、小型内容站，有时用 html/template 直接渲染 HTML 会比引入前端构建链更省事。页面请求进来，服务端查询数据，套进模板，返回 HTML，流程非常清楚。

Go 数据库入门：用 database/sql 写清楚的查询和事务

Tue, 17 Mar 2020 08:52:00 +0800

数据库代码要先写清楚，再谈封装

Go 做后端服务绕不开数据库。很多人会直接找 ORM，但在理解 ORM 之前，最好先用标准库 database/sql 写几次查询和事务。它能让你看清楚数据库访问的基本动作：打开连接池、执行 SQL、扫描结果、处理空值、使用 context、提交或回滚事务。

Go HTTP 客户端入门：请求、超时、重试和 JSON API 调用

Sat, 14 Mar 2020 20:07:00 +0800

调用外部 API 是后端程序的日常

很多 Go 服务不只是接收请求，也会调用别的服务：支付网关、短信平台、内部用户中心、搜索服务、AI 接口、Webhook 地址。HTTP 客户端代码看似简单，一个 http.Get 就能拿到响应，但真实项目里需要考虑超时、状态码、JSON 解析、错误消息、重试和日志。

Go 时间处理入门：time 包、时区、定时器和超时控制怎么用

Wed, 11 Mar 2020 14:18:00 +0800

时间问题总比看起来更复杂

业务代码里到处都有时间：用户注册时间、订单过期时间、活动开始时间、接口超时、定时任务、缓存有效期、日志时间戳。刚开始你可能只会用 time.Now()，但很快会遇到格式化、解析、时区和定时器。时间处理一旦写错，问题往往很隐蔽：本地正常，线上差 8 小时；今天正常，月底出错；测试偶尔超时，查不出原因。

Go 日志和配置入门：让程序出问题时能看得懂、改得动

Sun, 08 Mar 2020 09:36:00 +0800

程序能跑还不够，还要能排查

很多入门程序只关注“功能能不能运行”。但真实服务上线后，另一个问题会立刻出现：出了问题怎么看？连接哪个端口？数据文件在哪里？请求为什么失败？程序启动时到底读到了什么配置？如果日志混乱、配置散落，排查会非常痛苦。

Go 表驱动测试入门：用一张用例表保护越来越多的业务规则

Thu, 05 Mar 2020 18:24:00 +0800

测试不是额外负担，而是让修改变轻

很多初学者学 Go 时会先写程序，再手动运行几次，看输出差不多就算完成。这个阶段可以理解，但一旦函数里出现业务规则，手动验证很快就不够用了。你今天改了折扣逻辑，明天改了分页边界，后天又修了一个空字符串问题，如果每次都靠肉眼看输出，迟早会漏。

Go 包和模块入门：把代码从一个文件整理成一个小项目

Mon, 02 Mar 2020 10:12:00 +0800

从一个文件走向一个项目

刚开始学 Go 时，所有代码写在 main.go 里很正常。几十行代码时，这样最直接；可是一旦你开始写命令行工具、HTTP 服务、批处理脚本，main.go 很快会变成一个混合了参数解析、业务规则、文件读写和输出格式的长文件。Go 的包和模块，就是用来帮你把这些代码拆开，同时保持引用关系清楚。

错误处理：Go 为什么不用 try-catch？

Fri, 28 Feb 2020 14:07:00 +0800

错误处理：Go 为什么不用 try-catch？

如果你来自 Java、Python 或 C# 的世界，第一次看到 Go 的错误处理代码时，你大概会皱眉头：

result, err := doSomething()
if err != nil {
 return err
}

result2, err := doSomethingElse(result)
if err != nil {
 return err
}

result3, err := doAnotherThing(result2)
if err != nil {
 return err
}

“这什么鬼？if err != nil 写了一遍又一遍，也太啰嗦了吧？try-catch 不好吗？”

Go Web 入门：只用标准库写一个小而清楚的 HTTP 服务

Fri, 28 Feb 2020 09:35:00 +0800

为什么建议先用标准库写一次 Web 服务

很多人学 Go Web 的第一步是找框架。Gin、Echo、Fiber 都很好用，但如果完全跳过标准库，后面很容易只会照框架文档写代码，却不理解请求、响应、路由和中间件到底是什么。Go 的 net/http 标准库已经足够写一个小型 JSON 服务。先用它做一次完整项目，会让你对所有框架的理解都更扎实。

Go 并发入门：goroutine、channel 和 context 怎么一起用

Tue, 25 Feb 2020 14:55:00 +0800

Go 的并发为什么容易上手也容易误用

Go 最吸引人的特性之一是并发。启动一个 goroutine 只需要在函数调用前加 go，channel 可以在 goroutine 之间传递数据，select 可以等待多个通信事件，context 可以传递取消信号和超时。相比手动管理线程，这套模型轻很多。

接口：Go 最优雅的设计哲学

Tue, 25 Feb 2020 11:15:00 +0800

接口：Go 最优雅的设计哲学

如果你问我 Go 语言中哪个特性最能体现设计之美，我会毫不犹豫地回答：接口。

在 Go 的世界里，接口不是用来"约束"的，而是用来"描述"的。它描述的是一种能力——“你能做什么”，而不是"你是什么"。这种思维方式的转变，是理解 Go 接口的关键。

结构体与方法：Go 的''面向对象''之路

Sat, 22 Feb 2020 09:38:00 +0800

结构体与方法：Go 的"面向对象"之路

到目前为止，我们已经学了 Go 的基本数据类型、切片、map、指针。但如果你要描述一个更复杂的事物——比如一个"用户"，他有姓名、年龄、邮箱、注册时间等多个属性——用基本类型就不够用了。

Go 文件、JSON 和命令行工具：做一个真正能用的小程序

Fri, 21 Feb 2020 19:25:00 +0800

小工具是学习 Go 的好方式

学 Go 不一定要从 Web 框架开始。很多时候，一个能解决自己问题的命令行工具更适合入门：代码量不大，不需要数据库，也不需要前端，但会用到文件、JSON、参数解析、错误处理和结构体建模。这些都是 Go 日常开发的基本能力。

指针：没有你想的那么可怕

Wed, 19 Feb 2020 15:22:00 +0800

指针：没有你想的那么可怕

提到"指针"，很多人的第一反应是恐惧。这很正常——在 C/C++ 的世界里，指针确实是很多 bug 的根源：野指针、空指针、内存泄漏、缓冲区溢出……简直是一场噩梦。

Go 错误处理实战：别怕 if err != nil，它是在保护你

Tue, 18 Feb 2020 11:10:00 +0800

错误处理是 Go 风格的核心部分

很多初学者看到 Go 代码里反复出现 if err != nil，第一反应是啰嗦。和异常机制相比，它确实更显眼。可是显眼正是 Go 的设计选择：失败路径应该被看见，调用者应该明确决定如何处理失败，而不是让错误从深层调用栈里悄悄冒出来。

Map 字典：Go 里的哈希表实战

Sun, 16 Feb 2020 10:33:00 +0800

Map 字典：Go 里的哈希表实战

想象一下你走进一家大型图书馆。你想找一本特定的书，如果一本书一本书地找，可能要花上一整天。但如果有一个索引系统——你告诉管理员书名，他直接告诉你书在哪个架子上，是不是快多了？

Go 接口入门：从会写到真正理解隐式实现

Sat, 15 Feb 2020 16:30:00 +0800

接口不是为了“面向对象”，而是为了边界

很多人第一次看到 Go 接口，会下意识把它和 Java、PHP 或 TypeScript 的接口放在一起理解。它们确实都能描述一组方法，但 Go 接口最特别的地方是隐式实现：一个类型不需要声明自己实现了某个接口，只要方法集匹配，就自动满足接口。

数组与切片：Go 里最常被搞混的一对

Fri, 14 Feb 2020 13:45:00 +0800

数组与切片：Go 里最常被搞混的一对

如果你问我 Go 语言里最容易让新手困惑的概念是什么，我一定会提到切片（slice）。

很多从 Python、Java 或其他语言转过来的开发者，看到 Go 的切片都会觉得似曾相识——它看起来像 Python 的 list，又像 Java 的 ArrayList。但当你真正开始使用它的时候，会发现它的行为和你想的总是不太一样。

Go 结构体和方法：用组合组织真实业务数据

Wed, 12 Feb 2020 08:45:00 +0800

结构体是 Go 里最重要的建模工具

如果说变量和函数让程序能运行，那么结构体让程序开始表达业务。用户、订单、文章、配置、任务、支付记录，这些概念都需要有名字、有字段、有规则。Go 没有传统面向对象语言那种复杂类体系，它用结构体加方法来组织数据和行为，再通过组合表达复用。

Go 函数：把重复的事交给它

Tue, 11 Feb 2020 11:08:00 +0800

Go 函数：把重复的事交给它

如果你仔细观察日常生活，你会发现很多事情都是重复的。每天早上你要泡咖啡，每周五你要写周报，每个月你要交房租。重复的事情做多了，你就会想：能不能把这些步骤打包，以后只需要一个指令就能搞定？

Go 切片、Map 和字符串：写业务代码绕不开的数据结构

Sun, 09 Feb 2020 21:05:00 +0800

数据结构决定业务代码的日常手感

写 Go 后端时，你每天都会处理列表、键值表和文本。用户列表是切片，配置项是 Map，HTTP 请求里的路径、标题和 JSON 字段大多是字符串。语法上它们都很容易上手，但如果不了解一些底层直觉，很容易写出表面能跑、遇到边界就出问题的代码。

Go 控制流：让程序学会做选择

Sat, 08 Feb 2020 14:52:00 +0800

Go 控制流：让程序学会做选择

到目前为止，我们写的程序都是"一条路走到黑"——从第一行开始，一行一行地往下执行，直到结束。但现实世界中的问题往往不是这么简单的。

Go 函数、指针和值语义：为什么代码看起来简单却很讲究

Fri, 07 Feb 2020 10:15:00 +0800

Go 的函数为什么让人觉得朴素

Go 的函数没有默认参数，没有函数重载，也没有把异常藏在函数体里。一个函数接收什么，返回什么，基本都写在签名上。刚学时你可能觉得它少了一些方便功能，但写真实项目久了会发现，这种朴素让调用关系更容易推理。

Go 变量与数据类型：给数据贴上标签

Thu, 06 Feb 2020 09:17:00 +0800

Go 变量与数据类型：给数据贴上标签

上一篇我们一起搭建了 Go 的开发环境，写出了第一个 Hello World 程序。今天，我们要聊一个更基础的话题——变量和数据类型。

你可能会问：变量有什么好讲的？不就是存个值嘛。

Go 变量、类型和流程控制：把基础语法写得清清楚楚

Tue, 04 Feb 2020 15:40:00 +0800

基础语法不是背规则，而是建立手感

很多人学 Go 的第一反应是：语法不难，但总觉得写起来有些规矩。变量声明有好几种方式，类型写在变量名后面，if 没有括号，循环只有 for，switch 默认不贯穿。单独看每条规则都不复杂，真正需要练的是判断：什么时候该显式写类型，什么时候可以让编译器推断，什么时候应该用 switch 让代码更清楚。

Go 语言开发环境搭建：从零开始的冒险

Mon, 03 Feb 2020 10:24:00 +0800

Go 语言开发环境搭建：从零开始的冒险

嗨，朋友！欢迎来到 Go 语言的世界。

如果你正在读这篇文章，说明你大概已经听说了 Go 语言的一些好处——也许是它超快的编译速度，也许是它简洁优雅的语法，又或者是它强大的并发能力。不管是什么原因把你带到这里，我都很高兴能陪你一起踏上这段旅程。

Go 语言入门：从安装环境到写出第一个可维护程序

Sun, 02 Feb 2020 09:20:00 +0800

为什么很多人把 Go 当作第二门后端语言

学习一门新语言时，最容易被问到的问题是：它到底能帮我解决什么？如果你已经写过 PHP、JavaScript、Python 或 Java，Go 初看起来会有一点朴素。它没有复杂的继承体系，没有花哨的语法糖，也不鼓励把一个表达式写成谜语。可是这种朴素恰好是它的特点：代码容易读，程序容易部署，标准库足够扎实，并发模型也比许多传统语言轻。