Hobin's Blog

1.1 高频标准库包

Sun, 12 Apr 2026 09:05:00 +0800

Go 常用包总览

学习目标

知道 Go 开发中最常用的一批标准库包分别解决什么问题。
能根据场景快速判断应该优先导入哪个包。
能写出字符串处理、时间处理、文件读写、JSON 编解码和 HTTP 请求的基础代码。

常用包速查表

包名	主要用途	常见函数/类型
`fmt`	格式化输入输出	`Println`、`Printf`、`Sprintf`
`strings`	字符串查找、切分、拼接、替换	`Contains`、`Split`、`Join`、`TrimSpace`
`strconv`	字符串与数字、布尔值互转	`Atoi`、`Itoa`、`ParseBool`、`FormatFloat`
`time`	时间获取、格式化、计算	`Now`、`Parse`、`Format`、`Add`
`os`	文件、目录、环境变量、进程级能力	`ReadFile`、`WriteFile`、`MkdirAll`、`Getenv`
`io`	统一处理输入输出流	`Copy`、`ReadAll`、`EOF`
`bufio`	带缓冲的读写，提高 IO 便利性	`NewReader`、`NewWriter`、`Scanner`
`path/filepath`	处理跨平台文件路径	`Join`、`Base`、`Dir`、`Ext`
`encoding/json`	JSON 编码与解码	`Marshal`、`Unmarshal`
`net/http`	HTTP 服务端与客户端开发	`Get`、`Post`、`NewRequest`、`ListenAndServe`

`fmt`：格式化输出的起点

fmt 几乎是每个 Go 初学者最先接触的包。
它负责把变量输出到终端，也能把格式化后的字符串返回出来。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 name := "阿斌"
 age := 18

 fmt.Println("姓名：", name)
 fmt.Printf("年龄：%d\n", age)

 message := fmt.Sprintf("%s 正在学习 Go", name)
 fmt.Println(message)
}

输出结果：

1
2
3


姓名： 阿斌
年龄：18
阿斌 正在学习 Go

适合优先记住的三个函数：

Println：最常见，自动换行。
Printf：按占位符格式化输出。
Sprintf：不直接打印，而是返回字符串。

`strings` 与 `strconv`：文本处理的高频组合

实际开发里，字符串处理和类型转换经常一起出现。
例如：前端传来的是 "18"，你要先去空格，再把它转成数字。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "strconv"
 "strings"
)

func main() {
 rawAge := " 18 "

 trimmed := strings.TrimSpace(rawAge)
 age, err := strconv.Atoi(trimmed)
 if err != nil {
 fmt.Println("转换失败：", err)
 return
 }

 fmt.Println(strings.Contains("golang", "go"))
 fmt.Println(strings.Join([]string{"Go", "标准库", "常用包"}, " / "))
 fmt.Println(age + 2)
}

输出结果：

1
2
3


true
Go / 标准库 / 常用包
20

使用建议：

文本查找、切分、拼接，优先想到 strings。
字符串转数字、数字转字符串，优先想到 strconv。
处理用户输入时，先 TrimSpace，再做转换更稳妥。

`time`：时间、日期与格式化

Go 的时间格式化比较特别，不是写 YYYY-MM-DD，而是使用固定参考时间：

2006-01-02 15:04:05

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import (
 "fmt"
 "time"
)

func main() {
 now := time.Now()
 fmt.Println(now.Format("2006-01-02 15:04:05"))

 t, _ := time.Parse("2006-01-02", "2026-04-12")
 fmt.Println(t.Add(24 * time.Hour).Format("2006-01-02"))
}

常见场景：

记录日志时间。
生成日期目录或文件名。
计算超时时间、过期时间和倒计时。

`os`、`io`、`bufio`、`path/filepath`：文件与系统操作

这几个包经常组合使用：

os 负责打开文件、读取文件、创建目录。
io 负责复制、读取数据流。
bufio 负责按行读取或带缓冲写入。
path/filepath 负责拼接系统路径，避免手写 / 或 \。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


package main

import (
 "bufio"
 "fmt"
 "os"
 "path/filepath"
)

func main() {
 filePath := filepath.Join("data", "demo.txt")
 _ = os.MkdirAll(filepath.Dir(filePath), 0o755)

 file, err := os.Create(filePath)
 if err != nil {
 fmt.Println("创建文件失败：", err)
 return
 }
 defer file.Close()

 writer := bufio.NewWriter(file)
 writer.WriteString("Go 常用包\n")
 writer.WriteString("fmt, strings, strconv\n")
 writer.Flush()

 content, err := os.ReadFile(filePath)
 if err != nil {
 fmt.Println("读取文件失败：", err)
 return
 }

 fmt.Println(string(content))
}

这类代码里有两个实用习惯：

路径拼接使用 filepath.Join，跨平台更安全。
需要分批读写时用 bufio，一次性读写时可以直接用 os.ReadFile、os.WriteFile。

`encoding/json`：结构体与 JSON 互转

接口开发里最常见的序列化包就是 encoding/json。
你可以把结构体编码成 JSON，也可以把 JSON 解析回结构体。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "encoding/json"
 "fmt"
)

type User struct {
 Name string `json:"name"`
 Age int `json:"age"`
}

func main() {
 user := User{Name: "阿斌", Age: 18}

 data, _ := json.Marshal(user)
 fmt.Println(string(data))

 var parsed User
 _ = json.Unmarshal(data, &parsed)
 fmt.Println(parsed.Name, parsed.Age)
}

使用时注意：

Unmarshal 的第二个参数通常要传指针。
结构体字段如果首字母小写，JSON 包无法访问到。
通过 json tag 可以自定义字段名。

`net/http`：服务端和客户端都会用到

只要涉及接口调用或 Web 服务，net/http 都会出现。

客户端最简单的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
 "fmt"
 "io"
 "net/http"
)

func main() {
 resp, err := http.Get("https://example.com")
 if err != nil {
 fmt.Println("请求失败：", err)
 return
 }
 defer resp.Body.Close()

 body, err := io.ReadAll(resp.Body)
 if err != nil {
 fmt.Println("读取响应失败：", err)
 return
 }

 fmt.Println(resp.StatusCode)
 fmt.Println(len(body))
}

开发中要特别留意：

请求完成后记得 defer resp.Body.Close()。
简单请求可以直接用 http.Get，复杂请求建议 NewRequest + Client。
写服务端时常配合 http.HandleFunc 与 http.ListenAndServe。

选包思路

遇到一个需求时，可以先这样判断：

要打印和格式化字符串，用 fmt。
要处理字符串内容，用 strings。
要做类型转换，用 strconv。
要处理日期时间，用 time。
要读写文件和目录，用 os。
要处理数据流复制，用 io。
要按行扫描文本，用 bufio。
要拼接文件路径，用 path/filepath。
要处理 JSON，用 encoding/json。
要发 HTTP 请求或起 Web 服务，用 net/http。

常见误区

新项目读取文件时优先使用 os.ReadFile，不要继续依赖已经废弃的 ioutil。
strconv.Atoi 只适合十进制整数字符串，不适合任意进制场景。
json.Unmarshal 忘记传指针时，解析结果不会按预期写回变量。
使用 http.Get 后忘记关闭 Body，会造成资源没有及时释放。

延伸阅读

如果你想继续拆开学习，可以继续看这些相关专题：

1.1 标题

Thu, 09 Apr 2026 12:05:00 +0800

标题语法概览

Markdown 标题有两种常见写法：

ATX 风格：使用 #，支持 1 到 6 级标题（推荐）。
Setext 风格：使用 = 和 -，只支持 1、2 级标题。

ATX 风格（`#`）

这是最常用、兼容性最好的标题写法。

基本语法

1
2
3
4
5
6


# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 六级标题

渲染效果：

# 一级标题（示例）
## 二级标题（示例）
### 三级标题（示例）
#### 四级标题（示例）
##### 五级标题（示例）
###### 六级标题（示例）

书写规则

# 必须在行首。
# 与标题文字之间建议保留一个空格。
一般不建议在标题末尾再补很多 #（可读性较差）。

Setext 风格（`=` / `-`）

Setext 只支持两级标题：

一级标题：下一行用 ===
二级标题：下一行用 ---

1
2
3
4
5


我展示的是一级标题
=================

我展示的是二级标题
-----------------

这种写法在短文档中也很常见，但在复杂文档里通常不如 # 风格直观。

标题层级结构

标题层级应遵循从大到小的逻辑，不建议随意跳级。
良好的标题结构就像一本书的目录。

不推荐结构

1
2
3


# 主标题
### 直接跳到三级标题（不推荐）
## 然后才是二级标题

常见错误

# 不在行首，导致无法识别为标题。
标题层级跳跃（如 # 后直接 ###），结构不清晰。
把普通短句都写成标题，导致文档层级过深、阅读困难。
同一篇文档混用过多风格（# 与 =/-）且无规律，影响一致性。

1.1 开发环境准备

Wed, 08 Apr 2026 10:30:00 +0800

学习目标

完成鸿蒙开发最小可用环境搭建，并确认项目可正常运行。

环境清单

DevEco Studio（建议使用稳定版本）。
HarmonyOS SDK。
可用模拟器或真机调试设备。

实操步骤

安装 DevEco Studio 并完成首次启动向导。
在 SDK 管理页面安装所需平台与工具链。
创建 Hello World 工程并执行编译运行。

验证标准

项目能够成功构建，并在模拟器或设备上启动。

1.1 变量定义

Wed, 01 Apr 2026 10:00:00 +0800

变量定义

概念说明

变量用于在程序运行过程中保存数据。
Go 是静态类型语言，变量在声明时就确定类型。
局部变量必须先声明再使用，并且声明后必须被使用。

如果变量只声明不赋值，会获得该类型的零值，例如：

int 的零值是 0
string 的零值是 ""
bool 的零值是 false

语法/规则

完整声明：var 变量名类型 = 值
类型推导：var 变量名 = 值
简短声明：变量名 := 值（只能在函数内部使用）
多变量声明支持同类型并列和同时赋值。
全局变量定义在函数外；局部变量定义在函数内。

单变量声明与零值示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 var age int // 未赋值时会得到 int 的零值 0
 var nickname string = "阿斌"
 city := "上海" // := 只能在函数内部使用

 fmt.Println(age) // 输出零值 0
 fmt.Println(nickname)
 fmt.Println(city)
}

输出结果：

1
2
3


0
阿斌
上海

多变量与作用域示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

var courseName = "Go 入门" // 全局变量，定义在函数外

func main() {
 var firstName, lastName string
 firstName, lastName = "阿", "斌" // 同时给两个变量赋值

 level, passed := 1, true // 同时声明并赋值两个变量

 fmt.Println(courseName)
 fmt.Println(firstName, lastName)
 fmt.Println(level, passed)
}

输出结果：

1
2
3


Go 入门
阿 斌
1 true

常见错误

在函数外使用 :=，会直接编译报错。
局部变量声明后未使用，会出现 declared and not used。
把同名变量反复用 := 声明，容易误以为是赋值，实际可能是重新声明。

1.2 文本格式

Thu, 09 Apr 2026 12:05:00 +0800

文本格式语法概览

本节整理 Markdown 中最常见的文本格式能力：

换行与分段
强调（粗体、斜体、粗斜体）
分割线
删除线、下划线、高亮
脚注
行内代码

换行与分段

行内换行（行尾两个空格）

1
2


第一行文本
第二行文本

渲染效果：
第一行文本
第二行文本

分段（空一行）

1
2
3


第一段文本

第二段文本

渲染效果：
第一段文本

第二段文本

强调语法

Markdown 提供粗体、斜体和粗斜体的简洁写法。

粗体

使用 **文本** 或 __文本__。

1
2


这是 **粗体文字**（星号写法）
这是 __粗体文字__（下划线写法）

渲染效果：
这是 粗体文字（星号写法）
这是 粗体文字（下划线写法）

斜体

使用 *文本* 或 _文本_。

1
2


这是 *斜体文字*（星号写法）
这是 _斜体文字_（下划线写法）

渲染效果：
这是 斜体文字（星号写法）
这是 斜体文字（下划线写法）

粗斜体

使用 ***文本*** 或 ___文本___。

1
2


***粗斜体文本***
___粗斜体文本___

渲染效果：
粗斜体文本
粗斜体文本

分割线

一行中使用 3 个及以上的 *、- 或 _ 可创建分割线。
符号间可以带空格。

1
2
3
4
5


***
* * *
-----
- - -
___

渲染效果：

删除线、下划线与高亮

删除线

使用 ~~文本~~。

1

~~这段内容会显示为删除线~~

渲染效果：
~~这段内容会显示为删除线~~

下划线（HTML 写法）

标准 Markdown 没有原生下划线语法，通常使用 HTML 标签：

1

<u>带下划线文本</u>

渲染效果：
带下划线文本

高亮（HTML 写法）

部分 Markdown 扩展支持高亮；为兼容性更稳，常用 <mark>：

1

这是 <mark>高亮文本</mark>

渲染效果：
这是高亮文本

脚注

脚注用于补充说明，正文中用引用标记，文末写定义。

1
2
3


这是一个脚注示例[^note-1]。

[^note-1]: 这是脚注内容。

渲染效果：
这是一个脚注示例¹。

行内代码

基本写法

使用一个反引号包围代码片段。

1
2
3


使用 `git commit` 命令提交代码。
变量 `userName` 存储用户名。
在终端中输入 `npm install` 安装依赖。

渲染效果：
使用 git commit 命令提交代码。
变量 userName 存储用户名。
在终端中输入 npm install 安装依赖。

代码中包含反引号

当内容本身包含反引号时，外层使用更多反引号包裹。

1

要显示反引号，使用 `` `code` `` 这样的格式。

渲染效果：
要显示反引号，使用 `code` 这样的格式。

常见错误

行尾换行忘记加两个空格，导致换行不生效。
强调符号前后紧贴中文或英文时，个别解析器可能出现渲染差异，建议留意结果。
把全角符号当作语法符号使用（如全角 ＊、＿），会导致格式失效。
在不支持脚注或 HTML 标签的解析器中，[^脚注]、<u>、<mark> 可能无法按预期渲染。

这是脚注内容。 ↩︎

1.2 输出

Wed, 01 Apr 2026 10:00:00 +0800

输出

概念说明

Go 常用 fmt 包完成控制台输出。
输出函数的核心区别在于是否换行、是否格式化。

语法/规则

fmt.Print()：输出内容，不自动换行。
fmt.Println()：输出内容，并在末尾自动换行。
fmt.Printf()：按格式化占位符输出，例如 %s、%d、%.1f。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 name := "阿斌"
 age := 18
 score := 93.5

 fmt.Print("姓名：") // Print 不自动换行
 fmt.Println(name) // Println 会自动换行
 fmt.Printf("年龄：%d\n", age) // %d 用来输出整数
 fmt.Printf("成绩：%.1f\n", score) // %.1f 表示保留 1 位小数
}

输出结果：

1
2
3


姓名：阿斌
年龄：18
成绩：93.5

常见错误

忘记导入 fmt，会导致 undefined: fmt。
Printf 占位符与变量类型不匹配，输出会出现 %!d(string=...) 这类提示。
需要换行时却使用 Print，会导致多段输出挤在同一行。

1.3 列表

Thu, 09 Apr 2026 12:05:00 +0800

列表语法概览

Markdown 中常用的列表有 3 种：

无序列表：-、*、+
有序列表：1.、2.、3.
任务列表（GFM 扩展）：- [ ]、- [x]

无序列表

无序列表可以使用 -、* 或 + 作为标记，后面需要加一个空格。
实际写作中建议统一使用一种符号（通常是 -），保持文档风格一致。

1
2
3


- 第一项
- 第二项
- 第三项

渲染效果：

第一项
第二项
第三项

有序列表

有序列表使用“数字 + 英文句点 + 空格”。

1
2
3


1. 第一项
2. 第二项
3. 第三项

渲染效果：

第一项
第二项
第三项

自动编号技巧

很多 Markdown 解析器会自动重排序号，因此你也可以都写成 1.。

1
2
3


1. 需求分析
1. 原型设计
1. 开发实现

渲染效果：

需求分析
原型设计
开发实现

列表嵌套

嵌套列表依赖缩进，建议使用 2 或 4 个空格，并在全文保持一致。

无序列表嵌套

1
2
3
4
5
6
7
8
9


- 水果
 - 苹果
 - 红苹果
 - 绿苹果
 - 香蕉
 - 橙子
- 蔬菜
 - 胡萝卜
 - 白菜

渲染效果：

水果
- 苹果
  - 红苹果
  - 绿苹果
- 香蕉
- 橙子
蔬菜
- 胡萝卜
- 白菜

有序列表嵌套

1
2
3
4
5
6
7


1. 准备阶段
 1. 收集资料
 2. 制定计划
2. 执行阶段
 1. 开始实施
 2. 监控进度
3. 总结阶段

渲染效果：

准备阶段
1. 收集资料
2. 制定计划
执行阶段
1. 开始实施
2. 监控进度
总结阶段

混合嵌套

1
2
3
4
5
6
7


1. 主要任务
 - 子任务 A
 - 子任务 B
 1. 详细步骤 1
 2. 详细步骤 2
 - 子任务 C
2. 次要任务

渲染效果：

主要任务
- 子任务 A
- 子任务 B
  1. 详细步骤 1
  2. 详细步骤 2
- 子任务 C
次要任务

任务列表

任务列表属于 GitHub Flavored Markdown（GFM）扩展，常用于 TODO 清单。

基本语法

1
2
3


- [ ] 未完成的任务
- [x] 已完成的任务
- [ ] 另一个未完成的任务

渲染效果：

未完成的任务
已完成的任务
另一个未完成的任务

实战示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


### 项目待办清单

#### 设计阶段
- [x] 需求分析
- [x] 原型设计
- [ ] UI 设计

#### 开发阶段
- [ ] 前端开发
 - [x] 页面布局
 - [ ] 交互功能
 - [ ] 响应式适配
- [ ] 后端开发
 - [ ] 数据库设计
 - [ ] API 开发
 - [ ] 性能优化

#### 测试阶段
- [ ] 单元测试
- [ ] 集成测试
- [ ] 用户验收测试

渲染效果：

项目待办清单

设计阶段

需求分析
原型设计
UI 设计

开发阶段

前端开发
- 页面布局
- 交互功能
- 响应式适配
后端开发
- 数据库设计
- API 开发
- 性能优化

测试阶段

单元测试
集成测试
用户验收测试

常见错误

列表标记后漏写空格，例如 -第一项，会导致列表不生效。
嵌套层级缩进不一致，导致结构错位。
无序列表混用 -、*、+，文档风格不统一。
任务列表的复选框写成 - [] 或 - [X ]，应使用 - [ ] 或 - [x]。

1.3 输入

Wed, 01 Apr 2026 10:00:00 +0800

输入

概念说明

Go 可以通过 fmt 包从标准输入读取数据。
常见入门函数是 fmt.Scan 和 fmt.Scanln。

语法/规则

读取变量时必须传入地址，例如 &name、&age。
fmt.Scan(&a, &b) 按空格分隔读取多个值。
函数会返回读取数量和错误信息，应优先检查 err。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 var name string
 var age int

 fmt.Print("请输入姓名和年龄（空格分隔）：")
 n, err := fmt.Scan(&name, &age) // 传入变量地址，按空格读取两个值
 if err != nil { // 读取失败时先处理错误
 fmt.Println("输入有误：", err)
 return
 }

 fmt.Printf("成功读取 %d 项：name=%s, age=%d\n", n, name, age)
}

输出结果：

1
2


请输入姓名和年龄（空格分隔）：阿斌 18
成功读取 2 项：name=阿斌, age=18

常见错误

忘记写 &，例如 fmt.Scan(name)，会导致类型不匹配。
输入类型与变量类型不一致，例如给 int 输入文字，会触发读取错误。
忽略 err，输入异常时程序行为不明确，不利于排查问题。

1.4 格式化输出

Sun, 12 Apr 2026 10:00:00 +0800

格式化输出

概念说明

格式化输出用于把变量按照指定格式组合成文本。
Go 里最常用的是 fmt.Printf，它会根据格式字符串中的占位符，把后面的变量依次填进去。

例如：

1

fmt.Printf("姓名：%s，年龄：%d\n", name, age)

其中 %s、%d 就是占位符。
格式化输出常用于输出资料卡、计算结果、调试信息、表格对齐等场景。

语法/规则

fmt.Printf("格式字符串", 值1, 值2, ...)：格式化并直接输出到控制台。
fmt.Sprintf("格式字符串", 值1, 值2, ...)：格式化后返回字符串，不会直接输出。
占位符数量通常要和后面的值数量匹配。
占位符类型要和变量类型匹配，例如字符串用 %s，整数用 %d，小数常用 %f。
\n 表示换行，\t 表示制表符，%% 表示输出一个百分号。

常用占位符

占位符	含义	示例
`%v`	按默认格式输出任意值	`fmt.Printf("%v\n", score)`
`%T`	输出变量类型	`fmt.Printf("%T\n", score)`
`%s`	输出字符串	`fmt.Printf("%s\n", name)`
`%d`	输出十进制整数	`fmt.Printf("%d\n", age)`
`%f`	输出浮点数	`fmt.Printf("%f\n", price)`
`%.2f`	输出浮点数并保留 2 位小数	`fmt.Printf("%.2f\n", price)`
`%t`	输出布尔值	`fmt.Printf("%t\n", passed)`
`%c`	按字符输出	`fmt.Printf("%c\n", ch)`
`%q`	带引号输出字符串或字符，适合观察空字符串、空格等内容	`fmt.Printf("%q\n", text)`
`%%`	输出百分号	`fmt.Printf("完成度：%d%%\n", percent)`

基础格式化示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 name := "阿斌"
 age := 18
 score := 93.456
 passed := true

 fmt.Printf("姓名：%s\n", name)
 fmt.Printf("年龄：%d\n", age)
 fmt.Printf("成绩：%.2f\n", score)
 fmt.Printf("是否通过：%t\n", passed)
 fmt.Printf("默认格式：%v\n", score)
 fmt.Printf("变量类型：%T\n", score)
}

输出结果：

1
2
3
4
5
6


姓名：阿斌
年龄：18
成绩：93.46
是否通过：true
默认格式：93.456
变量类型：float64

说明：%.2f 表示保留 2 位小数，输出时会按指定精度进行舍入。

宽度、补零与对齐示例

格式化输出还可以控制最小宽度、补零和左右对齐，常用于输出表格或编号。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 id := 7
 name := "Go"
 price := 19.9

 fmt.Printf("|%4d|%-6s|%8.2f|\n", id, name, price)
 fmt.Printf("订单号：%04d\n", id)
}

输出结果：

1
2


| 7|Go | 19.90|
订单号：0007

说明：

%4d 表示整数至少占 4 个字符宽度，默认右对齐。
%-6s 表示字符串至少占 6 个字符宽度，并且左对齐。
%8.2f 表示浮点数至少占 8 个字符宽度，并保留 2 位小数。
%04d 表示整数至少占 4 位，不足的地方用 0 补齐。

生成格式化字符串

如果只是想得到一段格式化后的字符串，而不是立刻输出，可以使用 fmt.Sprintf。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 name := "小王"
 score := 88.5

 message := fmt.Sprintf("%s的成绩是 %.1f 分", name, score)
 fmt.Println(message)
}

输出结果：

1

小王的成绩是 88.5 分

说明：fmt.Sprintf 会返回字符串，所以可以先保存到变量里，再用于输出、拼接或后续处理。

常见错误

占位符和变量类型不匹配，例如用 %d 输出字符串，会出现 %!d(string=...) 这类提示。
忘记写 \n，多次 Printf 的输出会挤在同一行。
占位符数量和变量数量不一致，容易出现 %!s(MISSING) 或多余参数提示。
把 fmt.Sprintf 当成 fmt.Printf 使用，只调用却不接收返回值，控制台不会看到输出。
想输出百分号时直接写 %，应改成 %%。

1.4 引用块

Thu, 09 Apr 2026 12:05:00 +0800

引用块语法概览

引用块（Blockquote）用于标记“引用内容”或“补充说明”。
核心写法是在行首使用 >，后面加一个空格。

1

> 这是一段引用

单级引用

基本写法

1
2


> 区块引用
> 学的不仅是技术，更是思路

渲染效果：

区块引用学的不仅是技术，更是思路

多行与多段落

多段落时，空行也建议带上 >，可读性更好，也更稳定。

1
2
3
4


> 这是引用的第一行。
> 这是引用的第二行。
>
> 这是引用的第二段。

渲染效果：

这是引用的第一行。
这是引用的第二行。

这是引用的第二段。

懒惰续行（可选写法）

CommonMark 支持“懒惰续行”：段落续行可以省略 >。
但为了兼容不同解析器，实际写作中仍建议每一行都写 >。

1
2
3


> 这是一个长引用，
包含多行内容，
这是懒惰续行写法。

渲染效果：

这是一个长引用，包含多行内容，这是懒惰续行写法。

多级嵌套引用

一个 > 是第一层，两个 >> 是第二层，三个 >>> 是第三层。

1
2
3


> 最外层
>> 第一层嵌套
>>> 第二层嵌套

渲染效果：

最外层

第一层嵌套

第二层嵌套

实际应用示例

1
2
3
4
5


> **用户反馈**：这个功能很有用！
>
>> **开发团队回复**：感谢反馈，我们会继续优化。
>>
>>> **项目经理补充**：预计下个版本会增加更多改进。

渲染效果：

用户反馈：这个功能很有用！

开发团队回复：感谢反馈，我们会继续优化。

项目经理补充：预计下个版本会增加更多改进。

引用块与其他元素组合

引用块中使用列表

1
2
3
4
5
6
7
8


> 今日计划：
> 1. 阅读文档
> 2. 整理笔记
> 3. 输出总结
>
> 待办清单：
> - 完成示例
> - 提交修改

渲染效果：

今日计划：

阅读文档

整理笔记

输出总结

待办清单：

完成示例

提交修改

列表中使用引用块

在列表项中放引用块时，要注意缩进对齐。

1
2
3
4


1. 第一项
 > 这是第一项的补充说明
 > 这是第二行说明
2. 第二项

渲染效果：

第一项

这是第一项的补充说明这是第二行说明
第二项

引用块中使用代码块

1
2
3
4
5
6


> 执行以下命令启动项目：
>
> ```bash
> npm install
> npm run dev
> ```

渲染效果：

执行以下命令启动项目：
1
2
npm install
npm run dev

常见错误

> 后面忘记加空格，导致语法可读性差或渲染不一致。
使用全角符号 ＞ 代替半角 >，导致引用失效。
列表中嵌套引用时缩进不足，导致结构错位。
多段落引用时空行没带 >，在部分解析器中可能意外“跳出引用块”。

1.5 练习

Sun, 12 Apr 2026 10:00:00 +0800

练习

学完本章你应该掌握

能使用 var 和 := 完成基础变量声明，并理解零值、全局变量、局部变量的区别。
能根据场景选择 fmt.Print、fmt.Println、fmt.Printf，写出普通输出和格式化输出。
能使用 fmt.Scan、fmt.Scanln 读取一个或多个输入值，并知道为什么要传变量地址。
能识别并修正常见输入输出错误，例如占位符类型不匹配、读取时漏写 &、把 := 用在函数外。
能把本章的输入输出知识迁移到稍复杂一点的控制台交互场景，例如整行读取、输入转换、简单输入校验。

简单

第 1 题：声明并输出三个变量

第 1 题简单

编写一个 Go 程序，完成下面要求：

声明 name、age、city 三个变量。
至少使用一次 var，至少使用一次 :=。
把这三个变量分别输出到控制台，每个值占一行。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 var name string = "阿斌"
 age := 18
 var city = "上海"

 fmt.Println(name)
 fmt.Println(age)
 fmt.Println(city)
}

第 2 题：观察变量的零值

第 2 题简单

声明下面三个变量，但先不要赋值：

score int
nickname string
passed bool

然后把它们输出出来，观察默认值分别是什么。

扩展思考：既然字符串内容直接输出时不明显，怎么做才能输出 " " 呢？

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 var score int
 var nickname string
 var passed bool

 fmt.Println(score)
 fmt.Println(nickname)
 fmt.Println(passed)
}

输出结果：

1
2
3


0

false

说明：第二行是空字符串，所以看起来像“空了一行”。

扩展写法，可以把下面代码放到 main 函数里继续观察：

1
2
3
4
5
6


space := " "

fmt.Printf("nickname=%q, len=%d\n", nickname, len(nickname))
fmt.Printf("space=%q, len=%d\n", space, len(space))
fmt.Println("[" + nickname + "]")
fmt.Println("[" + space + "]")

输出结果：

1
2
3
4


nickname="", len=0
space=" ", len=1
[]
[ ]

说明：len 可以查看字符串长度。空字符串 "" 的长度是 0，空格字符串 " " 的长度是 1。如果只是 fmt.Print(" ") 或 fmt.Println(" ")，控制台确实会输出一个空格，但肉眼很难看出来；用 %q 或给它加上 [] 这样的边界，就能明显看出它存在。

第 3 题：写出下面程序的输出结果

第 3 题简单

阅读下面代码，写出它的输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 fmt.Print("Go")
 fmt.Print("语言")
 fmt.Println("入门")
 fmt.Printf("第%d课\n", 1)
}

查看参考答案

1
2


Go语言入门
第1课

说明：前两个 Print 不换行，Println 会在末尾补一个换行。

第 4 题：补全 `Printf` 的占位符

第 4 题简单

已知下面三个变量：

1
2
3


name := "小李"
age := 18
score := 96.5

请补全这一行代码中的占位符，让成绩保留 1 位小数：

1

fmt.Printf("姓名：__，年龄：__，成绩：__\n", name, age, score)

查看参考答案

1

fmt.Printf("姓名：%s，年龄：%d，成绩：%.1f\n", name, age, score)

说明：

%s 输出字符串
%d 输出整数
%.1f 输出浮点数并保留 1 位小数

一般

第 5 题：读取一个姓名并输出欢迎语

第 5 题一般

编写一个程序：

提示用户输入姓名
使用 fmt.Scanln 读取一个字符串
输出 你好，张三

其中 张三 要替换成用户真正输入的内容。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 var name string

 fmt.Print("请输入姓名：")
 fmt.Scanln(&name)

 fmt.Printf("你好，%s\n", name)
}

第 6 题：同时读取姓名和年龄

第 6 题一般

编写一个程序，要求用户按“姓名年龄”的格式输入，例如：

1

阿斌 18

程序读取后输出：

1

name=阿斌, age=18

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 var name string
 var age int

 fmt.Print("请输入姓名和年龄（空格分隔）：")
 fmt.Scan(&name, &age)

 fmt.Printf("name=%s, age=%d\n", name, age)
}

第 7 题：区分全局变量和局部变量

第 7 题一般

编写一个程序：

在函数外定义全局变量 courseName
在 main 函数里定义局部变量 studentName
输出一句话：欢迎小王学习 Go 入门

其中变量值可以自行设置。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

var courseName = "Go 入门"

func main() {
 studentName := "小王"
 fmt.Printf("欢迎 %s 学习 %s\n", studentName, courseName)
}

第 8 题：修正一段有问题的代码

第 8 题一般

下面这段代码有两个明显问题，请改正后让它可以正常运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var name string

 fmt.Print("请输入姓名：")
 fmt.Scan(name)
 fmt.Printf("你好，%d\n", name)
}

查看参考答案

修正后的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var name string

 fmt.Print("请输入姓名：")
 fmt.Scan(&name)
 fmt.Printf("你好，%s\n", name)
}

两个问题分别是：

fmt.Scan 读取变量时需要传地址，所以应该写成 &name
name 是字符串，Printf 里应该使用 %s，不能使用 %d

第 9 题：格式化输出一张成绩单

第 9 题一般

已知下面几个变量：

1
2
3
4
5
6


name := "小王"
age := 18
score := 93.456
rank := 7
passed := true
progress := 85

请使用 fmt.Printf 输出下面这张成绩单：

1
2
3
4
5
6


姓名：小王
年龄：18
成绩：93.5
排名：007
是否通过：true
完成度：85%

要求：

成绩保留 1 位小数。
排名不足 3 位时在前面补 0。
完成度后面要正确输出百分号。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func main() {
 name := "小王"
 age := 18
 score := 93.456
 rank := 7
 passed := true
 progress := 85

 fmt.Printf("姓名：%s\n", name)
 fmt.Printf("年龄：%d\n", age)
 fmt.Printf("成绩：%.1f\n", score)
 fmt.Printf("排名：%03d\n", rank)
 fmt.Printf("是否通过：%t\n", passed)
 fmt.Printf("完成度：%d%%\n", progress)
}

说明：

%s 用来输出字符串。
%d 用来输出整数。
%.1f 表示浮点数保留 1 位小数。
%03d 表示整数至少占 3 位，不足的地方用 0 补齐。
%t 用来输出布尔值。
%% 用来输出一个真正的百分号。

进阶

下面两题会少量接触本章之外、但和输入输出强相关的内容，更接近真实开发里的控制台交互场景。

第 10 题：读取一整行自我介绍

第 10 题进阶

在前面的 Scan / Scanln 示例里，我们读取的大多是一个值或空格分隔的多个值。
现在请尝试完成一个稍微更真实的场景：

提示用户输入一句自我介绍
允许这段输入里出现空格
程序读取整行内容后，输出 你的自我介绍是：xxx

例如输入：

1

大家好，我正在学习 Go 语言

查看参考答案

先给出一个更简洁的主答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "bufio"
 "fmt"
 "os"
)

func main() {
 scanner := bufio.NewScanner(os.Stdin)

 fmt.Print("请输入一句自我介绍：")
 if scanner.Scan() {
 intro := scanner.Text()
 fmt.Printf("你的自我介绍是：%s\n", intro)
 }

 if err := scanner.Err(); err != nil {
 fmt.Println("输入有误：", err)
 }
}

说明：

bufio.NewScanner(os.Stdin) 可以按整行读取输入
scanner.Text() 返回当前读到的这一整行内容
这版更适合初学时先理解“如何读取带空格的一整行”

扩展写法：如果你想进一步了解更接近底层的按行读取方式，也可以这样写：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
 "strings"
)

func main() {
 reader := bufio.NewReader(os.Stdin)

 fmt.Print("请输入一句自我介绍：")
 intro, err := reader.ReadString('\n')
 if err != nil && err != io.EOF {
 fmt.Println("输入有误：", err)
 return
 }

 intro = strings.TrimSpace(intro)
 fmt.Printf("你的自我介绍是：%s\n", intro)
}

补充说明：

ReadString('\n') 会一直读取，直到遇到换行符
strings.TrimSpace 用来去掉输入末尾的换行
如果读到文件结尾前已经拿到内容，ReadString 可能同时返回内容和 io.EOF，这时仍然可以继续处理输入

第 11 题：把字符串年龄转换成整数

第 11 题进阶

请编写一个程序：

先读取用户输入的年龄，但先把它当成字符串读取
再把这个字符串转换成整数
最后输出 明年你的年龄是：xx

例如输入：

1

18

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
 "fmt"
 "strconv"
)

func main() {
 var ageText string

 fmt.Print("请输入年龄：")
 _, err := fmt.Scanln(&ageText)
 if err != nil {
 fmt.Println("输入有误：", err)
 return
 }

 age, err := strconv.Atoi(ageText)
 if err != nil {
 fmt.Println("年龄必须是整数：", err)
 return
 }

 fmt.Printf("明年你的年龄是：%d\n", age+1)
}

说明：

strconv.Atoi 可以把字符串转换成整数
这类写法很常见，适合处理“先读入文本，再做类型转换”的场景

1.5 代码

Thu, 09 Apr 2026 21:25:00 +0800

代码语法概览

Markdown 中常用的代码相关语法有 4 类：

行内代码：反引号包裹
围栏代码块：使用 ``` 或 ~~~
缩进代码块：每行前 4 个空格（或 1 个 Tab）
diff 代码块：```diff 用于展示增删改

行内代码

在段落中表示函数名、变量名、命令时，使用单反引号 ` 包裹。

1

请调用 `printf()` 输出结果。

渲染效果：
请调用 printf() 输出结果。

行内代码中包含反引号

原则：内容里有几个连续反引号，外层就用更多个反引号包裹。

1

``使用 `反引号` 包裹代码``

渲染效果：
使用 `反引号` 包裹代码

1

```这里包含 `` 双反引号 ```

渲染效果：
这里包含 `` 双反引号

代码块

缩进式代码块

每行前添加 4 个空格（或 1 个 Tab）即可形成代码块。

1
2
3
4
5
6
7


正常文本段落

 这是缩进式代码块
 每行前面有四个空格
 保持原始缩进格式

继续正常文本

渲染效果：
正常文本段落

这是缩进式代码块
每行前面有四个空格
保持原始缩进格式

继续正常文本

围栏代码块（三反引号）

推荐写法：使用三反引号，并在首行声明语言类型，方便语法高亮。

1
2
3
4
5


```javascript
document.addEventListener("DOMContentLoaded", () => {
 console.log("Hello Markdown");
});
```

渲染效果：

1
2
3


document.addEventListener("DOMContentLoaded", () => {
 console.log("Hello Markdown");
});

代码块嵌套

在文档里讲解 Markdown 语法时，常常需要“在代码块里展示代码块”。

核心原则：外层围栏符号数量要大于内层。

外层使用更多反引号

1
2
3
4
5


````markdown
```javascript
console.log("nested block");
```
````

渲染效果：

1
2
3


```javascript
console.log("nested block");
```

外层使用波浪号 `~~~`

1
2
3
4
5


~~~markdown
```javascript
console.log("nested block");
```
~~~

渲染效果：

1
2
3


```javascript
console.log("nested block");
```

代码差异对比（diff）

diff 代码块用于展示版本变更：
+ 表示新增，- 表示删除。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


```diff
function calculateTotal(items) {
- let total = 0;
+ let total = 0.0;

 for (const item of items) {
- total += item.price;
+ total += Number(item.price);
 }

+ // 保留两位小数
+ total = Math.round(total * 100) / 100;
 return total;
}
```

渲染效果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


function calculateTotal(items) {
- let total = 0;
+ let total = 0.0;

 for (const item of items) {
- total += item.price;
+ total += Number(item.price);
 }

+ // 保留两位小数
+ total = Math.round(total * 100) / 100;
 return total;
}

常见错误

行内代码分隔符数量不够，导致反引号提前闭合。
代码块前后缺少空行，影响渲染稳定性（不同解析器表现可能不同）。
外层与内层都用三反引号，造成嵌套代码块断裂。
混用 Tab 和空格，导致缩进式代码块格式错乱。

1.6 链接

Thu, 09 Apr 2026 22:23:00 +0800

链接基础语法

Markdown 中最常见的链接写法有 3 种：

行内链接：[链接文字](URL)
带标题的链接：[链接文字](URL "可选标题")
自动链接：<URL>

1. 行内链接

1

这是一个链接 [Hobin's Blog](https://bhb6.top)

渲染效果：
这是一个链接 Hobin’s Blog

2. 带标题的链接

标题会在鼠标悬停时显示。

1
2


欢迎访问 [GitHub](https://github.com "全球最大的代码托管平台") 官网
这是 [百度搜索](https://www.baidu.com "百度一下，你就知道")

渲染效果：
欢迎访问 GitHub 官网
这是百度搜索

3. 自动链接

1

<https://bhb6.top>

渲染效果：
https://bhb6.top

参考式链接

参考式链接适合在文档中重复使用同一 URL，让正文更干净。

基本语法

1
2
3


[链接文字][参考标签]

[参考标签]: URL "可选标题"

示例：

1
2
3
4
5


这个链接用 google 作为参考标签 [Google][google]
这个链接用 hobin 作为参考标签 [Hobin][hobin]

[google]: https://www.google.com/ "Google 搜索"
[hobin]: https://bhb6.top/ "Hobin 的博客"

渲染效果：
这个链接用 google 作为参考标签 Google
这个链接用 hobin 作为参考标签 Hobin

简化写法

当参考标签与链接文字相同时，可以省略第二个方括号。

1
2
3


我喜欢使用 [GitHub][] 来管理代码。

[GitHub]: https://github.com/

常见错误

把 [] 或 () 写成全角符号，会导致链接无法解析。
URL 和可选标题之间必须有空格：(URL "标题")。
方括号与圆括号必须成对出现，少一个都会失效。
示例中建议优先使用 https://，避免使用不安全的 http://。

2.1 数据类型

Fri, 03 Apr 2026 10:00:00 +0800

数据类型

概念说明

Go 是静态类型语言，变量在声明后类型固定。
入门阶段先掌握 int、float64、bool、string 这四类最常用类型。

语法/规则

整数类型常用 int。
小数类型常用 float64。
布尔类型是 bool，只有 true 和 false。
字符串类型是 string。
不同数值类型不能直接运算，需要显式转换。

声明并输出常见类型示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 var age int = 18 // 整数
 var price float64 = 19.9 // 浮点数
 var passed bool = true // 布尔值
 var name string = "阿斌" // 字符串

 fmt.Printf("age=%d\n", age)
 fmt.Printf("price=%.1f\n", price)
 fmt.Printf("passed=%t\n", passed)
 fmt.Printf("name=%s\n", name)
}

输出结果：

1
2
3
4


age=18
price=19.9
passed=true
name=阿斌

类型转换示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 total := 95
 count := 10
 avg := float64(total) / float64(count) // 运算前先把 int 转成 float64

 fmt.Printf("平均分：%.1f\n", avg)
}

输出结果：

1

平均分：9.5

常见错误

不同类型直接运算，例如 int 和 float64 直接相除会报错。
使用错误的格式化占位符，例如用 %d 打印 float64。
把字符串直接赋值给数字变量，类型不兼容会导致编译失败。

2.2 整数

Fri, 03 Apr 2026 10:00:00 +0800

整数

概念说明

整数用于保存没有小数部分的数值。
Go 的整数分为有符号整数和无符号整数两类。

语法/规则

有符号整数：int8、int16、int32、int64、int。
无符号整数：uint8、uint16、uint32、uint64、uint。
整数字面量默认类型是 int。
uint8 的别名是 byte，常用于字节数据。
int 和 uint 的位宽与平台相关，在 64 位平台通常是 64 位。
不同整数类型不能直接运算，需要显式类型转换。

声明与范围示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
 "fmt"
 "math"
 "strconv"
)

func main() {
 var age int = 18
 var small uint8 = 255 // uint8 只能表示非负整数
 var delta int8 = -12 // int8 可以表示负数

 fmt.Printf("age=%d\n", age)
 fmt.Printf("small=%d\n", small)
 fmt.Printf("delta=%d\n", delta)
 fmt.Printf("当前平台 int 位数：%d\n", strconv.IntSize) // 查看当前平台 int 的位数
 fmt.Printf("int8 范围：%d ~ %d\n", math.MinInt8, math.MaxInt8) // 查看 int8 的取值范围
}

输出结果：

1
2
3
4
5


age=18
small=255
delta=-12
当前平台 int 位数：64
int8 范围：-128 ~ 127

类型转换后再运算示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var total int32 = 100
 var extra int64 = 20

 sum := int64(total) + extra // 不同整数类型运算前要先转换
 fmt.Printf("sum=%d\n", sum)
}

输出结果：

1

sum=120

常见错误

不同整数类型直接运算，例如 int32 + int64，会编译报错。
给无符号整数赋负数，例如 var n uint8 = -1，会编译报错。
常量超出类型范围，例如 var n int8 = 128，会编译报错。

2.3 浮点型

Fri, 03 Apr 2026 10:00:00 +0800

浮点型

概念说明

浮点型用于保存带小数部分的数值。
Go 常用的浮点类型是 float32 和 float64。

语法/规则

float32 占 32 位，float64 占 64 位。
浮点字面量默认类型是 float64。
float32 精度低于 float64，同一个数值可能出现不同的近似结果。
浮点数遵循二进制表示，很多十进制小数不能被精确表示。

浮点声明与输出示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
 "fmt"
 "math"
)

func main() {
 var price32 float32 = 19.9 // float32 精度较低
 var price64 float64 = 19.9 // float64 更常用

 fmt.Printf("price32=%.8f\n", price32)
 fmt.Printf("price64=%.8f\n", price64)
 fmt.Printf("float32 最大值约：%.1e\n", math.MaxFloat32)
 fmt.Printf("float64 最大值约：%.1e\n", math.MaxFloat64)
}

输出结果：

1
2
3
4


price32=19.89999962
price64=19.90000000
float32 最大值约：3.4e+38
float64 最大值约：1.8e+308

精度现象示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 sum := 0.1 + 0.2 // 浮点运算可能存在精度误差

 fmt.Printf("sum=%.2f\n", sum)
 fmt.Printf("sum == 0.3 ? %t\n", sum == 0.3) // 直接比较结果可能不是预期值
}

输出结果：

1
2


sum=0.30
sum == 0.3 ? false

常见错误

直接用 == 比较浮点数是否相等，容易因为精度误差得到意外结果。
把 int 和 float64 直接运算，不做类型转换会编译报错。
用 %d 打印浮点数，格式化占位符与类型不匹配。

2.4 字符

Fri, 03 Apr 2026 10:00:00 +0800

字符

概念说明

Go 中的“字符”本质上是整数码点。
单个字符常见用两种类型保存：byte 和 rune。

语法/规则

字符字面量使用单引号，例如 'A'、'中'。
byte 是 uint8 的别名，适合保存单字节字符。
rune 是 int32 的别名，适合保存 Unicode 字符。
%c 按字符输出，%d 按整数码点输出。
字符可以参与整数运算，例如 'A' + 1。

byte 与 rune 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var letter byte = 'A' // byte 适合单字节字符
 var chinese rune = '中' // rune 适合表示中文等 Unicode 字符

 fmt.Printf("letter: %c, code=%d\n", letter, letter)
 fmt.Printf("chinese: %c, code=%d\n", chinese, chinese)
}

输出结果：

1
2


letter: A, code=65
chinese: 中, code=20013

字符运算示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var c rune = 'A'
 next := c + 1 // 字符本质是码点，可以参与运算

 fmt.Printf("当前字符：%c\n", c)
 fmt.Printf("下一个字符：%c\n", next)
}

输出结果：

1
2


当前字符：A
下一个字符：B

常见错误

用双引号声明字符，例如 "A"，这实际上是字符串而不是字符。
用 byte 保存中文字符，例如 var b byte = '中'，会因超出范围编译报错。
直接 Println 字符变量时看到的是数字码点，误以为字符值不对，应配合 %c 输出查看。

2.5 字符串

Fri, 03 Apr 2026 10:00:00 +0800

字符串

概念说明

字符串用于表示一段文本。
在 Go 中，字符串使用双引号或反引号表示，并且字符串是不可变的。

语法/规则

双引号字符串会处理转义字符，例如 \n、\t、\"。
反引号字符串是原始字符串，内容按原样保留，常用于多行文本。
字符串拼接可以使用 +。
len(s) 返回的是字节长度，不是字符个数。
字符串下标可读不可写，不能通过 s[0] = 'x' 修改字符串内容。

声明与转义示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 name := "阿斌"
 message := "你好，" + name // 字符串可以用 + 拼接

 fmt.Println(message)
 fmt.Println("\"Go\" 是一门编程语言")
}

输出结果：

1
2


你好，阿斌
"Go" 是一门编程语言

原始字符串与长度示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
 "fmt"
 "unicode/utf8"
)

func main() {
 text := `第一行
第二行\t不会转义`
 word := "你好" // 中文在 UTF-8 下通常占多个字节

 fmt.Println(text) // 反引号中的内容会按原样保留
 fmt.Printf("len(word)=%d\n", len(word)) // len 返回字节数
 fmt.Printf("字符数=%d\n", utf8.RuneCountInString(word)) // 统计字符个数
}

输出结果：

1
2
3
4


第一行
第二行\t不会转义
len(word)=6
字符数=2

说明：

len(s) 的单位是字节（byte），不是“字符个数”。
1 byte = 8 bit，所以 len("你好") == 6 的含义是“6 个字节（即 6 个 8 位，共 48 位）”。
Go 字符串默认按 UTF-8 存储，常见中文（如 你、好）通常各占 3 个字节，所以一共是 6 个字节。
如果要统计“字符个数”，使用 utf8.RuneCountInString 更直观。

可对比理解：

len("A") == 1（英文/ASCII 常见 1 字节）
len("你") == 3（中文常见 3 字节）
len("😀") == 4（Emoji 常见 4 字节）

常见转换补充

字符串和整数互转，初学阶段最常用的是 strconv.Atoi 与 strconv.Itoa。
字符串转字符切片，常用 []rune(str)，更适合处理中英文混合内容。
字符串转字节切片，常用 []byte(str)，更适合网络传输、编码和文件读写场景。

常见错误

用单引号定义字符串，例如 'hello'，会编译报错。
误以为 len("你好") 返回 2，实际返回的是 UTF-8 字节数 6。
试图通过下标直接修改字符串内容，会出现 cannot assign to 编译错误。

2.6 布尔型

Fri, 03 Apr 2026 10:00:00 +0800

布尔型

概念说明

布尔型用于表示真假状态，只有 true 和 false 两个值。
它常用于条件判断和逻辑运算。

语法/规则

布尔类型是 bool，零值是 false。
比较运算会得到布尔值，例如 score >= 60。
逻辑运算符包括 &&（与）、||（或）、!（非）。
Go 不支持把整数直接当布尔值使用，也不能把 bool 当数字计算。

布尔表达式示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 score := 92
 passed := score >= 60 // 比较运算的结果是 bool
 vip := true
 canJoin := passed && vip // && 表示两个条件都要满足

 fmt.Printf("passed=%t\n", passed)
 fmt.Printf("canJoin=%t\n", canJoin)
}

输出结果：

1
2


passed=true
canJoin=true

条件判断示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 loggedIn := true
 hasToken := false

 if loggedIn || hasToken { // || 表示满足一个条件即可
 fmt.Println("允许访问")
 } else {
 fmt.Println("拒绝访问")
 }
}

输出结果：

1

允许访问

常见错误

把 0 或 1 当成布尔值使用，Go 中这是不合法的。
在条件判断里写非布尔表达式，例如 if 1 {}，会编译报错。
对布尔值做加减运算，例如 true + 1，会编译报错。

2.7 练习

Sun, 12 Apr 2026 10:10:00 +0800

练习

学完本章你应该掌握

能声明并区分 int、float64、bool、string、byte、rune 等常见类型，并使用正确的格式化占位符输出。
能识别字符与字符串的区别，理解单引号、双引号，以及 byte、rune 的基本使用场景。
能在整数与浮点数混合计算时完成显式类型转换，避免整数除法和类型不兼容问题。
能理解字符串的字节长度和字符个数不是一回事，并在中英文混合文本中做出正确判断。
能识别并修正本章常见错误，例如不同类型直接运算、错误的字面量写法、错误的输出格式。
能把本章知识迁移到基础数据处理场景，例如资料录入、数值比较、文本数字转换。

简单

第 1 题：写出不同类型的输出结果

第 1 题简单

阅读下面代码，写出它的输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 age := 18
 price := 19.9
 passed := false
 first := 'G'

 fmt.Printf("age=%d\n", age)
 fmt.Printf("price=%.1f\n", price)
 fmt.Printf("passed=%t\n", passed)
 fmt.Printf("first=%c, code=%d\n", first, first)
}

查看参考答案

1
2
3
4


age=18
price=19.9
passed=false
first=G, code=71

说明：%c 按字符输出，%d 按整数码点输出，所以 'G' 会显示成字符 G 和码点 71。

第 2 题：判断哪些声明是合法的

第 2 题简单

下面这些声明里，哪些可以通过编译，哪些不可以？请分别写出结果，并简要说明原因。

1
2
3
4
5
6


A. var a int = 18
B. var b float64 = 18
C. var c bool = 1
D. var d byte = 'A'
E. var e string = 'A'
F. var f rune = '中'

查看参考答案

可以通过编译的是：

1

A、B、D、F

不能通过编译的是：

1

C、E

原因说明：

A 合法，18 是整数常量，可以赋值给 int。
B 合法，18 是无类型整数常量，可以赋值给 float64。
C 不合法，bool 只能是 true 或 false，不能写成 1。
D 合法，'A' 是字符字面量，byte 可以保存单字节字符。
E 不合法，'A' 是字符，不是字符串；字符串应该用双引号，例如 "A"。
F 合法，rune 适合表示 Unicode 字符，例如中文。

第 3 题：补全平均值计算中的类型转换

第 3 题简单

已知下面代码：

1
2
3
4


total := 95
count := 2
avg := ________
fmt.Printf("平均分：%.1f\n", avg)

请补全 avg 的计算，让程序输出：

1

平均分：47.5

查看参考答案

1

avg := float64(total) / float64(count)

说明：total 和 count 都是 int，直接相除会得到整数结果，所以要先转成 float64。

第 4 题：修正字符输出程序

第 4 题简单

下面代码的目标是输出字符 A 和字符 上，但现在有问题。请改正后让它正常运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var first byte = "A"
 var city rune = '上'

 fmt.Printf("first=%s\n", first)
 fmt.Printf("city=%d\n", city)
}

查看参考答案

修正后的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 var first byte = 'A'
 var city rune = '上'

 fmt.Printf("first=%c\n", first)
 fmt.Printf("city=%c\n", city)
}

两个关键问题分别是：

byte 保存字符时要使用单引号，"A" 是字符串，不是字符。
如果想按字符显示，应该使用 %c，而不是 %s 或 %d。

第 5 题：写出布尔表达式的结果

第 5 题简单

阅读下面代码，写出它的输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 score := 58
 retake := true
 vip := false

 a := score >= 60
 b := (score >= 60) || retake
 c := b && !vip

 fmt.Println(a)
 fmt.Println(b)
 fmt.Println(c)
}

查看参考答案

1
2
3


false
true
true

说明：

a 表示 58 >= 60，所以是 false。
b 表示“及格或者允许补考”，因为 retake 是 true，所以结果是 true。
c 表示 b 为真并且不是 vip，所以结果仍然是 true。

一般

第 6 题：解释字符串长度为什么不同

第 6 题一般

阅读下面代码，写出它的输出结果，并说明为什么两个数字不同：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import (
 "fmt"
 "unicode/utf8"
)

func main() {
 word := "Go语言"

 fmt.Printf("len=%d\n", len(word))
 fmt.Printf("runes=%d\n", utf8.RuneCountInString(word))
}

查看参考答案

输出结果：

1
2


len=8
runes=4

原因说明：

len(word) 统计的是字节数，G 和 o 各占 1 个字节，语 和 言 在 UTF-8 中通常各占 3 个字节，所以总共是 8。
utf8.RuneCountInString(word) 统计的是字符个数，所以 Go语言 一共是 4 个字符。

第 7 题：修正混合数值计算程序

第 7 题一般

下面程序想输出：

1
2


sum=120
avg=33.3

但它现在不能正确运行。请改正后让它得到预期结果。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 var total int32 = 100
 var extra int64 = 20

 sum := total + extra
 avg := total / 3

 fmt.Printf("sum=%d\n", sum)
 fmt.Printf("avg=%.1f\n", avg)
}

查看参考答案

修正后的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 var total int32 = 100
 var extra int64 = 20

 sum := int64(total) + extra
 avg := float64(total) / 3

 fmt.Printf("sum=%d\n", sum)
 fmt.Printf("avg=%.1f\n", avg)
}

关键点：

int32 和 int64 不能直接相加，所以 total 需要先转换成 int64。
total / 3 如果保持整数运算，会丢失小数部分，所以要先转成 float64。

第 8 题：编写一张资料卡

第 8 题一般

编写一个程序，要求用户按“姓名年龄身高是否通过”的格式输入，例如：

1

阿斌 18 172.5 true

程序读取后输出：

1

姓名：阿斌，年龄：18，身高：172.5cm，是否通过：true

其中：

姓名使用 string
年龄使用 int
身高使用 float64
是否通过使用 bool

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 var name string
 var age int
 var height float64
 var passed bool

 fmt.Print("请输入姓名、年龄、身高、是否通过：")
 fmt.Scan(&name, &age, &height, &passed)

 fmt.Printf("姓名：%s，年龄：%d，身高：%.1fcm，是否通过：%t\n", name, age, height, passed)
}

说明：这道题的重点不是输入本身，而是让不同类型的变量在同一个小场景里配合使用，并用正确的占位符输出。

进阶

下面两题会少量接触本章之外、但和本章内容强相关的标准库函数，用来帮助你把类型知识放到更真实的问题里。

第 9 题：避免直接比较浮点数

第 9 题进阶

我们知道 0.1 + 0.2 == 0.3 在 Go 里不一定得到 true。
请补全下面程序，让它通过“误差足够小”的方式判断两个浮点数是否近似相等，并输出：

1

approxEqual=true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import (
 "fmt"
 "math"
)

func main() {
 a := 0.1 + 0.2
 b := 0.3

 approxEqual := ______________________
 fmt.Printf("approxEqual=%t\n", approxEqual)
}

查看参考答案

1

approxEqual := math.Abs(a-b) < 0.000001

完整代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import (
 "fmt"
 "math"
)

func main() {
 a := 0.1 + 0.2
 b := 0.3

 approxEqual := math.Abs(a-b) < 0.000001
 fmt.Printf("approxEqual=%t\n", approxEqual)
}

说明：math.Abs 用来求绝对值。浮点数常常不能被精确表示，所以实际开发里更常见的是比较“差值是否足够小”，而不是直接用 ==。

第 10 题：把文本年龄转换成整数

第 10 题进阶

编写一个程序：

读取用户输入的姓名和年龄文本，例如：

1

小王 18

年龄先用 string 接收
再把年龄文本转换成整数
如果转换成功，输出：

1

小王明年 19 岁

如果转换失败，输出：

1

年龄必须是整数

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import (
 "fmt"
 "strconv"
)

func main() {
 var name string
 var ageText string

 fmt.Print("请输入姓名和年龄：")
 _, err := fmt.Scan(&name, &ageText)
 if err != nil {
 fmt.Println("输入有误：", err)
 return
 }

 age, err := strconv.Atoi(ageText)
 if err != nil {
 fmt.Println("年龄必须是整数")
 return
 }

 fmt.Printf("%s明年 %d 岁\n", name, age+1)
}

说明：strconv.Atoi 可以把字符串转换成整数。这类“先按文本读取，再做类型转换”的写法很常见，适合处理用户输入的数据。

3.1 数组

Fri, 03 Apr 2026 10:00:00 +0800

数组

概念说明

数组（Array）是长度固定、元素类型相同的序列。
在 Go 中，数组长度也是类型的一部分，例如 [3]int 和 [4]int 是不同类型。
数组适合存放“数量固定、类型一致”的数据。

语法/规则

声明数组时必须确定长度，可以显式写长度，也可以使用 ... 自动推导长度。
数组索引从 0 开始，最大索引是 len(array)-1。
数组元素可以通过索引读取和修改。
数组支持 for 和 for range 遍历。
未显式赋值的元素会使用对应类型的零值。

定义与索引修改示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 arr1 := [3]int{1, 2, 3}
 arr2 := [3]int{1, 2, 3}
 arr3 := [...]string{"Go", "数组", "入门"} // 用 ... 自动推导数组长度

 arr1[0] = 10 // 通过索引修改元素

 fmt.Println(arr1)
 fmt.Println(arr2)
 fmt.Println(arr3)
}

输出结果：

1
2
3


[10 2 3]
[1 2 3]
[Go 数组 入门]

索引与遍历示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 letters := [4]string{"a", "b", "c", "d"}

 fmt.Println(letters[1]) // 第二个元素
 fmt.Println(letters[len(letters)-2]) // 倒数第二个元素

 for i, v := range letters { // i 是索引，v 是当前元素
 fmt.Printf("index=%d value=%s\n", i, v)
 }
}

输出结果：

1
2
3
4
5
6


b
c
index=0 value=a
index=1 value=b
index=2 value=c
index=3 value=d

range 解析

在 for i, v := range letters 里，range 会按顺序遍历 letters。

i 表示当前元素的索引（从 0 开始）。
v 表示当前索引对应的元素值。

这种写法比手动控制索引边界更直观，也更不容易写错。

常见错误

使用越界索引（例如 letters[4]），会触发 index out of range。
把不同长度的数组当作同一类型使用（如 [3]int 赋值给 [4]int）会编译失败。
误以为 Go 支持负索引（如 letters[-1]），Go 不支持这种写法。
把数组当切片使用 append，会编译报错，append 只作用于切片。

3.2 切片

Fri, 03 Apr 2026 10:00:00 +0800

切片

概念说明

切片（Slice）是对底层数组的一个连续片段视图。
和数组相比，切片长度可变，更适合日常开发中的动态数据场景。
在 Go 中，切片是最常用的序列类型。

语法/规则

切片类型写法是 []T，例如 []int、[]string。
零值切片是 nil，len 和 cap 都是 0。
make([]T, len, cap) 用于创建切片，cap 可省略（默认等于 len）。
append 可能返回新的底层数组，因此通常要写成 s = append(s, x)。
切片表达式 a[low:high] 左闭右开，包含 low，不包含 high。

追加与修改元素示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 list := []string{} // 空切片

 list = append(list, "阿斌") // append 后通常要接收返回值
 list = append(list, "知道")
 fmt.Println(list)
 fmt.Println(len(list))

 list[1] = "不知道" // 按索引修改元素
 fmt.Println(list)
}

输出结果：

1
2
3


[阿斌 知道]
2
[阿斌 不知道]

make 与切片表达式示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 var a []int
 b := make([]int, 2, 4) // len=2, cap=4
 b[0], b[1] = 10, 20

 base := [5]int{10, 20, 30, 40, 50}
 part := base[1:4] // 左闭右开，得到 20 30 40

 fmt.Println(a == nil, len(a), cap(a))
 fmt.Println(b == nil, len(b), cap(b), b)
 fmt.Println(part, len(part), cap(part))
}

输出结果：

1
2
3


true 0 0
false 2 4 [10 20]
[20 30 40] 3 4

make 解析

在 b := make([]int, 2, 4) 里，make 会创建并初始化一个可直接使用的切片。

[]int 是切片类型。
2 是长度 len，表示当前能直接通过索引访问的元素个数。
4 是容量 cap，表示底层数组当前最多可容纳的元素个数。

这种写法适合你预估元素数量的场景，通常能减少 append 触发扩容的次数。

除了切片，make 也常用于创建 map 和 channel。你先记住一点：make 的作用是把这些依赖运行时结构的类型初始化成可直接使用的值。

字符串转 `[]rune` 统计字符数

有些题目会要求“统计字符串中的字符个数，一个中文算一个”。
这时不能直接写 len(str)，因为 Go 字符串底层存的是字节序列，len(str) 统计的是字节数。
在 UTF-8 编码里，常见汉字通常占 3 个字节，英文字母通常占 1 个字节，所以更适合先把字符串转成 []rune 再统计长度。

题目示例：

1
2


输入："小明的英文名叫jack"
返回：11

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 name := "小明的英文名叫jack"

 fmt.Println("字节数:", len(name))

 chars := []rune(name) // 把字符串转成 rune 切片
 fmt.Println("字符数:", len(chars))
}

输出结果：

1
2


字节数: 25
字符数: 11

`rune` 是什么

rune 是 int32 的别名，用来表示一个 Unicode 码点；初学阶段可以先把它理解成一个字符。
[]rune(str) 会把字符串按“字符”拆开，所以适合处理中文等多字节字符。
byte 是 uint8 的别名，更适合表示原始字节数据；rune 能表示的字符范围更大。
len([]rune(str)) 统计的是字符个数，而 len(str) 统计的是字节个数。

切片排序示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
 "fmt"
 "sort"
)

func main() {
 nums := []int{4, 5, 3, 2, 7}

 sort.Ints(nums) // 升序排序
 fmt.Println("升序:", nums)

 sort.Sort(sort.Reverse(sort.IntSlice(nums))) // 降序排序
 fmt.Println("降序:", nums)
}

输出结果：

1
2


升序: [2 3 4 5 7]
降序: [7 5 4 3 2]

常见错误

对空切片直接按索引赋值（如 list[0] = "x"）会触发 index out of range。
调用 append 后不接收返回值，可能导致新增元素没有保存到目标切片。
切片边界写错（如 a[3:2] 或超过长度）会在运行时 panic。
排序示例忘记导入 sort 包会导致编译失败。
直接用 len(str) 统计中文字符串长度，得到的是字节数，不是字符数；这类题通常要先转成 []rune。

3.3 map

Fri, 03 Apr 2026 10:00:00 +0800

map

概念说明

map（映射、字典）是 Go 的内置数据结构，用于存储无序的 key-value 键值对。
它适合做“通过键快速查值”的场景，例如用户信息、配置表、计数器等。

语法/规则

类型写法是 map[K]V，例如 map[string]int。
key 必须是可比较类型（例如 string、int、bool、数组、结构体）；value 可以是任意类型。
map 在写入前必须初始化，可用 make 或字面量。
读取不存在的键会返回 value 类型零值。
使用 value, ok := m[key] 可以区分“键不存在”与“值刚好是零值”。
delete(m, key) 删除键值对；删除不存在的键不会报错。
for range 遍历 map 时顺序不固定。

初始化与增删改查示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 m1 := make(map[string]string) // map 写入前要先初始化
 m1["name"] = "阿斌"
 m1["city"] = "上海"

 fmt.Println(m1["name"])

 delete(m1, "city") // 删除指定键
 fmt.Println(m1)
}

输出结果：

1
2


阿斌
map[name:阿斌]

不存在键取值示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 ages := map[string]int{
 "阿斌": 21,
 }

 age1 := ages["小王"] // 键不存在时会返回零值
 fmt.Println(age1)

 age2, ok := ages["小王"] // ok 用来判断键是否存在
 fmt.Println(age2, ok)
}

输出结果：

1
2


0
0 false

常见错误

只声明不初始化就写入，例如 var m map[string]int; m["a"]=1，会触发 assignment to entry in nil map。
读取 map 只接收一个返回值时，无法区分“键不存在”和“键存在但值为零值”。
误以为 map 遍历顺序固定，导致业务逻辑依赖顺序而出错。
把不可比较类型（如切片 []int）当作 key，会编译失败。

3.4 练习

Sun, 12 Apr 2026 11:00:00 +0800

练习

学完本章你应该掌握

能根据场景区分数组、切片、map，并写出对应的定义、初始化和基础操作代码。
能完成数组和切片的索引、截取、追加、排序，并正确使用 len、cap、append。
能正确初始化 map，完成增删改查，并使用 value, ok := m[key] 判断键是否存在。
能识别并修正常见错误，例如数组长度不匹配、切片直接越界赋值、append 后漏接收返回值、向 nil map 写入数据。
能把本章知识迁移到基础数据整理场景，例如成绩统计、名称排序、字符数统计和有序输出。

简单

第 1 题：声明并修改一个数组

第 1 题简单

编写一个 Go 程序，完成下面要求：

声明一个 scores 数组，类型为 [4]int
初始值分别是 88、76、95、60
把第二个元素改成 80
依次输出第一个元素、第二个元素和整个数组

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 scores := [4]int{88, 76, 95, 60}
 scores[1] = 80

 fmt.Println(scores[0])
 fmt.Println(scores[1])
 fmt.Println(scores)
}

输出结果：

1
2
3


88
80
[88 80 95 60]

第 2 题：补全自动推导长度的数组

第 2 题简单

补全下面代码中的两个空白，让程序输出：

1
2


4
map

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 langs := ________{"Go", "数组", "切片", "map"}
 fmt.Println(len(langs))
 fmt.Println(langs[________])
}

查看参考答案

补全后的代码如下：

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 langs := [...]string{"Go", "数组", "切片", "map"}
 fmt.Println(len(langs))
 fmt.Println(langs[len(langs)-1])
}

说明：

... 可以让 Go 自动推导数组长度。
len(langs)-1 是最后一个元素的索引。

第 3 题：创建并追加一个切片

第 3 题简单

编写一个程序，完成下面要求：

使用 make([]string, 0, 3) 创建切片 topics
依次追加 "Go"、"切片"、"练习"
输出切片内容
再输出它的长度和容量

示例输出可以类似这样：

1
2


[Go 切片 练习]
3 3

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 topics := make([]string, 0, 3)

 topics = append(topics, "Go")
 topics = append(topics, "切片")
 topics = append(topics, "练习")

 fmt.Println(topics)
 fmt.Println(len(topics), cap(topics))
}

第 4 题：写出 `make` 和 `append` 的结果

第 4 题简单

阅读下面代码，写出它的输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 nums := make([]int, 2, 5)
 nums[0], nums[1] = 10, 20
 nums = append(nums, 30)

 fmt.Println(nums)
 fmt.Println(len(nums), cap(nums))
}

查看参考答案

说明：make([]int, 2, 5) 创建的是长度为 2、容量为 5 的切片；追加一个元素后，长度变成 3，容量仍然是 5。

第 5 题：修正 nil map 的写入错误

第 5 题简单

下面程序有问题，请改正后让它正常运行，并保持原有输出逻辑不变：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 var levels map[string]int

 levels["初级"] = 1
 value, ok := levels["中级"]

 fmt.Println(value, ok)
}

查看参考答案

修正后的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 levels := make(map[string]int)

 levels["初级"] = 1
 value, ok := levels["中级"]

 fmt.Println(value, ok)
}

输出结果：

1

0 false

说明：map 在写入前必须先初始化；读取不存在的键时，会返回零值和 false。

一般

第 6 题：用数组统计三门成绩

第 6 题一般

编写一个程序，完成下面要求：

提示用户按“成绩1 成绩2 成绩3”的格式输入 3 个整数，例如 80 90 85
使用数组 [3]int 保存这 3 个成绩
使用 for range 计算总分
输出总分和平均分，平均分保留 1 位小数

示例输出可以类似这样：

1
2


total=255
avg=85.0

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import "fmt"

func main() {
 var scores [3]int

 fmt.Print("请输入 3 个成绩：")
 fmt.Scan(&scores[0], &scores[1], &scores[2])

 total := 0
 for _, score := range scores {
 total += score
 }

 avg := float64(total) / float64(len(scores))

 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
}

说明：这道题把数组、输入、遍历和类型转换组合到了一起，是很典型的基础整合题。

第 7 题：对整数切片分别做升序和降序排序

第 7 题一般

编写一个程序，完成下面要求：

创建切片 nums := []int{34, 12, 56, 23}
先输出原始切片
再把它按升序排序后输出
最后把它按降序排序后输出

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
 "fmt"
 "sort"
)

func main() {
 nums := []int{34, 12, 56, 23}

 fmt.Println("原始:", nums)

 sort.Ints(nums)
 fmt.Println("升序:", nums)

 sort.Sort(sort.Reverse(sort.IntSlice(nums)))
 fmt.Println("降序:", nums)
}

一种可能的输出结果：

1
2
3


原始: [34 12 56 23]
升序: [12 23 34 56]
降序: [56 34 23 12]

说明：sort.Ints 用来做升序排序；sort.Reverse 可以把排序结果反过来，得到降序。

第 8 题：建立并查询一张年龄表

第 8 题一般

编写一个程序，完成下面要求：

创建一个 map[string]int
写入三条数据："阿斌":18、"小李":20、"小王":19
删除 "小李"
分别读取 "阿斌" 和 "小李" 的年龄
两次读取都要使用 value, ok := m[key]
最后输出两次读取的结果

示例输出可以类似这样：

1
2


18 true
0 false

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func main() {
 ages := make(map[string]int)

 ages["阿斌"] = 18
 ages["小李"] = 20
 ages["小王"] = 19

 delete(ages, "小李")

 age1, ok1 := ages["阿斌"]
 age2, ok2 := ages["小李"]

 fmt.Println(age1, ok1)
 fmt.Println(age2, ok2)
}

说明：这道题把 map 的初始化、写入、删除和 ok 判断放到了一起，是 map 最常见的一组操作。

进阶

下面两题会把数组、切片、map 放到更接近真实数据整理的场景里，重点考察多个知识点的配合使用。

第 9 题：统计字符串的字节数和字符数

第 9 题进阶

编写一个程序，完成下面要求：

读取一个不含空格的字符串，例如 Go语言123
输出它的字节数
再输出它的字符数

示例输出可以类似这样：

1
2


bytes=11
chars=7

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 var text string

 fmt.Print("请输入字符串：")
 fmt.Scanln(&text)

 fmt.Printf("bytes=%d\n", len(text))
 fmt.Printf("chars=%d\n", len([]rune(text)))
}

说明：

len(text) 统计的是字节数。
len([]rune(text)) 统计的是字符个数，处理中英文混合内容时更常用。

第 10 题：按固定顺序输出成绩并统计平均分

第 10 题进阶

已知有一份成绩表：

1
2
3
4
5


scores := map[string]int{
 "阿斌": 92,
 "小李": 85,
 "小王": 88,
}

现在要求你按下面这个顺序输出成绩：

1

names := []string{"小李", "小王", "阿斌"}

请编写程序，完成下面要求：

按 names 的顺序输出每个人的成绩
在输出过程中累计总分
最后输出总分和平均分，平均分保留 1 位小数

示例输出可以类似这样：

1
2
3
4
5


小李: 85
小王: 88
阿斌: 92
total=265
avg=88.3

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import "fmt"

func main() {
 scores := map[string]int{
 "阿斌": 92,
 "小李": 85,
 "小王": 88,
 }

 names := []string{"小李", "小王", "阿斌"}

 total := 0
 for _, name := range names {
 score := scores[name]
 fmt.Printf("%s: %d\n", name, score)
 total += score
 }

 avg := float64(total) / float64(len(names))

 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
}

说明：map 的遍历顺序不固定，所以如果你需要稳定顺序，常见做法是先准备一个切片，再按切片顺序去 map 里取值。

4.1 if

Fri, 03 Apr 2026 10:00:00 +0800

if 语句

概念说明

if 用于条件判断，根据布尔表达式结果执行不同代码分支。
它是 Go 里最基础、最常用的流程控制语句之一。
在“区间判断”“输入校验”“状态分流”这类场景里会频繁使用。

语法/规则

Go 的 if 条件不需要圆括号，直接写布尔表达式即可。
分支代码必须写在 {} 中，不能省略大括号。
多分支通常写成 if -> else if -> else，满足第一个条件后就不会继续判断后续分支。
也可以写多个并列 if，但要确保条件互斥，避免一次命中多个分支。
处理非法输入时，常用“卫语句（提前返回）”让主流程更清晰。
if 支持“初始化语句 + 条件判断”写法：if 初始化语句; 条件 {}。
在初始化语句里声明的变量，只在当前 if/else 代码块内有效。

语法模板

1
2
3
4
5
6
7


if 条件1 {
 // 分支1
} else if 条件2 {
 // 分支2
} else {
 // 兜底分支
}

1
2
3
4
5


if 初始化语句; 条件 {
 // 条件成立
} else {
 // 条件不成立
}

带初始化语句的 if 示例（map 取值）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 ages := map[string]int{
 "阿斌": 21,
 "小王": 18,
 }

 name := "阿斌"
 if age, ok := ages[name]; ok { // 在 if 中先取值，再判断键是否存在
 fmt.Printf("%s 的年龄是 %d\n", name, age)
 } else {
 fmt.Printf("没有找到 %s 的年龄信息\n", name)
 }
}

输出结果（name = 阿斌）：

1

阿斌 的年龄是 21

区间判断示例（卫语句写法）

下面以年龄区间为例：

age <= 0：未出生
1 ~ 18：未成年
19 ~ 35：青年
> 35：中年

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func main() {
 fmt.Println("请输入你的年龄：")
 var age int
 fmt.Scan(&age)

 if age <= 0 {
 fmt.Println("未出生")
 return // 提前结束，后面的判断就不会再执行
 }
 if age <= 18 {
 fmt.Println("未成年")
 return
 }
 if age <= 35 {
 fmt.Println("青年")
 return
 }
 fmt.Println("中年")
}

输出结果（输入 12）：

1
2
3


请输入你的年龄：
12
未成年

区间判断示例（嵌套写法）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func main() {
 fmt.Println("请输入你的年龄：")
 var age int
 fmt.Scan(&age)

 if age <= 18 {
 if age <= 0 {
 fmt.Println("未出生")
 } else {
 fmt.Println("未成年")
 }
 } else {
 if age <= 35 {
 fmt.Println("青年")
 } else {
 fmt.Println("中年")
 }
 }
}

输出结果（输入 30）：

1
2
3


请输入你的年龄：
30
青年

区间判断示例（多条件并列写法）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

func main() {
 fmt.Println("请输入你的年龄：")
 var age int
 fmt.Scan(&age)

 if age <= 0 { // 条件之间要互斥，避免命中多个分支
 fmt.Println("未出生")
 }
 if age > 0 && age <= 18 {
 fmt.Println("未成年")
 }
 if age > 18 && age <= 35 {
 fmt.Println("青年")
 }
 if age > 35 {
 fmt.Println("中年")
 }
}

输出结果（输入 40）：

1
2
3


请输入你的年龄：
40
中年

常见错误

把比较写成赋值（如 if age = 18），会导致编译报错。
写多个并列 if 时条件没有互斥，导致一次输出多个结果。
边界条件写错（如 18、35）导致分类错误。
漏掉非法输入处理（如 age <= 0）导致逻辑不完整。
把 if 初始化语句; 条件 中声明的变量拿到块外使用，导致“未定义”编译错误。

4.2 switch

Fri, 03 Apr 2026 10:00:00 +0800

switch 语句

概念说明

switch 用于多分支判断，适合“多选一”场景。
相比多层 if-else，switch 在分支较多时通常更直观。

语法/规则

switch 可以带表达式（如 switch week），也可以不带表达式（如 switch {}）。
case 按书写顺序匹配，命中第一个分支后默认结束，不会继续向下执行。
default 是兜底分支，当前面的 case 都不满足时执行。
一个 case 可以匹配多个值，例如 case 6, 7:。
如果希望命中后继续执行下一个分支，可使用 fallthrough。
fallthrough 会直接进入下一个 case，不会重新判断下一个 case 的条件。

区间判断示例（switch + 条件表达式）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import "fmt"

func main() {
 fmt.Println("请输入你的年龄：")
 var age int
 fmt.Scan(&age)

 switch { // 不写表达式时，每个 case 后面直接写条件
 case age <= 0:
 fmt.Println("未出生")
 case age <= 18:
 fmt.Println("未成年")
 case age <= 35:
 fmt.Println("青年")
 default:
 fmt.Println("中年")
 }
}

输出结果（输入 22）：

1
2
3


请输入你的年龄：
22
青年

枚举值判断示例（switch + 变量）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import "fmt"

func main() {
 fmt.Println("请输入星期数字：")
 var week int
 fmt.Scan(&week)

 switch week {
 case 1:
 fmt.Println("周一")
 case 2:
 fmt.Println("周二")
 case 3:
 fmt.Println("周三")
 case 4:
 fmt.Println("周四")
 case 5:
 fmt.Println("周五")
 case 6, 7: // 一个 case 可以匹配多个值
 fmt.Println("周末")
 default:
 fmt.Println("输入错误")
 }
}

输出结果（输入 6）：

1
2
3


请输入星期数字：
6
周末

fallthrough 示例

默认情况下，switch 命中一个 case 后就结束。
如果你希望继续执行下一个分支，可以使用 fallthrough。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

func main() {
 fmt.Println("请输入你的年龄：")
 var age int
 fmt.Scan(&age)

 switch {
 case age <= 0:
 fmt.Println("未出生")
 fallthrough // 直接继续执行下一个 case，不再判断条件
 case age <= 18:
 fmt.Println("未成年")
 fallthrough
 case age <= 35:
 fmt.Println("青年")
 default:
 fmt.Println("中年")
 }
}

输出结果（输入 12）：

1
2
3
4


请输入你的年龄：
12
未成年
青年

常见错误

误以为 switch 会自动“贯穿”到后续 case，实际上默认不会。
在 switch {} 中把范围更大的条件写在前面，导致后面的分支永远匹配不到。
误解 fallthrough 行为，以为会再次判断下一个 case 条件。
枚举场景没有写 default，导致非法输入时没有明确提示。

4.3 练习

Sun, 12 Apr 2026 11:30:00 +0800

练习

学完本章你应该掌握

能根据简单条件写出 if、if-else、if-else if-else 三种常见判断结构。
能处理区间判断、非法输入和兜底分支，避免边界写错或漏掉异常情况。
能在合适场景下使用 switch 完成枚举判断和区间判断，并理解 default 与 fallthrough 的作用。
能使用 if 初始化语句; 条件 处理 map 查询等“先取值再判断”的写法，并知道变量作用域只在当前分支内有效。
能把本章知识迁移到成绩判断、星期转换、角色分流、资料查询等基础控制台场景。

简单

第 1 题：判断是否及格

第 1 题简单

编写一个程序，完成下面要求：

提示用户输入一个整数分数
如果分数大于等于 60，输出 及格
否则输出 不及格

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 var score int

 fmt.Print("请输入分数：")
 fmt.Scan(&score)

 if score >= 60 {
 fmt.Println("及格")
 } else {
 fmt.Println("不及格")
 }
}

第 2 题：补全年龄区间判断

第 2 题简单

补全下面代码中的空白，让程序按照下面规则输出结果：

age <= 0 输出 未出生
1 ~ 18 输出 未成年
19 ~ 35 输出 青年
其他情况输出 中年

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 var age int
 fmt.Scan(&age)

 if ________ {
 fmt.Println("未出生")
 } else if ________ {
 fmt.Println("未成年")
 } else if ________ {
 fmt.Println("青年")
 } else {
 fmt.Println("中年")
 }
}

查看参考答案

补全后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 var age int
 fmt.Scan(&age)

 if age <= 0 {
 fmt.Println("未出生")
 } else if age <= 18 {
 fmt.Println("未成年")
 } else if age <= 35 {
 fmt.Println("青年")
 } else {
 fmt.Println("中年")
 }
}

说明：写成 else if age <= 18 和 else if age <= 35 就可以了，因为前面的不满足时才会继续判断后面的分支。

第 3 题：把星期数字转成文字

第 3 题简单

编写一个程序，完成下面要求：

提示用户输入一个整数 week
如果输入 1，输出 周一
如果输入 2，输出 周二
如果输入 3，输出 周三
如果输入 4，输出 周四
如果输入 5，输出 周五
如果输入 6 或 7，输出 周末
其他情况输出 输入错误

要求使用 switch 实现。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import "fmt"

func main() {
 var week int

 fmt.Print("请输入星期数字：")
 fmt.Scan(&week)

 switch week {
 case 1:
 fmt.Println("周一")
 case 2:
 fmt.Println("周二")
 case 3:
 fmt.Println("周三")
 case 4:
 fmt.Println("周四")
 case 5:
 fmt.Println("周五")
 case 6, 7:
 fmt.Println("周末")
 default:
 fmt.Println("输入错误")
 }
}

第 4 题：修正会重复输出的年龄判断

第 4 题简单

下面程序的目标是根据年龄输出一个结果，但它现在有逻辑问题。
请改正后让输入 12 时只输出一行 未成年。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 var age int
 fmt.Scan(&age)

 if age > 0 {
 fmt.Println("未成年")
 }
 if age <= 18 {
 fmt.Println("未成年")
 }
 if age > 18 {
 fmt.Println("青年或中年")
 }
}

查看参考答案

一种可行的改法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 var age int
 fmt.Scan(&age)

 if age <= 0 {
 fmt.Println("未出生")
 } else if age <= 18 {
 fmt.Println("未成年")
 } else {
 fmt.Println("青年或中年")
 }
}

说明：原程序用了多个并列 if，条件又没有互斥，所以一次输入可能命中多个分支。这里改成 if -> else if -> else 更合适。

第 5 题：写出 `fallthrough` 的输出结果

第 5 题简单

阅读下面代码，写出它的输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 level := 1

 switch level {
 case 1:
 fmt.Println("初级")
 fallthrough
 case 2:
 fmt.Println("继续学习")
 default:
 fmt.Println("结束")
 }
}

查看参考答案

1
2


初级
继续学习

说明：fallthrough 会直接进入下一个 case 执行，不会重新判断下一个 case 的条件。

一般

第 6 题：用 `if` 查询年龄表

第 6 题一般

编写一个程序，完成下面要求：

先准备一个 map：

1
2
3
4


ages := map[string]int{
 "阿斌": 21,
 "小王": 18,
}

再读取一个姓名
使用 if 初始化语句; 条件 的写法判断这个姓名是否存在于 map 中
如果存在，输出 阿斌的年龄是 21
如果不存在，输出 没有找到阿华的年龄信息

其中姓名要替换成用户真正输入的内容。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import "fmt"

func main() {
 ages := map[string]int{
 "阿斌": 21,
 "小王": 18,
 }

 var name string

 fmt.Print("请输入姓名：")
 fmt.Scan(&name)

 if age, ok := ages[name]; ok {
 fmt.Printf("%s 的年龄是 %d\n", name, age)
 } else {
 fmt.Printf("没有找到 %s 的年龄信息\n", name)
 }
}

说明：age 和 ok 是在 if 初始化语句里声明的，它们只在当前 if/else 代码块中可用。

第 7 题：用 `switch {}` 判断成绩等级

第 7 题一般

编写一个程序，完成下面要求：

读取一个整数分数
如果分数小于 0 或大于 100，输出 分数非法
如果分数在 90 ~ 100，输出 A
如果分数在 80 ~ 89，输出 B
如果分数在 60 ~ 79，输出 C
其他情况输出 D

要求使用 switch {} 实现区间判断。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func main() {
 var score int

 fmt.Print("请输入分数：")
 fmt.Scan(&score)

 switch {
 case score < 0 || score > 100:
 fmt.Println("分数非法")
 case score >= 90:
 fmt.Println("A")
 case score >= 80:
 fmt.Println("B")
 case score >= 60:
 fmt.Println("C")
 default:
 fmt.Println("D")
 }
}

说明：switch {} 里每个 case 后面直接写条件，写区间判断时通常比多层 if-else 更整齐。

第 8 题：先校验姓名，再分配角色欢迎语

第 8 题一般

编写一个程序，完成下面要求：

先定义两个变量：姓名 name 和角色 role，值可以自行设置
如果 name 是空字符串，输出 姓名不能为空 并结束程序
如果 role 是 admin，输出 管理员，欢迎你
如果 role 是 teacher，输出 老师，欢迎你
如果 role 是 student，输出 同学，欢迎你
其他情况输出 未知角色

要求：

姓名校验使用 if
角色分流使用 switch

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import "fmt"

func main() {
 name := "阿斌"
 role := "teacher"

 if name == "" {
 fmt.Println("姓名不能为空")
 return
 }

 switch role {
 case "admin":
 fmt.Println("管理员，欢迎你")
 case "teacher":
 fmt.Println("老师，欢迎你")
 case "student":
 fmt.Println("同学，欢迎你")
 default:
 fmt.Println("未知角色")
 }
}

说明：这道题把 if 和 switch 放在同一个小场景里，前者做输入校验，后者做状态分流。

进阶

下面两题会把 if 和 switch 放到更完整的输入处理场景里，重点考察分支顺序、边界判断和多知识点组合。

第 9 题：查询成绩并输出等级

第 9 题进阶

已知有一份成绩表：

1
2
3
4
5


scores := map[string]int{
 "阿斌": 92,
 "小李": 76,
 "小王": 58,
}

请编写一个程序，完成下面要求：

读取一个姓名
先用 if 初始化语句; 条件 判断这个姓名是否存在于成绩表中
如果不存在，输出 没有找到该学生
如果存在，再根据分数输出等级： 90 ~ 100 输出 A 80 ~ 89 输出 B 60 ~ 79 输出 C 其他输出 D
最后输出一行完整结果，例如：

1

阿斌 的分数是 92，等级是 A

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


package main

import "fmt"

func main() {
 scores := map[string]int{
 "阿斌": 92,
 "小李": 76,
 "小王": 58,
 }

 var name string

 fmt.Print("请输入姓名：")
 fmt.Scan(&name)

 if score, ok := scores[name]; ok {
 level := ""

 switch {
 case score >= 90:
 level = "A"
 case score >= 80:
 level = "B"
 case score >= 60:
 level = "C"
 default:
 level = "D"
 }

 fmt.Printf("%s 的分数是 %d，等级是 %s\n", name, score, level)
 } else {
 fmt.Println("没有找到该学生")
 }
}

说明：这道题先用 if 处理“有没有这个人”，再用 switch {} 处理“这个人的分数属于哪个区间”，是很常见的两段式判断。

第 10 题：快递费用判断

第 10 题进阶

编写一个程序，完成下面要求：

读取两个输入：快递类型 kind 和重量 weight
如果 weight <= 0，输出 重量非法 并结束程序
运费规则如下：

standard： weight <= 1 时运费 8 其他情况运费 12

express： weight <= 1 时运费 12 其他情况运费 18

其他快递类型输出 未知快递类型

如果类型合法，最后输出：

1

运费：12元

要求：

先用 if 处理重量非法
再用 switch 判断快递类型

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


package main

import "fmt"

func main() {
 var kind string
 var weight float64

 fmt.Print("请输入快递类型和重量：")
 fmt.Scan(&kind, &weight)

 if weight <= 0 {
 fmt.Println("重量非法")
 return
 }

 switch kind {
 case "standard":
 if weight <= 1 {
 fmt.Println("运费：8元")
 } else {
 fmt.Println("运费：12元")
 }
 case "express":
 if weight <= 1 {
 fmt.Println("运费：12元")
 } else {
 fmt.Println("运费：18元")
 }
 default:
 fmt.Println("未知快递类型")
 }
}

说明：这道题里 switch 先区分类型，进入具体类型后再用 if 做更细的条件判断，这是一种很常见的组合写法。

5.1 传统for循环

Fri, 03 Apr 2026 10:00:00 +0800

传统 for 循环

概念说明

Go 只有 for 一种循环关键字。
传统写法是 for 初始化; 条件; 后置操作，适合“已知循环次数”的场景。

语法/规则

初始化语句在循环开始前执行一次。
每轮先判断条件，条件为 true 才执行循环体。
每轮执行完循环体后，再执行后置操作（如 i++）。
初始化、条件、后置操作都可以按需省略，但分号位置要正确。
在 for 中声明的变量（如 i := 0）作用域只在循环内部。

语法模板

1
2
3


for 初始化; 条件; 后置操作 {
 // 循环体
}

累加求和示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 sum := 0
 for i := 1; i <= 100; i++ { // 初始化; 条件; 后置操作
 sum += i // 每轮把当前 i 累加到 sum
 }
 fmt.Println(sum)
}

输出结果：

1

5050

常见错误

忘记写后置操作（如 i++），导致死循环。
条件边界写错（如 < 100 与 <= 100 混淆），造成结果偏差。
误把循环变量拿到循环外直接使用，导致作用域错误。
把传统 for 写成其他语言风格（括号或语法顺序错误）导致编译失败。

5.2 死循环

Fri, 03 Apr 2026 10:00:00 +0800

死循环

概念说明

死循环是“没有自然结束条件”的循环。
在 Go 中通常使用 for {} 表示。
它常用于服务监听、消息消费、定时轮询等长期运行场景。

语法/规则

for {} 会一直执行，除非在循环内 break、return 或程序退出。
死循环里通常要有“节流”逻辑（如 time.Sleep），避免无意义高频占用 CPU。
如果业务上需要结束循环，必须提供明确退出条件。

每秒打印当前时间示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import (
 "fmt"
 "time"
)

func main() {
 for { // 没有结束条件，会一直循环
 time.Sleep(1 * time.Second) // 每次循环暂停 1 秒，避免空转占用 CPU
 fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
 }
}

输出结果（示例，时间会持续变化）：

1
2
3


2026-04-10 20:20:01
2026-04-10 20:20:02
2026-04-10 20:20:03

常见错误

在死循环里没有 Sleep 或阻塞操作，导致 CPU 占用过高。
误把死循环用于本应有限次数的任务，导致程序无法结束。
写了退出条件却永远不可能满足，等价于意外死循环。

5.3 while模式

Fri, 03 Apr 2026 10:00:00 +0800

while 模式

概念说明

Go 没有单独的 while 关键字。
如果只需要“条件判断 + 循环体”，可以使用 for 条件 来实现 while 模式。

语法/规则

for 条件 {} 等价于其他语言中的 while (条件) {}。
每轮开始前都会先判断条件，条件为 false 时结束循环。
循环变量更新必须写在循环体中，否则容易变成死循环。
while 模式适合“循环次数不固定，但结束条件明确”的场景。

语法模板

1
2
3


for 条件 {
 // 循环体
}

累加求和示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 i := 1
 sum := 0
 for i <= 100 { // 只保留条件判断，就是 while 模式
 sum += i
 i++ // 更新循环变量，避免死循环
 }
 fmt.Println(sum)
}

输出结果：

1

5050

常见错误

忘记更新循环变量（如遗漏 i++），导致无限循环。
条件边界写错（如 < 100），造成累加结果不正确。
把 while 模式和传统 for 混写，语法结构不完整导致编译失败。

5.4 do-while模式

Fri, 03 Apr 2026 10:00:00 +0800

do-while 模式

概念说明

Go 没有 do-while 关键字。
如果需要“先执行一次循环体，再判断是否继续”，可以使用 for {} + break 模拟。

语法/规则

do-while 模式的核心是“循环体先执行，再判断退出条件”。
在 Go 中通常把退出判断写在循环体末尾，通过 break 结束循环。
退出条件必须可达，否则会变成死循环。

语法模板

1
2
3
4
5
6
7


for {
 // 先执行循环体

 if 退出条件 {
 break
 }
}

累加求和示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 i := 0
 sum := 0
 for { // 先执行循环体，再判断是否退出
 sum += i
 i++
 if i > 100 {
 break // 条件满足时结束循环
 }
 }
 fmt.Println(sum)
}

输出结果：

1

5050

常见错误

把退出条件写错（如 i >= 100 放在不合适位置），导致少算或多算。
忘记写 break，循环无法结束。
把 do-while 模式误写成 for 条件，导致“先执行一次”的语义丢失。

5.5 遍历切片,map

Fri, 03 Apr 2026 10:00:00 +0800

遍历切片与 map

概念说明

for range 是 Go 中遍历集合最常见的方式。
在切片上，它返回“索引 + 元素值”；在 map 上，它返回“键 + 值”。

语法/规则

遍历切片时，range 返回两个值：索引（index）和元素值（value）。
遍历 map 时，range 返回两个值：键（key）和值（value）。
如果不需要其中一个返回值，可以用 _ 忽略。
map 的遍历顺序不固定，不能依赖输出顺序编写业务逻辑。

遍历切片示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 names := []string{"阿斌", "知道"}
 for index, name := range names { // range 返回索引和值
 fmt.Println(index, name)
 }
}

输出结果：

1
2


0 阿斌
1 知道

遍历 map 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 info := map[string]int{
 "age": 24,
 "price": 1000,
 }
 for key, value := range info { // range 返回键和值
 fmt.Println(key, value)
 }
}

输出结果（顺序不固定，以下为一种可能）：

1
2


age 24
price 1000

常见错误

误以为 map 每次遍历顺序都一样，导致结果依赖顺序而出错。
不需要索引或键时仍声明变量，后续未使用会触发编译错误。
将切片遍历中的“索引、值”与 map 遍历中的“键、值”混淆。

5.6 break，continue

Fri, 03 Apr 2026 10:00:00 +0800

break 与 continue

概念说明

break 和 continue 都用于控制循环流程。
break 用于提前结束循环，continue 用于跳过本轮剩余代码并进入下一轮。

语法/规则

break 默认只结束当前所在的这一层循环。
continue 会跳过本轮后续语句，直接进入下一轮判断。
在嵌套循环中使用时，要注意它们只作用于最近一层循环。
使用 continue 时，循环变量更新逻辑仍需保证正确，否则可能陷入死循环。

break 示例（提前结束循环）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 for i := 1; i <= 20; i++ {
 if i%7 == 0 {
 fmt.Println("第一个能被 7 整除的数是：", i)
 break // 找到后直接结束当前循环
 }
 }
}

输出结果：

1

第一个能被 7 整除的数是： 7

continue 示例（打印九九乘法表下三角）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 for i := 1; i <= 9; i++ {
 for j := 1; j <= 9; j++ {
 if j > i {
 continue // 跳过上三角，只打印下三角部分
 }
 fmt.Printf("%d * %d = %d\t", i, j, i*j)
 }
 fmt.Println()
 }
}

输出结果：

1
2
3
4
5
6
7
8
9


1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

常见错误

误以为 break 会结束所有层循环，实际只结束当前层。
在 continue 前遗漏关键逻辑，导致本轮该执行的代码被意外跳过。
把 break 和 continue 用反，造成循环结果与预期不一致。

5.7 练习

Sun, 12 Apr 2026 12:20:00 +0800

练习

学完本章你应该掌握

能根据场景选择传统 for、while 模式、do-while 模式和 for range。
能使用循环完成计数、累加、累乘、筛选、查找等基础任务，并写对条件边界。
能遍历切片与 map，正确处理索引、键值以及 map 遍历顺序不固定的特点。
能使用 break 和 continue 改变循环流程，并识别由更新语句遗漏带来的死循环问题。
能在循环中结合输入、判断、切片、map 写出更完整的控制台小程序。
能把 for 的知识迁移到数据统计、菜单交互、重复录入、倒计时等常见场景。

简单

第 1 题：打印 1 到 5 并求和

第 1 题简单

编写一个 Go 程序，完成下面要求：

使用传统 for 循环
依次输出 1 到 5
再输出它们的总和

示例输出：

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 sum := 0

 for i := 1; i <= 5; i++ {
 fmt.Println(i)
 sum += i
 }

 fmt.Printf("sum=%d\n", sum)
}

说明：这道题的重点是把“循环次数已知”的场景写成熟悉的 for 初始化; 条件; 后置操作 结构。

第 2 题：补全倒序偶数循环

第 2 题简单

补全下面代码中的空白，让程序输出：

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 for i := ____; i >= ____; i ____ {
 fmt.Println(i)
 }
}

查看参考答案

补全后的代码如下：

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 for i := 10; i >= 2; i -= 2 {
 fmt.Println(i)
 }
}

说明：这道题练的是“倒序循环”和“步长不一定是 1”。后置操作除了 i++，也可以写成 i--、i += 2、i -= 2。

第 3 题：用 while 模式计算阶乘

第 3 题简单

编写一个程序：

读取一个正整数 n
使用 while 模式，也就是 for 条件 {} 的写法
计算 n!
输出结果

例如输入：

1

5

输出：

1

120

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 var n int

 fmt.Print("请输入一个正整数：")
 fmt.Scan(&n)

 result := 1
 for n > 0 {
 result *= n
 n--
 }

 fmt.Println(result)
}

说明：for n > 0 {} 就是 Go 里的 while 模式。循环变量的更新要写在循环体里，否则很容易变成死循环。

第 4 题：用 do-while 模式打印倒计时

第 4 题简单

请使用 for {} + break 模拟 do-while 模式，完成下面任务：

定义 count := 3
每轮先输出 count
再让 count--
当 count == 0 时结束循环

输出结果应为：

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 count := 3

 for {
 fmt.Println(count)
 count--

 if count == 0 {
 break
 }
 }
}

说明：这道题的关键不是“打印倒计时”，而是体会 do-while 模式的顺序是“先执行一次，再判断要不要退出”。

第 5 题：修正 `continue` 造成的死循环

第 5 题简单

下面程序的目标是输出：

但它现在会卡住。请改正后让它正常结束。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 i := 1

 for i <= 5 {
 if i == 3 {
 continue
 }

 fmt.Println(i)
 i++
 }
}

查看参考答案

修正后的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 i := 1

 for i <= 5 {
 if i == 3 {
 i++
 continue
 }

 fmt.Println(i)
 i++
 }
}

原因说明：

当 i == 3 时，程序会直接执行 continue
原代码里的 i++ 在 continue 后面，所以这一轮不会执行
i 一直停在 3，循环条件始终成立，于是程序陷入死循环

一般

第 6 题：遍历切片输出编号和名称

第 6 题一般

已知下面这个切片：

1

langs := []string{"Go", "切片", "循环"}

请使用 for range 输出：

1
2
3


第1个：Go
第2个：切片
第3个：循环

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 langs := []string{"Go", "切片", "循环"}

 for index, lang := range langs {
 fmt.Printf("第%d个：%s\n", index+1, lang)
 }
}

说明：遍历切片时，range 返回的是索引和值。如果想把编号显示成“第 1 个”，记得把索引加 1。

第 7 题：统计 1 到 n 中 3 的倍数

第 7 题一般

编写一个程序，完成下面要求：

读取一个整数 n
如果 n <= 0，输出 n 必须大于 0
否则统计 1 ~ n 之间能被 3 整除的数字个数和总和
最后输出 count=... 和 total=...

例如输入：

1

10

输出：

1
2


count=3
total=18

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import "fmt"

func main() {
 var n int

 fmt.Print("请输入 n：")
 fmt.Scan(&n)

 if n <= 0 {
 fmt.Println("n 必须大于 0")
 return
 }

 count := 0
 total := 0

 for i := 1; i <= n; i++ {
 if i%3 == 0 {
 count++
 total += i
 }
 }

 fmt.Printf("count=%d\n", count)
 fmt.Printf("total=%d\n", total)
}

说明：这道题把循环和条件判断放到了一起，是最常见的“边遍历、边筛选、边统计”写法。

第 8 题：统计成绩切片的总分、平均分和及格人数

第 8 题一般

已知下面这个成绩切片：

1

scores := []int{78, 92, 56, 84, 67}

请编写程序，完成下面要求：

使用 for range 遍历切片
计算总分 total
计算平均分 avg，保留 1 位小数
统计及格人数 passCount，及格线是 60

示例输出：

1
2
3


total=377
avg=75.4
passCount=4

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func main() {
 scores := []int{78, 92, 56, 84, 67}

 total := 0
 passCount := 0

 for _, score := range scores {
 total += score
 if score >= 60 {
 passCount++
 }
 }

 avg := float64(total) / float64(len(scores))

 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
 fmt.Printf("passCount=%d\n", passCount)
}

说明：这道题虽然主角是 for range，但想把平均分算对，仍然需要用到前面学过的类型转换。

第 9 题：遍历 map 输出高价商品

第 9 题一般

已知下面这个商品价格表：

1
2
3
4
5
6


prices := map[string]float64{
 "苹果": 5.5,
 "牛奶": 12.0,
 "洗发水": 39.9,
 "书包": 128.0,
}

请编写程序，完成下面要求：

使用 for range 遍历这个 map
只输出价格大于等于 30 的商品
同时统计这类商品的数量 count
再统计它们的总价 total

一种可能的输出结果：

1
2
3
4


洗发水: 39.9
书包: 128.0
count=2
total=167.9

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import "fmt"

func main() {
 prices := map[string]float64{
 "苹果": 5.5,
 "牛奶": 12.0,
 "洗发水": 39.9,
 "书包": 128.0,
 }

 count := 0
 total := 0.0

 for name, price := range prices {
 if price < 30 {
 continue
 }

 fmt.Printf("%s: %.1f\n", name, price)
 count++
 total += price
 }

 fmt.Printf("count=%d\n", count)
 fmt.Printf("total=%.1f\n", total)
}

说明：前面几行商品输出的顺序不固定，因为 map 的遍历顺序本来就不保证一致。只要统计结果正确即可。

第 10 题：用 `break` 找到第一个及格分数

第 10 题一般

已知下面这个切片：

1

scores := []int{45, 58, 61, 73, 90}

请编写程序，完成下面要求：

遍历切片
找到第一个大于等于 60 的分数
输出它的下标和分数
找到后立即结束循环
如果整个切片里都没有及格分数，输出 未找到及格分数

示例输出：

1
2


index=2
score=61

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import "fmt"

func main() {
 scores := []int{45, 58, 61, 73, 90}
 found := false

 for index, score := range scores {
 if score >= 60 {
 fmt.Printf("index=%d\n", index)
 fmt.Printf("score=%d\n", score)
 found = true
 break
 }
 }

 if !found {
 fmt.Println("未找到及格分数")
 }
}

说明：break 很适合“找到就停”的场景。它能避免无意义地继续遍历后面的元素。

进阶

下面三题会把 01-05 单元里的输入、判断、切片、map 和 for 一起用起来，更接近真实的控制台程序。

第 11 题：编写一个循环菜单

第 11 题进阶

请编写一个程序，完成下面要求：

先准备一个成绩切片：

1

scores := []int{78, 92, 85, 66}

使用 for {} 做一个循环菜单
每轮提示用户输入一个选项： 1 表示输出总分 2 表示输出及格人数 0 表示退出程序
其他输入输出 无效选项
菜单要能重复使用，直到用户输入 0
选项分流要求使用 switch

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


package main

import "fmt"

func main() {
 scores := []int{78, 92, 85, 66}

 for {
 var choice int

 fmt.Print("请输入选项（1总分 2及格人数 0退出）：")
 fmt.Scan(&choice)

 switch choice {
 case 1:
 total := 0
 for _, score := range scores {
 total += score
 }
 fmt.Printf("总分：%d\n", total)
 case 2:
 passCount := 0
 for _, score := range scores {
 if score >= 60 {
 passCount++
 }
 }
 fmt.Printf("及格人数：%d\n", passCount)
 case 0:
 fmt.Println("退出程序")
 return
 default:
 fmt.Println("无效选项")
 continue
 }
 }
}

说明：这道题会把死循环、switch、切片遍历和统计逻辑连在一起，是一个很典型的“控制台菜单”场景。

第 12 题：使用死循环做 5 秒倒计时

第 12 题进阶

请编写一个程序，完成下面要求：

使用 for {} 创建死循环
从 5 开始倒计时
每秒输出一个数字
输出顺序是 5、4、3、2、1
倒计时结束后输出 开始

要求：

使用 time.Sleep(1 * time.Second) 控制每轮间隔
倒计时结束时要主动跳出循环

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "time"
)

func main() {
 seconds := 5

 for {
 fmt.Println(seconds)
 time.Sleep(1 * time.Second)

 seconds--
 if seconds == 0 {
 break
 }
 }

 fmt.Println("开始")
}

说明：for {} 会一直循环，所以必须自己设计退出条件。time.Sleep 用来让程序暂停 1 秒，避免一瞬间把所有数字都打印完。

第 13 题：录入成绩直到输入 `-1`

第 13 题进阶

请编写一个程序，完成下面要求：

不断读取用户输入的成绩
如果输入 -1，结束录入
如果分数小于 0 或大于 100，输出 分数无效，已跳过，并继续下一轮
对有效成绩统计人数 count、总分 total
最后输出平均分 avg，保留 1 位小数
如果用户没有输入任何有效成绩，输出 没有有效成绩

示例交互可以类似这样：

1
2
3
4
5
6
7
8


请输入成绩（-1 结束）：80
请输入成绩（-1 结束）：150
分数无效，已跳过
请输入成绩（-1 结束）：90
请输入成绩（-1 结束）：-1
count=2
total=170
avg=85.0

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import "fmt"

func main() {
 count := 0
 total := 0

 for {
 var score int

 fmt.Print("请输入成绩（-1 结束）：")
 fmt.Scan(&score)

 if score == -1 {
 break
 }

 if score < 0 || score > 100 {
 fmt.Println("分数无效，已跳过")
 continue
 }

 count++
 total += score
 }

 if count == 0 {
 fmt.Println("没有有效成绩")
 return
 }

 avg := float64(total) / float64(count)

 fmt.Printf("count=%d\n", count)
 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
}

说明：这道题是本章很有代表性的综合题。for {} 负责反复读取，break 负责结束录入，continue 负责跳过非法数据，最后再做一次统计输出。

6.1 函数定义

Fri, 03 Apr 2026 10:00:00 +0800

函数定义

概念说明

函数是将一段可复用逻辑封装起来的代码块。
它可以接收输入参数，也可以返回处理结果。
通过函数拆分业务逻辑，代码会更清晰、更容易维护。

语法/规则

使用 func 关键字定义函数。
函数名后面是参数列表，返回值写在参数列表后面。
无参数可写成 func name()，无返回值可省略返回类型。
定义后通过 函数名() 调用执行。
函数定义不能写在另一个函数内部。

语法模板

1
2
3


func 函数名(参数列表) 返回值类型 {
 // 函数体
}

基础定义与调用示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func sayHello() {
 fmt.Println("hello")
}

func add(a, b int) int {
 return a + b // 返回两个参数的和
}

func main() {
 sayHello() // 调用无参无返回值函数
 fmt.Println(add(1, 2)) // 调用有参有返回值函数
}

输出结果：

1
2


hello
3

常见错误

忘记写 func 关键字，导致语法错误。
把函数定义写进 main 等函数内部，导致编译失败。
有返回值类型却没有 return，会编译报错。
调用函数时参数数量或类型不匹配，无法通过编译。

6.2 函数参数

Fri, 03 Apr 2026 10:00:00 +0800

函数参数

概念说明

函数参数用于把数据传入函数，让同一段逻辑可复用。
Go 中最常见的参数形式有：普通参数、同类型合并参数、可变参数（...）。

语法/规则

普通参数写法：func add(a int, b int)。
同类型参数可合并：func add(a, b int)。
可变参数写法：func sum(nums ...int)。
可变参数在一个函数里只能有一个，并且必须放在参数列表最后。
调用可变参数函数时，可以传 0 个、1 个或多个同类型值。
向可变参数函数传切片时，必须写成 slice...。

参数写法示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import "fmt"

func add(n1 int, n2 int) int {
 return n1 + n2
}

func add1(n1, n2 int) int {
 return n1 + n2
}

func add2(numList ...int) int { // 可变参数，本质上可当作 []int 使用
 sum := 0
 for _, num := range numList {
 sum += num
 }
 return sum
}

func main() {
 fmt.Println(add(1, 2))
 fmt.Println(add1(3, 4))
 fmt.Println(add2(1, 2))
 fmt.Println(add2(1, 2, 3, 4))

 nums := []int{5, 6, 7}
 fmt.Println(add2(nums...)) // 把切片展开后再传参
}

输出结果：

可变参数深入理解

func sum(nums ...int) 在调用层面看是“可传多个 int”，
但在函数内部，nums 的真实类型是 []int，所以可以直接 len、range、索引访问。

nums 在函数内可当作切片使用。
不传参数时，nums 是长度为 0 的切片语义（可正常 range）。
普通参数和可变参数可以共存，例如 func report(tag string, nums ...int)。

可变参数调用对比示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import "fmt"

func sum(nums ...int) int { // nums 在函数内部就是 []int
 total := 0
 for _, n := range nums {
 total += n
 }
 return total
}

func showArgs(tag string, nums ...int) { // 普通参数和可变参数可以共存
 fmt.Printf("%s -> type=%T len=%d values=%v\n", tag, nums, len(nums), nums)
}

func main() {
 fmt.Println(sum())
 fmt.Println(sum(1, 2, 3))

 base := []int{4, 5, 6}
 fmt.Println(sum(base...)) // 切片展开传参

 showArgs("直接传值", 8, 9)
 showArgs("传切片", base...)
}

输出结果：

1
2
3
4
5


0
6
15
直接传值 -> type=[]int len=2 values=[8 9]
传切片 -> type=[]int len=3 values=[4 5 6]

展开传参（`slice...`）

fmt.Println(sum(base...)) 这种写法叫“展开传参”。
它的意思是：把切片 base 里的元素逐个拆开，作为多个参数传给 sum。

例如：

sum(1, 2, 3) 是直接传多个参数
sum(base...) 是把切片元素展开后再传参

注意两点：

可以直接展开的是“切片”，例如 []int。
数组不能直接展开，需要先切成切片再展开（如 arr[:]...）。

展开传参示例（切片与数组）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func sum(nums ...int) int {
 total := 0
 for _, n := range nums {
 total += n
 }
 return total
}

func main() {
 base := []int{4, 5, 6}
 fmt.Println(sum(base...)) // 切片可直接展开

 arr := [3]int{7, 8, 9}
 fmt.Println(sum(arr[:]...)) // 数组要先切成切片再展开
}

输出结果：

常见错误

把可变参数放在非最后位置，导致语法错误。
向可变参数函数传切片时漏写 ...，导致类型不匹配。
在同一个函数里声明多个可变参数，导致编译失败。
误以为可变参数在函数内部不是切片，从而不会用 len/range 处理它。
把数组直接写成 sum(arr...)，会报错；应写成 sum(arr[:]...)。

6.3 函数返回值

Fri, 03 Apr 2026 10:00:00 +0800

函数返回值

概念说明

函数返回值用于把处理结果从函数内部传回调用方。
Go 常见写法有：无返回值、单返回值、多返回值、命名返回值。

语法/规则

无返回值函数可省略返回类型。
单返回值写在参数列表后，例如 func f() int。
多返回值写在括号里，例如 func f() (int, error)。
命名返回值可以在函数签名中先声明，return 时可省略具体变量。
返回 error 时，调用方应先判断错误再使用结果。

不同返回值写法示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import (
 "errors"
 "fmt"
)

func fun1() {
 fmt.Println("fun1 无返回值")
}

func fun2() int {
 return 5
}

func fun3(a, b int) (int, error) {
 if b == 0 {
 return 0, errors.New("除数不能为 0") // 多返回值：结果 + 错误信息
 }
 return a / b, nil
}

func fun4() (res string) { // 命名返回值
 res = "命名返回值"
 return
}

func main() {
 fun1()
 fmt.Println(fun2())

 value, err := fun3(10, 0) // 同时接收结果和错误
 fmt.Println(value, err)

 fmt.Println(fun4())
}

输出结果：

1
2
3
4


fun1 无返回值
5
0 除数不能为 0
命名返回值

常见错误

函数声明了返回值类型却没有 return，导致编译报错。
调用多返回值函数时只接收一部分值，写法不合法。
接收到 error 后不判断就继续使用结果，容易引发逻辑错误。
命名返回值和局部变量重名，导致结果混淆。

6.4 匿名函数

Fri, 03 Apr 2026 10:00:00 +0800

匿名函数

概念说明

匿名函数是“没有函数名”的函数。
它常用于临时逻辑、回调函数、或定义后立即执行的场景。

语法/规则

匿名函数可以赋值给变量后再调用。
匿名函数也可以定义后立即执行（IIFE）。
匿名函数可像普通函数一样接收参数和返回值。
匿名函数常与闭包一起使用，捕获外层变量。

匿名函数示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 add := func(a, b int) int { // 匿名函数赋值给变量
 return a + b
 }
 fmt.Println(add(1, 2))

 func(msg string) { // 定义后立即执行
 fmt.Println(msg)
 }("匿名函数可以立即执行")
}

输出结果：

1
2


3
匿名函数可以立即执行

常见错误

误把匿名函数当声明语句写，却忘了赋值或调用，导致逻辑未执行。
匿名函数参数和调用参数不匹配，导致编译报错。
需要返回值却没有定义返回类型，导致函数签名错误。

6.5 高阶函数

Fri, 03 Apr 2026 10:00:00 +0800

高阶函数

概念说明

高阶函数是“把函数当作值来使用”的函数。
常见形式包括：函数作为参数传入、函数作为返回值返回。
在业务中常用于策略切换、回调处理和行为分发。

语法/规则

函数可以赋值给变量，也可以存进 map、切片等容器。
不同函数要放在同一个容器里，签名必须一致。
从 map 取出函数后，调用前应先判断是否存在，避免运行时错误。
当分支逻辑较多时，用“编号 -> 函数”的映射通常比多层 if 更清晰。

菜单分发示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import "fmt"

func login() {
 fmt.Println("登录")
}

func userCenter() {
 fmt.Println("个人中心")
}

func logout() {
 fmt.Println("注销")
}

func main() {
 actions := map[int]func(){ // 把函数当作值放进 map
 1: login,
 2: userCenter,
 3: logout,
 }

 choice := 2 // 模拟用户输入
 if action, ok := actions[choice]; ok { // 先判断该编号是否存在
 action() // 调用取出来的函数
 } else {
 fmt.Println("无效操作")
 }
}

输出结果：

1

个人中心

常见错误

直接调用 actions[choice]() 而不判断是否存在，可能触发 panic。
map 中函数签名不一致，导致无法放入同一容器。
误把“高阶函数”理解成“函数很多”，而不是“函数作为值参与传递”。

6.6 闭包

Fri, 03 Apr 2026 10:00:00 +0800

闭包

概念说明

闭包可以理解为“函数 + 它引用的外部变量”。
外层函数执行结束后，内层函数仍然可以继续使用这些被捕获的变量。
它适合实现延迟执行、计数器、配置函数等场景。

语法/规则

闭包本质是返回一个匿名函数，且匿名函数引用了外层变量。
被捕获的变量会在后续调用中持续生效。
闭包逻辑应尽量保持单一职责，避免过度嵌套影响可读性。

延时求和示例

目标：先传入延时参数，再传入多个整数并求和。
使用方式：awaitAdd(2)(1, 2, 3)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "time"
)

func awaitAdd(delaySecond int) func(...int) int {
 return func(numList ...int) int { // 返回一个匿名函数，并记住 delaySecond
 time.Sleep(time.Duration(delaySecond) * time.Second)

 sum := 0
 for _, num := range numList {
 sum += num
 }
 return sum
 }
}

func main() {
 fmt.Println(awaitAdd(2)(1, 2, 3)) // 先传延时，再传要相加的数字
}

逐行解释（核心函数）

先只看核心这段：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func awaitAdd(delaySecond int) func(...int) int {
 return func(numList ...int) int {
 time.Sleep(time.Duration(delaySecond) * time.Second)

 sum := 0
 for _, num := range numList {
 sum += num
 }
 return sum
 }
}

逐行解释如下：

func awaitAdd(delaySecond int) func(...int) int {
定义外层函数 awaitAdd。
它接收一个参数 delaySecond（延时秒数），返回值不是普通值，而是“另一个函数类型” func(...int) int。
return func(numList ...int) int {
返回一个匿名函数。这个匿名函数接收多个整数（可变参数），并返回一个整数（求和结果）。
time.Sleep(time.Duration(delaySecond) * time.Second)
先暂停 delaySecond 秒。这里用了外层函数的变量 delaySecond，这就是闭包捕获外部变量。
sum := 0
定义累加器，初始值为 0。
for _, num := range numList {
遍历传进来的所有整数参数。
sum += num
把每个数字累加到 sum。
return sum
把累加结果返回给调用方。
最后的 } } }
依次结束：匿名函数体、return func 语句所在块、外层函数体。

逐行解释（调用代码）

1
2
3


func main() {
 fmt.Println(awaitAdd(2)(1, 2, 3))
}

awaitAdd(2)：先调用外层函数，得到一个“已经记住延时 2 秒”的新函数。
(1, 2, 3)：再调用这个新函数，传入要相加的数字。
fmt.Println(...)：打印返回结果。

逻辑串联（从调用到返回）

把整句 awaitAdd(2)(1, 2, 3) 连起来看：

第一步：awaitAdd(2) 创建并返回一个内部函数。
第二步：内部函数拿到 1,2,3 后先等待 2 秒。
第三步：遍历 1,2,3，计算总和 6。
第四步：把 6 返回给 fmt.Println 输出。

等价写法（更容易看懂）：

1
2
3


addAfter2s := awaitAdd(2)
result := addAfter2s(1, 2, 3)
fmt.Println(result)

输出结果（等待约 2 秒后）：

1

6

常见错误

误把延时逻辑放在外层函数里，导致“创建闭包时延时”而不是“调用时延时”。
在循环中错误捕获变量，导致多个闭包共享同一最终值。
闭包层级过深且无注释，后期维护困难。
把两次调用写成一次传参（如 awaitAdd(2, 1, 2, 3)），会因为参数不匹配而编译失败。

6.7 值传递和引用传递

Fri, 03 Apr 2026 10:00:00 +0800

值传递和引用传递

概念说明

Go 的函数参数传递本质上都是“值拷贝”。
当参数类型是普通值（如 int）时，函数里改的是副本。
当参数类型是指针（如 *int）时，拷贝的是地址值，但可以通过该地址修改原变量。

语法/规则

普通值参数不会直接影响外部变量。
指针参数可通过 *指针 修改外部变量。
调用指针参数函数时，通常要传 &变量。
理解“拷贝值”与“能否改到原数据”是区分这两种写法的关键。

对比示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func changeByValue(num int, outer *int) {
 fmt.Println(outer == &num) // false：不是同一个地址
 num = 2 // 只修改副本
}

func changeByPointer(num *int, outer *int) {
 fmt.Println(outer == num) // true：是同一个地址
 *num = 2 // 通过指针修改原变量
}

func main() {
 num := 20

 changeByValue(num, &num)
 fmt.Println(num)

 changeByPointer(&num, &num)
 fmt.Println(num)
}

输出结果：

1
2
3
4


false
20
true
2

常见错误

误以为普通值参数在函数内修改后会自动影响外部变量。
调用指针参数函数时忘记传 &，导致类型不匹配。
对 nil 指针解引用（*p）会触发运行时 panic。

6.8 指针

Fri, 03 Apr 2026 10:00:00 +0800

指针

概念说明

指针保存的是“变量的内存地址”。
通过指针可以间接访问或修改该地址对应的值。
在 Go 中，指针常用于函数参数修改外部变量、减少大对象拷贝等场景。

语法/规则

& 表示取地址，例如 p := &num。
* 有两种用法：声明指针类型（*int）和解引用取值（*p）。
指针变量必须指向合法地址后再解引用。
对 nil 指针解引用会触发运行时 panic。

指针读写示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 num := 10
 p := &num // p 保存 num 的地址

 fmt.Println(*p) // 通过指针取值

 *p = 20 // 通过指针修改原变量
 fmt.Println(num)
}

输出结果：

常见错误

把 & 和 * 的含义写反，导致读写逻辑错误。
指针未初始化就解引用，触发运行时错误。
误以为指针是“引用类型”本身，忽略了传参时仍然是值拷贝。

6.9 练习

Sun, 12 Apr 2026 00:00:00 +0800

练习

学完本章你应该掌握

能根据任务拆出无参函数、有参函数、单返回值函数和多返回值函数，而不是把所有逻辑都堆在 main 里。
能正确使用普通参数、可变参数、slice... 展开传参和命名返回值，写出更灵活的函数接口。
能在函数中返回 bool、error 等结果，并在调用方完成判断、分流和错误处理。
能在合适场景下使用匿名函数、高阶函数和闭包，把“行为”当作数据来传递和复用。
能理解普通值参数与指针参数的区别，并通过 &、* 完成对外部变量的修改。
能把函数和前面学过的输入输出、基本类型、切片、map、判断、循环结合起来，写出结构更清晰的控制台程序。

简单

第 1 题：定义并调用问候函数

第 1 题简单

编写一个 Go 程序，完成下面要求：

定义一个无参无返回值函数 sayWelcome()
这个函数输出 欢迎学习函数
在 main 中调用它两次

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func sayWelcome() {
 fmt.Println("欢迎学习函数")
}

func main() {
 sayWelcome()
 sayWelcome()
}

输出结果：

1
2


欢迎学习函数
欢迎学习函数

第 2 题：编写返回较大值的函数

第 2 题简单

编写一个函数 max(a, b int) int，完成下面要求：

接收两个整数
返回其中较大的那个值
在 main 中调用 max(18, 25)，并输出 max=25

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func max(a, b int) int {
 if a > b {
 return a
 }
 return b
}

func main() {
 fmt.Printf("max=%d\n", max(18, 25))
}

第 3 题：编写返回布尔值的偶数判断函数

第 3 题简单

编写一个函数 isEven(n int) bool，完成下面要求：

如果 n 是偶数，返回 true
否则返回 false
在 main 中分别测试 8 和 11
输出格式如下：

1
2


8 -> true
11 -> false

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func isEven(n int) bool {
 return n%2 == 0
}

func main() {
 fmt.Printf("8 -> %t\n", isEven(8))
 fmt.Printf("11 -> %t\n", isEven(11))
}

说明：这道题的重点是让函数返回一个 bool，再由调用方决定怎么输出结果。

第 4 题：用函数统计切片总和

第 4 题简单

已知有一个切片：

1

scores := []int{3, 5, 7, 9}

请编写一个函数 sumSlice(nums []int) int，完成下面要求：

接收一个 []int
使用 for range 计算总和
在 main 中调用它，并输出 total=24

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func sumSlice(nums []int) int {
 total := 0
 for _, num := range nums {
 total += num
 }
 return total
}

func main() {
 scores := []int{3, 5, 7, 9}
 fmt.Printf("total=%d\n", sumSlice(scores))
}

第 5 题：修正可变参数的调用方式

第 5 题简单

下面程序想分别输出 6 和 15，但它现在不能通过编译。
请改正代码，让它正常运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func sum(nums ...int) int {
 total := 0
 for _, num := range nums {
 total += num
 }
 return total
}

func main() {
 base := []int{1, 2, 3}
 arr := [3]int{4, 5, 6}

 fmt.Println(sum(base))
 fmt.Println(sum(arr...))
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func sum(nums ...int) int {
 total := 0
 for _, num := range nums {
 total += num
 }
 return total
}

func main() {
 base := []int{1, 2, 3}
 arr := [3]int{4, 5, 6}

 fmt.Println(sum(base...))
 fmt.Println(sum(arr[:]...))
}

关键点：

向可变参数函数传切片时，要写成 base...
数组不能直接展开，要先切成切片，再写成 arr[:]...

第 6 题：用命名返回值计算长方形信息

第 6 题简单

编写一个函数 rectStats(width, height int) (area int, perimeter int)，完成下面要求：

使用命名返回值
返回长方形的面积和周长
在 main 中调用 rectStats(5, 3)
输出：

1
2


area=15
perimeter=16

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func rectStats(width, height int) (area int, perimeter int) {
 area = width * height
 perimeter = 2 * (width + height)
 return
}

func main() {
 area, perimeter := rectStats(5, 3)

 fmt.Printf("area=%d\n", area)
 fmt.Printf("perimeter=%d\n", perimeter)
}

说明：命名返回值适合返回含义明确的多个结果，但函数体仍然要保持清晰，不要为了省几个字把逻辑写乱。

第 7 题：用指针参数给分数加分

第 7 题简单

编写一个函数 addBonus(score *int)，完成下面要求：

接收一个整数指针
把这个分数加 10
在 main 中定义 score := 78
调用函数后输出修改后的结果

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func addBonus(score *int) {
 *score += 10
}

func main() {
 score := 78

 addBonus(&score)
 fmt.Println(score)
}

说明：如果函数参数写成 int，函数里改到的只是副本；这里传的是 &score，所以可以通过 *score 改到外部变量。

一般

第 8 题：实现带错误返回的安全除法

第 8 题一般

编写一个函数 safeDivide(a, b int) (int, error)，完成下面要求：

如果 b == 0，返回错误 除数不能为 0
否则返回 a / b
在 main 中分别测试 safeDivide(20, 4) 和 safeDivide(20, 0)
调用方拿到 error 后先判断，再决定输出结果

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import (
 "errors"
 "fmt"
)

func safeDivide(a, b int) (int, error) {
 if b == 0 {
 return 0, errors.New("除数不能为 0")
 }
 return a / b, nil
}

func main() {
 result, err := safeDivide(20, 4)
 if err != nil {
 fmt.Println(err)
 } else {
 fmt.Println(result)
 }

 result, err = safeDivide(20, 0)
 if err != nil {
 fmt.Println(err)
 } else {
 fmt.Println(result)
 }
}

输出结果：

1
2


5
除数不能为 0

说明：返回 error 不是为了“让函数更复杂”，而是为了让调用方知道这次计算是否真的成功。

第 9 题：编写可变参数统计函数

第 9 题一般

编写一个函数 calcStats(nums ...int) (total int, avg float64)，完成下面要求：

接收任意个整数
返回总和和平均值
如果一个数字都没传，平均值保持 0
在 main 中准备切片 scores := []int{80, 90, 85}
使用 calcStats(scores...) 调用它
输出：

1
2


total=255
avg=85.0

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

func calcStats(nums ...int) (total int, avg float64) {
 for _, num := range nums {
 total += num
 }

 if len(nums) > 0 {
 avg = float64(total) / float64(len(nums))
 }
 return
}

func main() {
 scores := []int{80, 90, 85}
 total, avg := calcStats(scores...)

 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
}

说明：这道题把可变参数、切片展开传参和命名返回值放到了一起，是函数章节里很典型的组合题。

第 10 题：编写成绩等级函数

第 10 题一般

编写一个函数 grade(score int) string，完成下面要求：

如果分数小于 0 或大于 100，返回 非法
90 ~ 100 返回 A
80 ~ 89 返回 B
60 ~ 79 返回 C
其他返回 D

然后在 main 中遍历下面这个切片，并逐行输出每个分数对应的等级：

1

scores := []int{95, 83, 61, 45, 120}

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import "fmt"

func grade(score int) string {
 switch {
 case score < 0 || score > 100:
 return "非法"
 case score >= 90:
 return "A"
 case score >= 80:
 return "B"
 case score >= 60:
 return "C"
 default:
 return "D"
 }
}

func main() {
 scores := []int{95, 83, 61, 45, 120}

 for _, score := range scores {
 fmt.Printf("%d -> %s\n", score, grade(score))
 }
}

第 11 题：封装年龄查询函数

第 11 题一般

请把 map 查询逻辑封装成一个函数，完成下面要求：

先准备一张年龄表：

1
2
3
4


ages := map[string]int{
 "阿斌": 21,
 "小王": 18,
}

编写函数 findAge(ages map[string]int, name string) (int, bool)
再让用户输入一个姓名
调用这个函数
如果找到了，输出 小王的年龄是 18
如果没找到，输出 没有找到该用户

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import "fmt"

func findAge(ages map[string]int, name string) (int, bool) {
 age, ok := ages[name]
 return age, ok
}

func main() {
 ages := map[string]int{
 "阿斌": 21,
 "小王": 18,
 }

 var name string
 fmt.Print("请输入姓名：")
 fmt.Scan(&name)

 age, ok := findAge(ages, name)
 if ok {
 fmt.Printf("%s 的年龄是 %d\n", name, age)
 } else {
 fmt.Println("没有找到该用户")
 }
}

说明：这道题的重点不是 map 本身，而是让你把“查询并返回结果”的逻辑收进函数里，让调用方只关心“找到了没有”。

第 12 题：使用立即执行匿名函数统计及格人数

第 12 题一般

已知有一个成绩切片：

1

scores := []int{78, 92, 56, 84, 67}

请使用“立即执行匿名函数”的写法，完成下面要求：

统计及格人数，及格线是 60
把结果保存到变量 passCount
最后输出 passCount=4

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func main() {
 scores := []int{78, 92, 56, 84, 67}

 passCount := func(list []int) int {
 count := 0
 for _, score := range list {
 if score >= 60 {
 count++
 }
 }
 return count
 }(scores)

 fmt.Printf("passCount=%d\n", passCount)
}

说明：匿名函数不一定要先赋值给变量，也可以“定义完立刻执行”，这种写法常见于一次性的临时逻辑。

第 13 题：实现接收函数参数的计算器

第 13 题一般

编写一个高阶函数 calc(a, b int, op func(int, int) int) int，完成下面要求：

calc 接收两个整数和一个函数参数
这个函数参数负责决定“怎么计算”
在 main 中用匿名函数分别完成两次调用：第一次计算 7 + 3 第二次取 7 和 3 中的较大值
输出格式如下：

1
2


sum=10
max=7

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func calc(a, b int, op func(int, int) int) int {
 return op(a, b)
}

func main() {
 sum := calc(7, 3, func(a, b int) int {
 return a + b
 })

 max := calc(7, 3, func(a, b int) int {
 if a > b {
 return a
 }
 return b
 })

 fmt.Printf("sum=%d\n", sum)
 fmt.Printf("max=%d\n", max)
}

说明：高阶函数的关键不在于“函数很多”，而在于“函数也能像普通值一样被传来传去”。

第 14 题：实现交换两个整数的函数

第 14 题一般

编写一个函数 swap(a, b *int)，完成下面要求：

接收两个整数指针
交换它们指向的值
在 main 中定义 x := 3、y := 9
调用函数前后都输出一次

期望输出类似这样：

1
2


before: 3 9
after: 9 3

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func swap(a, b *int) {
 temp := *a
 *a = *b
 *b = temp
}

func main() {
 x := 3
 y := 9

 fmt.Println("before:", x, y)
 swap(&x, &y)
 fmt.Println("after:", x, y)
}

说明：如果这里把函数参数写成 swap(a, b int)，交换的只会是两个副本，main 里的 x 和 y 不会真的变化。

进阶

下面四题会把 01-06 单元里的输入、判断、循环、切片、map 与函数组合起来，更接近“先拆函数，再组织流程”的真实写法。

第 15 题：实现一个闭包计数器

第 15 题进阶

编写一个函数 makeCounter(start int) func() int，完成下面要求：

外层函数接收起始值 start
返回一个匿名函数
每次调用这个匿名函数时，都先把内部值加 1，再返回
在 main 中这样测试：

1
2
3
4


counter := makeCounter(10)
fmt.Println(counter())
fmt.Println(counter())
fmt.Println(counter())

输出应为：

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func makeCounter(start int) func() int {
 return func() int {
 start++
 return start
 }
}

func main() {
 counter := makeCounter(10)

 fmt.Println(counter())
 fmt.Println(counter())
 fmt.Println(counter())
}

说明：start 原本是外层函数里的变量，但返回的匿名函数把它“记住”了，所以多次调用时状态会持续保留下来。

第 16 题：用闭包生成筛选函数

第 16 题进阶

编写一个函数 makeMinChecker(min int) func(int) bool，完成下面要求：

它返回一个新函数
这个新函数接收一个分数，并判断该分数是否大于等于 min
再编写一个辅助函数 countByChecker(scores []int, checker func(int) bool) int
使用下面这个切片做测试：

1

scores := []int{58, 61, 73, 90, 100}

创建两个检查函数： passChecker := makeMinChecker(60) excellentChecker := makeMinChecker(90)
分别统计及格人数和优秀人数

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import "fmt"

func makeMinChecker(min int) func(int) bool {
 return func(score int) bool {
 return score >= min
 }
}

func countByChecker(scores []int, checker func(int) bool) int {
 count := 0
 for _, score := range scores {
 if checker(score) {
 count++
 }
 }
 return count
}

func main() {
 scores := []int{58, 61, 73, 90, 100}

 passChecker := makeMinChecker(60)
 excellentChecker := makeMinChecker(90)

 fmt.Printf("passCount=%d\n", countByChecker(scores, passChecker))
 fmt.Printf("excellentCount=%d\n", countByChecker(scores, excellentChecker))
}

一种可能的输出结果：

1
2


passCount=4
excellentCount=2

说明：这道题把“函数作为返回值”和“函数作为参数”都连起来了，能很好地体会函数复用的价值。

第 17 题：用函数表实现循环菜单

第 17 题进阶

请编写一个程序，完成下面要求：

先准备成绩切片：

1

scores := []int{78, 92, 85, 66}

编写三个普通函数： calcTotal(scores []int) int calcAvg(scores []int) float64 bestScore(scores []int) int
再准备一个函数表 map[int]func()，让它负责菜单分发： 1 输出总分 2 输出平均分 3 输出最高分
使用 for {} 循环读取用户选项
输入 0 时退出
输入其他不存在的编号时输出 无效选项

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


package main

import "fmt"

func calcTotal(scores []int) int {
 total := 0
 for _, score := range scores {
 total += score
 }
 return total
}

func calcAvg(scores []int) float64 {
 return float64(calcTotal(scores)) / float64(len(scores))
}

func bestScore(scores []int) int {
 best := scores[0]
 for _, score := range scores[1:] {
 if score > best {
 best = score
 }
 }
 return best
}

func main() {
 scores := []int{78, 92, 85, 66}

 actions := map[int]func(){
 1: func() {
 fmt.Printf("总分：%d\n", calcTotal(scores))
 },
 2: func() {
 fmt.Printf("平均分：%.1f\n", calcAvg(scores))
 },
 3: func() {
 fmt.Printf("最高分：%d\n", bestScore(scores))
 },
 }

 for {
 var choice int

 fmt.Print("请输入选项（1总分 2平均分 3最高分 0退出）：")
 fmt.Scan(&choice)

 if choice == 0 {
 fmt.Println("退出程序")
 return
 }

 if action, ok := actions[choice]; ok {
 action()
 } else {
 fmt.Println("无效选项")
 }
 }
}

说明：这道题的重点不是菜单本身，而是体会“编号 -> 函数”的映射关系。分支一多，用函数表往往比堆很多层 if 更清晰。

第 18 题：拆分一个成绩录入分析器

第 18 题进阶

请把下面这个需求拆成多个函数来实现：

编写 readScores() []int 不断读取用户输入的成绩输入 -1 时结束如果分数小于 0 或大于 100，输出 分数无效，已跳过，然后继续下一轮合法分数追加到切片里
编写 calcStats(scores []int) (int, float64, error) 返回总分、平均分和错误信息如果一个有效成绩都没有，返回错误 没有有效成绩
编写 gradeByAvg(avg float64) string avg >= 90 返回 A avg >= 80 返回 B avg >= 60 返回 C 其他返回 D
在 main 中调用这些函数，最后输出总分、平均分和平均分等级

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71


package main

import (
 "errors"
 "fmt"
)

func readScores() []int {
 scores := []int{}

 for {
 var score int

 fmt.Print("请输入成绩（-1 结束）：")
 fmt.Scan(&score)

 if score == -1 {
 break
 }

 if score < 0 || score > 100 {
 fmt.Println("分数无效，已跳过")
 continue
 }

 scores = append(scores, score)
 }

 return scores
}

func calcStats(scores []int) (int, float64, error) {
 if len(scores) == 0 {
 return 0, 0, errors.New("没有有效成绩")
 }

 total := 0
 for _, score := range scores {
 total += score
 }

 avg := float64(total) / float64(len(scores))
 return total, avg, nil
}

func gradeByAvg(avg float64) string {
 switch {
 case avg >= 90:
 return "A"
 case avg >= 80:
 return "B"
 case avg >= 60:
 return "C"
 default:
 return "D"
 }
}

func main() {
 scores := readScores()

 total, avg, err := calcStats(scores)
 if err != nil {
 fmt.Println(err)
 return
 }

 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
 fmt.Printf("level=%s\n", gradeByAvg(avg))
}

说明：这道题把循环输入、切片追加、条件判断、错误返回和函数拆分全部串起来了。能顺利写出来，说明你已经开始真正把函数当成“组织程序结构”的工具在用了。

7.1 结构体定义

Fri, 03 Apr 2026 10:00:00 +0800

结构体定义

概念说明

结构体（struct）用于把多个不同类型的字段组织成一个整体。
它常用于描述“一个对象”的完整信息，比如学生、订单、商品等。
可以先把它理解成“数据模板”：先定义模板，再创建具体数据。

语法/规则

使用 type 名称 struct { ... } 定义结构体类型。
结构体字段由“字段名 + 类型”组成，字段名首字母大写表示可导出。
结构体实例可以通过字面量初始化。
字段可通过 实例.字段 读取和修改。
可以为结构体绑定方法，语法是 func (接收者结构体类型) 方法名(...)。
func (s Student) PrintInfo() 中，(s Student) 是接收者，PrintInfo 是方法名。

语法模板

1
2
3
4
5
6
7
8


type 结构体名称 struct {
 字段1 类型
 字段2 类型
}

func (接收者变量 结构体名称) 方法名(参数列表) {
 // 方法体
}

定义、初始化与字段修改示例

先看最容易卡住的一行：

func (s Student) PrintInfo()
(s Student)：接收者，表示这个方法属于 Student，s 是当前实例的临时名字。
PrintInfo：方法名，调用时写 student.PrintInfo()。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

type Student struct {
 Name string
 Age int
}

func (s Student) PrintInfo() {
 fmt.Printf("name:%s age:%d\n", s.Name, s.Age)
}

func main() {
 student := Student{ // 结构体字面量初始化
 Name: "阿斌",
 Age: 21,
 }

 student.Name = "阿斌知道" // 修改结构体字段
 student.PrintInfo() // 调用结构体方法
}

输出结果：

1

name:阿斌知道 age:21

常见错误

字段名和类型顺序写反（写成 string Name），会导致语法错误。
把 (s Student) 当成普通函数参数，误写成 PrintInfo(student) 这种调用方式。
初始化时字段名写错或漏写逗号，导致编译失败。

7.2 继承

Fri, 03 Apr 2026 10:00:00 +0800

继承（结构体嵌入）

概念说明

Go 没有传统面向对象里的“类继承”，常见替代方式是结构体嵌入（Embedding）。
把一个结构体匿名嵌入到另一个结构体后，外层结构体可以直接访问内层字段和方法。

语法/规则

在结构体里直接写类型名（如 People）表示匿名嵌入。
外层结构体可以通过 s.Field 直接访问嵌入结构体字段。
也可以通过完整路径访问，如 s.People.Time。
嵌入结构体的方法也会“提升”到外层结构体可调用。
如果字段或方法重名，需要使用完整路径区分。

结构体嵌入示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


package main

import "fmt"

type People struct {
 Time string
}

func (p People) Info() {
 fmt.Println("people", p.Time)
}

type Student struct {
 People // 匿名嵌入 People
 Name string
 Age int
}

func (s Student) PrintInfo() {
 fmt.Printf("name:%s age:%d\n", s.Name, s.Age)
}

func main() {
 student := Student{
 People: People{
 Time: "2026-04-11 01:20",
 },
 Name: "阿斌",
 Age: 21,
 }

 student.Name = "阿斌知道"
 student.PrintInfo()
 student.Info() // 可直接调用嵌入结构体的方法
 fmt.Println(student.People.Time)
 fmt.Println(student.Time) // 提升后可直接访问嵌入字段
}

输出结果：

1
2
3
4


name:阿斌知道 age:21
people 2026-04-11 01:20
2026-04-11 01:20
2026-04-11 01:20

常见错误

误把嵌入当作传统继承使用，忽略 Go 本质是组合复用。
字段或方法重名时不写完整路径，导致访问歧义。
以为外层结构体会自动覆盖内层方法行为，实际需显式定义同名方法。

7.3 结构体指针

Fri, 03 Apr 2026 10:00:00 +0800

结构体指针

概念说明

结构体作为函数参数或方法接收者时，既可以按值传递，也可以用指针传递。
如果希望在函数/方法内部修改原结构体，通常需要使用结构体指针。

语法/规则

值参数（Student）会复制一份数据，修改不会影响外部原值。
指针参数（*Student）传的是地址，修改会影响外部原值。
值接收者方法（func (s Student) ...）修改的是副本。
指针接收者方法（func (s *Student) ...）可修改原结构体字段。
调用指针接收者方法时，Go 会自动帮你取地址（前提是可寻址值）。

函数参数示例（值参数 vs 指针参数）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import "fmt"

type Student struct {
 Name string
 Age int
}

func SetAgeByValue(info Student, age int) {
 info.Age = age // 只改副本，不影响外部结构体
}

func SetAgeByPointer(info *Student, age int) {
 info.Age = age // 通过指针修改原结构体
}

func main() {
 student := Student{
 Name: "阿斌",
 Age: 21,
 }

 fmt.Println(student.Age)
 SetAgeByValue(student, 18)
 fmt.Println(student.Age)
 SetAgeByPointer(&student, 17)
 fmt.Println(student.Age)
}

输出结果：

方法接收者示例（值接收者 vs 指针接收者）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import "fmt"

type Student struct {
 Name string
 Age int
}

func (s Student) SetAge(age int) {
 s.Age = age // 值接收者修改的是副本
}

func (s *Student) SetAgeByPointer(age int) {
 s.Age = age // 指针接收者可修改原结构体
}

func main() {
 student := Student{
 Name: "阿斌",
 Age: 21,
 }

 student.SetAge(18)
 fmt.Println(student.Age)

 student.SetAgeByPointer(18) // 会自动取地址调用
 fmt.Println(student.Age)
}

输出结果：

常见错误

希望修改原结构体却使用了值参数或值接收者，导致修改无效。
忘记区分“读场景”和“改场景”，所有方法都用值接收者或都用指针接收者。
对 nil 结构体指针直接访问字段，可能触发运行时 panic。

7.4 结构体tag

Fri, 03 Apr 2026 10:00:00 +0800

结构体 tag

概念说明

结构体 tag 是写在字段后的元信息字符串，常用于告诉框架或库如何处理字段。
最常见场景是 encoding/json：通过 tag 指定 JSON 字段名。

语法/规则

tag 写在字段类型后面，使用反引号包裹。
常见格式为 key:"value"，例如 json:"name"。
tag 不会改变字段本身类型，只影响特定库的行为。
字段要想被 encoding/json 处理，字段名本身需大写导出。

基础示例（JSON 字段命名）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "encoding/json"
 "fmt"
)

type Student struct {
 Name string `json:"name"` // 指定 JSON 字段名
 Age int `json:"age"`
}

func main() {
 student := Student{
 Name: "阿斌",
 Age: 21,
 }

 byteData, _ := json.Marshal(student) // 序列化时会按 tag 输出字段名
 fmt.Println(string(byteData))
}

输出结果：

1

{"name":"阿斌","age":21}

常见错误

把 tag 写成双引号而不是反引号，导致语法错误。
字段名小写未导出，即使写了 tag 也不会被 JSON 库处理。
误以为 tag 会自动校验数据格式，tag 只提供元信息，不做业务校验。

7.5 json-tag

Fri, 03 Apr 2026 10:00:00 +0800

json tag

概念说明

json tag 是结构体字段上 json:"..." 形式的标签。
它用于控制结构体转 JSON 时的字段名和行为。

语法/规则

不写 json tag 时，JSON 字段名默认使用结构体字段名。
小写字段（未导出）不会被 encoding/json 编码。
json:"-" 表示该字段在 JSON 中忽略。
json:",omitempty" 表示字段是零值时省略输出。
多个选项写在同一个 tag 里，例如 json:"age,omitempty"。

忽略字段示例（`json:"-"`）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
 "encoding/json"
 "fmt"
)

type Student struct {
 Name string `json:"name"`
 Age int `json:"age"`
 Password string `json:"-"` // 该字段不会出现在 JSON 中
}

func main() {
 student := Student{
 Name: "阿斌",
 Age: 21,
 Password: "123456",
 }

 byteData, _ := json.Marshal(student)
 fmt.Println(string(byteData))
}

输出结果：

1

{"name":"阿斌","age":21}

空值省略示例（`omitempty`）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "encoding/json"
 "fmt"
)

type Student struct {
 Name string `json:"name"`
 Age int `json:"age,omitempty"` // 零值时省略该字段
}

func main() {
 student := Student{
 Name: "阿斌",
 Age: 0,
 }

 byteData, _ := json.Marshal(student)
 fmt.Println(string(byteData))
}

输出结果：

1

{"name":"阿斌"}

常见错误

字段名小写（未导出）却期望参与 JSON 编解码，结果字段被忽略。
把 json:"-" 和 omitempty 混淆：前者是永远忽略，后者是零值时忽略。
误以为 omitempty 会过滤空字符串之外的所有“无效值”，实际按类型零值规则判断。

7.6 练习

Sun, 12 Apr 2026 00:30:00 +0800

练习

学完本章你应该掌握

能定义结构体类型，完成结构体实例的初始化、字段读写和基础方法调用。
能在切片、map、函数和条件判断中自然使用结构体组织业务数据，而不是继续用零散变量硬拼。
能理解结构体嵌入的作用，知道它是组合复用而不是传统面向对象里的“类继承”。
能区分值参数、指针参数、值接收者和指针接收者在“是否修改原结构体”上的差异，并写对对应代码。
能为结构体字段添加 tag 与 json tag，控制 JSON 字段名、忽略字段和零值省略行为。
能识别并修正结构体章节的常见错误，例如字段名大小写、初始化语法、修改不生效、tag 写了却不输出等问题。

简单

第 1 题：定义并输出一张学生卡

第 1 题简单

编写一个 Go 程序，完成下面要求：

定义结构体 Student
字段包括：Name string、Age int、Score float64
创建一个学生： Name 是 小李 Age 是 18 Score 是 92.5
分别输出这三个字段

期望输出类似这样：

1
2
3


姓名：小李
年龄：18
成绩：92.5

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import "fmt"

type Student struct {
 Name string
 Age int
 Score float64
}

func main() {
 student := Student{
 Name: "小李",
 Age: 18,
 Score: 92.5,
 }

 fmt.Printf("姓名：%s\n", student.Name)
 fmt.Printf("年龄：%d\n", student.Age)
 fmt.Printf("成绩：%.1f\n", student.Score)
}

第 2 题：补全结构体字面量

第 2 题简单

已知下面的结构体：

1
2
3
4
5


type Book struct {
 Title string
 Author string
 Price float64
}

请补全下面代码中的空白，让程序输出：

1

Go 入门 - 阿斌 - 59.9

1
2
3
4
5
6
7


book := Book{
 Title: "Go 入门",
 Author: ________,
 Price: ________,
}

fmt.Printf("%s - %s - %.1f\n", book.Title, book.Author, book.Price)

查看参考答案

补全后的代码如下：

1
2
3
4
5
6
7


book := Book{
 Title: "Go 入门",
 Author: "阿斌",
 Price: 59.9,
}

fmt.Printf("%s - %s - %.1f\n", book.Title, book.Author, book.Price)

说明：结构体字面量初始化时，字段名和值之间写 :，每一行字段后面要记得写逗号。

第 3 题：给结构体绑定一个方法

第 3 题简单

编写一个 Go 程序，完成下面要求：

定义结构体 User
字段包括：Name string、City string
给它绑定一个方法 PrintProfile()
调用这个方法后输出：

1

用户：小王，城市：上海

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import "fmt"

type User struct {
 Name string
 City string
}

func (u User) PrintProfile() {
 fmt.Printf("用户：%s，城市：%s\n", u.Name, u.City)
}

func main() {
 user := User{
 Name: "小王",
 City: "上海",
 }

 user.PrintProfile()
}

说明：func (u User) PrintProfile() 里的 (u User) 是接收者，表示这个方法属于 User 类型。

第 4 题：修正一段结构体代码

第 4 题简单

下面程序有两个明显问题，请改正后让它正常运行，并输出商品价格。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

type Product struct {
 Name string
 Price float64
}

func main() {
 product := Product{
 Name: "机械键盘"
 Price: 299.0,
 }

 fmt.Println(product.price)
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

type Product struct {
 Name string
 Price float64
}

func main() {
 product := Product{
 Name: "机械键盘",
 Price: 299.0,
 }

 fmt.Println(product.Price)
}

两个问题分别是：

结构体字面量里每个字段后面要有逗号，所以 Name: "机械键盘" 这一行后面漏了逗号。
字段名是 Price，访问时也要写 product.Price，不能写成不存在的 product.price。

第 5 题：用函数接收结构体并返回简介

第 5 题简单

编写一个 Go 程序，完成下面要求：

定义结构体 Course
字段包括：Title string、Hours int
编写函数 buildSummary(c Course) string
让这个函数返回类似下面的文字：

1

课程：Go 结构体，总课时：6

在 main 中创建一个课程并调用这个函数

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import "fmt"

type Course struct {
 Title string
 Hours int
}

func buildSummary(c Course) string {
 return fmt.Sprintf("课程：%s，总课时：%d", c.Title, c.Hours)
}

func main() {
 course := Course{
 Title: "Go 结构体",
 Hours: 6,
 }

 fmt.Println(buildSummary(course))
}

说明：这道题把结构体和前面学过的函数放到了一起，让“多个字段的数据”可以整体传给函数处理。

一般

第 6 题：用结构体切片统计成绩

第 6 题一般

编写一个程序，完成下面要求：

定义结构体 Student
字段包括：Name string、Score int
准备下面这组数据：

1
2
3
4
5


students := []Student{
 {Name: "小李", Score: 82},
 {Name: "小王", Score: 59},
 {Name: "小张", Score: 91},
}

使用 for range 遍历这组结构体数据
统计及格人数 passCount
统计平均分 avg，保留 1 位小数

期望输出类似这样：

1
2


passCount=2
avg=77.3

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


package main

import "fmt"

type Student struct {
 Name string
 Score int
}

func main() {
 students := []Student{
 {Name: "小李", Score: 82},
 {Name: "小王", Score: 59},
 {Name: "小张", Score: 91},
 }

 total := 0
 passCount := 0

 for _, student := range students {
 total += student.Score
 if student.Score >= 60 {
 passCount++
 }
 }

 avg := float64(total) / float64(len(students))

 fmt.Printf("passCount=%d\n", passCount)
 fmt.Printf("avg=%.1f\n", avg)
}

说明：这道题的重点是把一组“相关字段”装进结构体，再配合切片和循环做统计，而不是继续维护多组并行变量。

第 7 题：使用结构体嵌入复用字段和方法

第 7 题一般

编写一个 Go 程序，完成下面要求：

定义结构体 People，字段为 City string
给 People 绑定方法 PrintCity()，输出 城市：北京
定义结构体 Employee
让 Employee 匿名嵌入 People
再增加字段：Name string、Role string
创建一个员工并完成下面两件事：输出 员工：小刘，角色：开发 直接调用 employee.PrintCity()

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import "fmt"

type People struct {
 City string
}

func (p People) PrintCity() {
 fmt.Printf("城市：%s\n", p.City)
}

type Employee struct {
 People
 Name string
 Role string
}

func main() {
 employee := Employee{
 People: People{
 City: "北京",
 },
 Name: "小刘",
 Role: "开发",
 }

 fmt.Printf("员工：%s，角色：%s\n", employee.Name, employee.Role)
 employee.PrintCity()
}

说明：Employee 并不是“继承了一个类”，而是通过嵌入 People 复用了字段和方法。

第 8 题：用指针参数给用户过生日

第 8 题一般

编写一个程序，完成下面要求：

定义结构体 User
字段包括：Name string、Age int
编写函数 birthday(u *User)
这个函数的作用是让用户年龄加 1
在 main 中先输出年龄，再调用函数，再输出年龄

期望输出类似这样：

1
2


before: 20
after: 21

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

type User struct {
 Name string
 Age int
}

func birthday(u *User) {
 u.Age++
}

func main() {
 user := User{
 Name: "小周",
 Age: 20,
 }

 fmt.Println("before:", user.Age)
 birthday(&user)
 fmt.Println("after:", user.Age)
}

说明：如果这里把参数写成 User 而不是 *User，函数里改到的只是副本，外面的 user.Age 不会变化。

第 9 题：把值接收者改成指针接收者

第 9 题一般

下面程序想给商品补库存，但现在补完以后库存没有变化。
请改正代码，让它最终输出：

1

15

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

type Goods struct {
 Name string
 Stock int
}

func (g Goods) AddStock(n int) {
 g.Stock += n
}

func main() {
 goods := Goods{
 Name: "耳机",
 Stock: 10,
 }

 goods.AddStock(5)
 fmt.Println(goods.Stock)
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

type Goods struct {
 Name string
 Stock int
}

func (g *Goods) AddStock(n int) {
 g.Stock += n
}

func main() {
 goods := Goods{
 Name: "耳机",
 Stock: 10,
 }

 goods.AddStock(5)
 fmt.Println(goods.Stock)
}

关键点：

原来的 func (g Goods) AddStock 是值接收者，修改的是副本。
改成 func (g *Goods) AddStock 以后，方法内部改到的就是原结构体。
调用时写 goods.AddStock(5) 就可以，Go 会自动帮你取地址。

第 10 题：按姓名查询学生信息

第 10 题一般

编写一个程序，完成下面要求：

定义结构体 Student
字段包括：Name string、Age int、Score int
准备一张 map[string]Student
数据如下：

1
2
3
4


students := map[string]Student{
 "小李": {Name: "小李", Age: 18, Score: 88},
 "小王": {Name: "小王", Age: 19, Score: 95},
}

读取一个姓名
如果存在，输出：

1

姓名：小王，年龄：19，成绩：95

如果不存在，输出：

1

没有找到该学生

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import "fmt"

type Student struct {
 Name string
 Age int
 Score int
}

func main() {
 students := map[string]Student{
 "小李": {Name: "小李", Age: 18, Score: 88},
 "小王": {Name: "小王", Age: 19, Score: 95},
 }

 var name string

 fmt.Print("请输入姓名：")
 fmt.Scan(&name)

 if student, ok := students[name]; ok {
 fmt.Printf("姓名：%s，年龄：%d，成绩：%d\n", student.Name, student.Age, student.Score)
 } else {
 fmt.Println("没有找到该学生")
 }
}

说明：这道题把结构体和前面学过的 map、输入、if 初始化语句; 条件 放到了一起，很接近真实的数据查询场景。

进阶

下面四题会把结构体和指针、切片、函数、encoding/json 放到更接近真实数据组织的场景里，重点考察多个知识点的配合使用。

第 11 题：为文章结构体添加 json tag

第 11 题进阶

编写一个程序，完成下面要求：

定义结构体 Article
字段包括：Title string、Author string、ViewCount int
给它们添加合适的 json tag
要求序列化后的 JSON 字段名分别是： title author view_count
创建一篇文章并转成 JSON 输出

期望输出类似这样：

1

{"title":"Go结构体","author":"小王","view_count":120}

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
 "encoding/json"
 "fmt"
)

type Article struct {
 Title string `json:"title"`
 Author string `json:"author"`
 ViewCount int `json:"view_count"`
}

func main() {
 article := Article{
 Title: "Go结构体",
 Author: "小王",
 ViewCount: 120,
 }

 data, _ := json.Marshal(article)
 fmt.Println(string(data))
}

说明：json tag 不会改变结构体字段本身的名字和类型，它只是告诉 encoding/json 在序列化时应该用什么 JSON 字段名。

第 12 题：使用 `json:"-"` 和 `omitempty` 导出用户资料

第 12 题进阶

编写一个程序，完成下面要求：

定义结构体 Profile
字段包括： Name string Age int Password string Phone string
JSON 规则如下： Name 输出成 name Age 输出成 age，但如果是零值则省略 Password 永远不要出现在 JSON 中 Phone 输出成 phone，但如果是空字符串则省略
创建下面这个值：

1
2
3
4
5
6


profile := Profile{
 Name: "小周",
 Age: 0,
 Password: "123456",
 Phone: "",
}

把它转成 JSON 并输出

期望输出：

1

{"name":"小周"}

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
 "encoding/json"
 "fmt"
)

type Profile struct {
 Name string `json:"name"`
 Age int `json:"age,omitempty"`
 Password string `json:"-"`
 Phone string `json:"phone,omitempty"`
}

func main() {
 profile := Profile{
 Name: "小周",
 Age: 0,
 Password: "123456",
 Phone: "",
 }

 data, _ := json.Marshal(profile)
 fmt.Println(string(data))
}

说明：

json:"-" 表示这个字段永远不参与 JSON 编码。
omitempty 表示字段是零值时省略输出，0、""、false 都可能被省略。

第 13 题：修正 tag 写了却没有输出的问题

第 13 题进阶

下面程序希望输出：

1

{"name":"阿斌","age":21}

但它现在输出的是：

1

{}

请改正代码，让 JSON 正常包含姓名和年龄。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "encoding/json"
 "fmt"
)

type student struct {
 name string `json:"name"`
 age int `json:"age"`
}

func main() {
 s := student{
 name: "阿斌",
 age: 21,
 }

 data, _ := json.Marshal(s)
 fmt.Println(string(data))
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "encoding/json"
 "fmt"
)

type Student struct {
 Name string `json:"name"`
 Age int `json:"age"`
}

func main() {
 s := Student{
 Name: "阿斌",
 Age: 21,
 }

 data, _ := json.Marshal(s)
 fmt.Println(string(data))
}

原因说明：

encoding/json 只能处理可导出的字段，也就是首字母大写的字段。
原来的 name 和 age 虽然写了 tag，但字段本身是小写，仍然不会被 JSON 编码。
tag 只是附加说明，不能替代“字段需要导出”这条规则。

第 14 题：实现一个班级成绩报告

第 14 题进阶

请完成一个稍微完整一点的小场景：

定义结构体 Student
字段包括： Name string Score int Comment string
给这三个字段添加合适的 json tag
其中 Comment 为空时不输出到 JSON
给 Student 绑定一个指针接收者方法 AddBonus(points int)，用于给分数加分
准备下面这组学生数据：

1
2
3
4
5


students := []Student{
 {Name: "小李", Score: 58, Comment: "需要补作业"},
 {Name: "小王", Score: 76},
 {Name: "小张", Score: 59},
}

遍历这组数据：如果学生分数小于 60，就给他加 5 分统计最终的及格人数 passCount 统计最终平均分 avg
最后把更新后的学生切片转成 JSON 输出

期望输出类似这样：

1
2
3


passCount=3
avg=67.7
[{"name":"小李","score":63,"comment":"需要补作业"},{"name":"小王","score":76},{"name":"小张","score":64}]

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


package main

import (
 "encoding/json"
 "fmt"
)

type Student struct {
 Name string `json:"name"`
 Score int `json:"score"`
 Comment string `json:"comment,omitempty"`
}

func (s *Student) AddBonus(points int) {
 s.Score += points
}

func main() {
 students := []Student{
 {Name: "小李", Score: 58, Comment: "需要补作业"},
 {Name: "小王", Score: 76},
 {Name: "小张", Score: 59},
 }

 total := 0
 passCount := 0

 for i := range students {
 if students[i].Score < 60 {
 students[i].AddBonus(5)
 }

 total += students[i].Score
 if students[i].Score >= 60 {
 passCount++
 }
 }

 avg := float64(total) / float64(len(students))

 fmt.Printf("passCount=%d\n", passCount)
 fmt.Printf("avg=%.1f\n", avg)

 data, _ := json.Marshal(students)
 fmt.Println(string(data))
}

说明：

这里使用 for i := range students，是为了直接修改切片里的原始结构体元素。
如果写成 for _, student := range students，拿到的是每个元素的副本，修改时很容易和预期不一致。
这道题把结构体、指针接收者、切片遍历、判断统计和 JSON 输出都串起来了，比较接近真实业务中的数据处理流程。

8.1 自定义类型

Sat, 11 Apr 2026 09:30:00 +0800

自定义类型

概念说明

自定义类型是用 type 基于已有类型定义出来的新类型。
它和底层类型有相同的存储方式，但在 Go 类型系统里是一个独立类型。

自定义类型常用于给普通值增加业务语义。
例如把 int 包装成 StatusCode，代码里就能看出这个整数代表“状态码”。

语法/规则

使用 type 新类型名底层类型 定义自定义类型。
自定义类型可以绑定方法。
自定义类型和底层类型不是同一个类型，比较或赋值时通常需要显式转换。
常量可以声明为自定义类型，便于集中维护业务枚举值。
自定义类型适合表达业务语义，不适合为了“换名字”而滥用。

语法模板

1

type 新类型名 底层类型

状态码类型示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


package main

import "fmt"

type StatusCode int // 基于 int 定义一个新的类型

const (
 StatusOK StatusCode = 0
 StatusInvalid StatusCode = 7
 StatusError StatusCode = 8
)

func (code StatusCode) Message() string {
 switch code {
 case StatusOK:
 return "success"
 case StatusInvalid:
 return "invalid"
 case StatusError:
 return "error"
 default:
 return "unknown"
 }
}

func main() {
 var rawCode int = 0

 fmt.Println(StatusOK.Message()) // 自定义类型也可以绑定方法
 fmt.Println(int(StatusOK) == rawCode) // 和 int 比较时要先显式转换
}

输出结果：

1
2


success
true

常见错误

误以为 type StatusCode int 定义出来的类型可以直接当作 int 使用，实际比较时通常需要转换。
只用 int 表示所有业务码，导致代码里看不出值的含义。
给简单类型绑定过多方法，让类型承担了超出它本身含义的职责。

8.2 类型别名

Sat, 11 Apr 2026 09:30:00 +0800

类型别名

概念说明

类型别名使用 type 新名字 = 原类型 定义。
它不会创建一个全新的类型，只是给已有类型增加一个别名。

它和自定义类型最容易混淆：
自定义类型是新类型，类型别名仍然是原类型。

语法/规则

类型别名语法中间有等号：type Alias = 原类型。
类型别名不会产生新类型，打印类型时通常仍显示原类型。
类型别名可以和原类型直接比较或赋值。
类型别名不适合用来给内置类型新增方法。
类型别名常用于重构、迁移包路径或兼容旧名称。

类型别名与自定义类型对比示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import "fmt"

type AliasCode = int // 类型别名，本质上还是 int
type StatusCode int // 自定义类型，是一个新类型

const (
 OK StatusCode = 0
 AliasOK AliasCode = 0
)

func (code StatusCode) Message() string {
 return "success"
}

func main() {
 var rawCode int = 0

 fmt.Printf("%T %T\n", OK, AliasOK) // 对比自定义类型和别名的实际类型
 fmt.Println(AliasOK == rawCode) // 别名可直接和原类型比较
 fmt.Println(int(OK) == rawCode) // 自定义类型通常要先转换
 fmt.Println(OK.Message())
}

输出结果：

1
2
3
4


main.StatusCode int
true
true
success

常见错误

把 type Alias = int 当成“新类型”使用，实际它仍然是 int。
忘记类型别名语法中的 =，导致定义成自定义类型。
试图通过内置类型别名给内置类型新增方法，通常无法达到预期。
为了让变量名更“好看”而滥用类型别名，反而降低代码可读性。

8.3 练习

Sun, 12 Apr 2026 01:10:00 +0800

练习

学完本章你应该掌握

能区分自定义类型和类型别名，理解“是否产生新类型”会影响赋值、比较、传参和方法绑定。
能使用 type 新类型底层类型 为普通值补充业务语义，并通过常量集中表达状态、等级等枚举值。
能在需要时完成自定义类型与底层类型之间的显式转换，避免直接混用导致的编译错误。
能判断什么时候更适合使用类型别名，什么时候更适合使用自定义类型，而不是为了“换个名字”随意定义。
能把本章知识自然放进函数、结构体、切片、map 和控制流程里，写出语义更清晰的基础程序。
能识别并修正常见错误，例如漏写 =、把自定义类型直接和底层类型比较、把别名误当成新类型使用。

简单

第 1 题：定义一个订单状态自定义类型

第 1 题简单

编写一个 Go 程序，完成下面要求：

定义自定义类型 OrderStatus，底层类型是 int
定义两个常量： StatusPending = 1 StatusPaid = 2
在 main 中定义 status := StatusPaid
先输出它对应的整数值
再定义 raw := 2
判断 status 和 raw 是否表示同一个值，并输出结果

要求：比较时请使用显式类型转换。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

type OrderStatus int

const (
 StatusPending OrderStatus = 1
 StatusPaid OrderStatus = 2
)

func main() {
 status := StatusPaid
 raw := 2

 fmt.Println(int(status))
 fmt.Println(int(status) == raw)
}

输出结果：

1
2


2
true

说明：OrderStatus 是一个新类型，虽然底层是 int，但和 int 变量比较时仍应先显式转换。

第 2 题：判断哪些写法可以通过编译

第 2 题简单

下面这些写法里，哪些可以通过编译，哪些不能？请分别写出结果，并简要说明原因。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


type StatusCode int
type AliasCode = int

var raw int = 200

A. var a StatusCode = 200
B. var b int = a
C. var c int = int(a)
D. var d AliasCode = raw
E. var e int = d
F. fmt.Println(a == raw)

查看参考答案

可以通过编译的是：

1

A、C、D、E

不能通过编译的是：

1

B、F

原因说明：

A 合法，200 可以赋值给 StatusCode。
B 不合法，StatusCode 是新类型，不能直接赋值给 int。
C 合法，先转成 int(a) 就可以。
D 合法，AliasCode 是 int 的别名，本质上还是 int。
E 合法，别名和原类型可以直接赋值。
F 不合法，a 是 StatusCode，raw 是 int 变量，二者不能直接比较。

第 3 题：修正自定义类型和整数混用错误

第 3 题简单

下面程序想输出：

1

17

但它现在不能通过编译。请改正后让它正常运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

type Price int

func main() {
 var shipping Price = 12
 discount := 5

 total := shipping + discount
 if shipping == discount {
 fmt.Println("运费和优惠金额相同")
 }

 fmt.Println(total)
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

type Price int

func main() {
 var shipping Price = 12
 discount := 5

 total := shipping + Price(discount)
 if shipping == Price(discount) {
 fmt.Println("运费和优惠金额相同")
 }

 fmt.Println(total)
}

关键点：

Price 是自定义类型，不能直接和 int 做加法。
比较时也要保证两边类型一致，所以这里同样要先转换。

第 4 题：使用类型别名判断编辑权限

第 4 题简单

编写一个 Go 程序，完成下面要求：

定义类型别名 UserID = int
定义 ownerID，值为 1001
定义 currentID，值为 1001
如果两者相等，输出 当前用户可以编辑
否则输出 无权限

要求：直接比较，不要额外做类型转换。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

type UserID = int

func main() {
 var ownerID UserID = 1001
 currentID := 1001

 if ownerID == currentID {
 fmt.Println("当前用户可以编辑")
 } else {
 fmt.Println("无权限")
 }
}

说明：UserID 是 int 的别名，所以这里可以直接和 int 比较。

第 5 题：给会员等级自定义类型绑定方法

第 5 题简单

编写一个 Go 程序，完成下面要求：

定义自定义类型 MemberLevel，底层类型是 int
定义三个常量： LevelNormal = 1 LevelVIP = 2 LevelSVIP = 3
给 MemberLevel 绑定方法 Name() string
返回规则如下： LevelNormal 返回 普通会员 LevelVIP 返回 VIP会员 LevelSVIP 返回 SVIP会员 其他值返回 未知等级
在 main 中输出 LevelVIP.Name()

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import "fmt"

type MemberLevel int

const (
 LevelNormal MemberLevel = 1
 LevelVIP MemberLevel = 2
 LevelSVIP MemberLevel = 3
)

func (m MemberLevel) Name() string {
 switch m {
 case LevelNormal:
 return "普通会员"
 case LevelVIP:
 return "VIP会员"
 case LevelSVIP:
 return "SVIP会员"
 default:
 return "未知等级"
 }
}

func main() {
 fmt.Println(LevelVIP.Name())
}

输出结果：

1

VIP会员

说明：自定义类型可以绑定方法，这也是它和“只是换个名字”的类型别名之间很重要的区别。

一般

第 6 题：用自定义分数类型统计总分和平均分

第 6 题一般

编写一个程序，完成下面要求：

定义自定义类型 Score，底层类型是 int
编写函数 calcStats(scores []Score) (total int, avg float64)
在函数中使用 for range 统计总分和平均分
准备下面这个切片：

1

scores := []Score{78, 92, 85, 60}

在 main 中调用这个函数
输出：

1
2


total=315
avg=78.8

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import "fmt"

type Score int

func calcStats(scores []Score) (total int, avg float64) {
 for _, score := range scores {
 total += int(score)
 }

 if len(scores) > 0 {
 avg = float64(total) / float64(len(scores))
 }
 return
}

func main() {
 scores := []Score{78, 92, 85, 60}
 total, avg := calcStats(scores)

 fmt.Printf("total=%d\n", total)
 fmt.Printf("avg=%.1f\n", avg)
}

说明：Score 虽然底层是 int，但在累加到 int total 时仍要显式转换，这正是自定义类型“语义更清晰，但不会自动混用”的体现。

第 7 题：用别名和自定义类型组织订单查询

第 7 题一般

编写一个程序，完成下面要求：

定义类型别名 OrderID = int
定义自定义类型 OrderStatus，底层类型是 int
定义三个状态常量： StatusPending = 1 StatusPaid = 2 StatusShipped = 3
给 OrderStatus 绑定方法 Text() string
定义结构体 Order，字段包括： ID OrderID Buyer string Status OrderStatus
准备一张订单表：

1
2
3
4


orders := map[OrderID]Order{
 1001: {ID: 1001, Buyer: "阿斌", Status: StatusPaid},
 1002: {ID: 1002, Buyer: "小李", Status: StatusPending},
}

读取一个订单编号
如果存在，输出：

1

订单1001，买家：阿斌，状态：已支付

如果不存在，输出：

1

没有找到该订单

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package main

import "fmt"

type OrderID = int
type OrderStatus int

const (
 StatusPending OrderStatus = 1
 StatusPaid OrderStatus = 2
 StatusShipped OrderStatus = 3
)

func (s OrderStatus) Text() string {
 switch s {
 case StatusPending:
 return "待支付"
 case StatusPaid:
 return "已支付"
 case StatusShipped:
 return "已发货"
 default:
 return "未知状态"
 }
}

type Order struct {
 ID OrderID
 Buyer string
 Status OrderStatus
}

func main() {
 orders := map[OrderID]Order{
 1001: {ID: 1001, Buyer: "阿斌", Status: StatusPaid},
 1002: {ID: 1002, Buyer: "小李", Status: StatusPending},
 }

 var id int

 fmt.Print("请输入订单编号：")
 fmt.Scan(&id)

 if order, ok := orders[id]; ok {
 fmt.Printf("订单%d，买家：%s，状态：%s\n", order.ID, order.Buyer, order.Status.Text())
 } else {
 fmt.Println("没有找到该订单")
 }
}

说明：这道题里 OrderID 用别名是为了保留和 int 的直接兼容；OrderStatus 用自定义类型是为了让状态值拥有自己的语义和方法。

第 8 题：修正把别名写成自定义类型的代码

第 8 题一般

下面程序的设计目标是：

用户输入的是普通 int
这个 int 可以直接拿来查询 users 这张表
不希望每次查表时都手动做类型转换

但它现在不能通过编译。请改正代码，并保持上面的设计目标不变。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import "fmt"

type UserID int

type User struct {
 ID UserID
 Name string
}

func main() {
 users := map[UserID]User{
 1001: {ID: 1001, Name: "阿斌"},
 1002: {ID: 1002, Name: "小李"},
 }

 var inputID int
 fmt.Print("请输入用户编号：")
 fmt.Scan(&inputID)

 if user, ok := users[inputID]; ok {
 fmt.Println(user.Name)
 } else {
 fmt.Println("没有找到该用户")
 }
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import "fmt"

type UserID = int

type User struct {
 ID UserID
 Name string
}

func main() {
 users := map[UserID]User{
 1001: {ID: 1001, Name: "阿斌"},
 1002: {ID: 1002, Name: "小李"},
 }

 var inputID int
 fmt.Print("请输入用户编号：")
 fmt.Scan(&inputID)

 if user, ok := users[inputID]; ok {
 fmt.Println(user.Name)
 } else {
 fmt.Println("没有找到该用户")
 }
}

原因说明：

原来的 type UserID int 定义的是自定义类型，不是别名。
如果目标是“让 int 可以直接使用”，就应该写成 type UserID = int。
这道题的重点不是语法细节本身，而是先想清楚这个场景到底要“新类型”还是要“兼容旧类型”。

进阶

下面两题会把前面学过的函数、结构体、切片、map、判断和循环一起用起来，重点考察你是否真的能把“自定义类型”和“类型别名”放进更完整的数据建模场景里。

第 9 题：统计任务状态数量

第 9 题进阶

请编写一个程序，完成下面要求：

定义自定义类型 TaskStatus，底层类型是 int
定义三个状态常量： StatusTodo = 1 StatusDoing = 2 StatusDone = 3
给 TaskStatus 绑定方法 Text() string
定义结构体 Task，字段包括： Name string Status TaskStatus
准备下面这组任务数据：

1
2
3
4
5
6
7


tasks := []Task{
 {Name: "看课", Status: StatusTodo},
 {Name: "写笔记", Status: StatusDoing},
 {Name: "做练习", Status: StatusDone},
 {Name: "复盘", Status: StatusTodo},
 {Name: "提交作业", Status: StatusDone},
}

遍历任务切片，用 map[TaskStatus]int 统计每种状态的数量
最后按下面顺序输出：

1
2
3


待开始: 2
进行中: 1
已完成: 2

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package main

import "fmt"

type TaskStatus int

const (
 StatusTodo TaskStatus = 1
 StatusDoing TaskStatus = 2
 StatusDone TaskStatus = 3
)

func (s TaskStatus) Text() string {
 switch s {
 case StatusTodo:
 return "待开始"
 case StatusDoing:
 return "进行中"
 case StatusDone:
 return "已完成"
 default:
 return "未知状态"
 }
}

type Task struct {
 Name string
 Status TaskStatus
}

func main() {
 tasks := []Task{
 {Name: "看课", Status: StatusTodo},
 {Name: "写笔记", Status: StatusDoing},
 {Name: "做练习", Status: StatusDone},
 {Name: "复盘", Status: StatusTodo},
 {Name: "提交作业", Status: StatusDone},
 }

 counts := make(map[TaskStatus]int)
 for _, task := range tasks {
 counts[task.Status]++
 }

 order := []TaskStatus{StatusTodo, StatusDoing, StatusDone}
 for _, status := range order {
 fmt.Printf("%s: %d\n", status.Text(), counts[status])
 }
}

说明：这道题里，自定义类型不只是“看起来更清楚”，它还直接参与了方法调用、切片字段建模和 map 统计键的设计。

第 10 题：实现一个学员等级报告

第 10 题进阶

请完成一个稍微完整一点的小场景：

定义类型别名 StudentID = int
定义自定义类型 ResultLevel，底层类型是 int
定义四个等级常量： LevelA LevelB LevelC LevelD
给 ResultLevel 绑定方法 Text() string
编写函数 judge(score int) ResultLevel score >= 90 返回 LevelA score >= 80 返回 LevelB score >= 60 返回 LevelC 其他返回 LevelD
定义结构体 Student，字段包括： ID StudentID Name string Score int
准备下面这组学生数据：

1
2
3
4
5
6


students := []Student{
 {ID: 1001, Name: "阿斌", Score: 92},
 {ID: 1002, Name: "小李", Score: 85},
 {ID: 1003, Name: "小王", Score: 76},
 {ID: 1004, Name: "小周", Score: 59},
}

遍历学生切片，逐行输出每个学生的编号、姓名和等级
再使用 map[ResultLevel]int 统计各等级人数
最后按 A / B / C / D 的顺序输出统计结果

示例输出可以类似这样：

1
2
3
4
5
6
7
8


1001 阿斌 -> A
1002 小李 -> B
1003 小王 -> C
1004 小周 -> D
A: 1
B: 1
C: 1
D: 1

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69


package main

import "fmt"

type StudentID = int
type ResultLevel int

const (
 LevelA ResultLevel = 1
 LevelB ResultLevel = 2
 LevelC ResultLevel = 3
 LevelD ResultLevel = 4
)

func (r ResultLevel) Text() string {
 switch r {
 case LevelA:
 return "A"
 case LevelB:
 return "B"
 case LevelC:
 return "C"
 case LevelD:
 return "D"
 default:
 return "未知"
 }
}

func judge(score int) ResultLevel {
 switch {
 case score >= 90:
 return LevelA
 case score >= 80:
 return LevelB
 case score >= 60:
 return LevelC
 default:
 return LevelD
 }
}

type Student struct {
 ID StudentID
 Name string
 Score int
}

func main() {
 students := []Student{
 {ID: 1001, Name: "阿斌", Score: 92},
 {ID: 1002, Name: "小李", Score: 85},
 {ID: 1003, Name: "小王", Score: 76},
 {ID: 1004, Name: "小周", Score: 59},
 }

 counts := make(map[ResultLevel]int)

 for _, student := range students {
 level := judge(student.Score)
 fmt.Printf("%d %s -> %s\n", student.ID, student.Name, level.Text())
 counts[level]++
 }

 order := []ResultLevel{LevelA, LevelB, LevelC, LevelD}
 for _, level := range order {
 fmt.Printf("%s: %d\n", level.Text(), counts[level])
 }
}

说明：这道题把“别名适合兼容旧类型”“自定义类型适合承载业务语义”这两个选择放进同一个小项目里了。StudentID 保持了和 int 的直接兼容，ResultLevel 则承担了等级表达、方法调用和统计分组这些更明确的业务职责。

9.1 接口定义与实现

Sat, 11 Apr 2026 09:30:00 +0800

接口定义与实现

概念说明

接口（interface）用于描述“行为”。
只要某个类型拥有接口要求的全部方法，它就自动满足这个接口。

Go 不需要显式写 implements。
implements 可以理解为“声明某个类型实现了某个接口”，一些语言需要这样写，但 Go 只看方法是否匹配。
这种方式叫隐式实现，也就是不写额外声明，只要方法集匹配就自动满足接口。

关键规则

接口里只声明方法签名，不写方法体。
类型只要方法匹配，就自动实现接口。
接口变量可以保存任意满足该接口的值。
接口适合让同一段代码处理多种类型。

语法模板

1
2
3


type 接口名 interface {
 方法名(参数列表) 返回值列表
}

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


package main

import "fmt"

type Speaker interface { // 只要有 Speak() string 方法，就满足 Speaker 接口
 Speak() string
}

type Dog struct {
 Name string
}

func (dog Dog) Speak() string { // Dog 实现 Speaker 接口
 return dog.Name + ": wang"
}

type Cat struct {
 Name string
}

func (cat Cat) Speak() string { // Cat 也实现 Speaker 接口
 return cat.Name + ": miao"
}

func say(speaker Speaker) { // 接收任何满足 Speaker 接口的值
 fmt.Println(speaker.Speak())
}

func main() {
 say(Dog{Name: "dog"}) // Dog{Name: "dog"} 是创建结构体值，不是函数调用
 say(Cat{Name: "cat"})
}

输出结果：

1
2


dog: wang
cat: miao

怎么理解这个示例

say(speaker Speaker) 接收的不是固定结构体，而是任何满足 Speaker 接口的值。
Dog{Name: "dog"} 不是 Dog() 函数调用，而是创建一个 Dog 结构体值。
下面这段展开写法和 say(Dog{Name: "dog"}) 的理解方式是等价的：

1
2
3
4


dog := Dog{Name: "dog"} // 创建一个 Dog 类型的值
var speaker Speaker = dog // 放进接口变量，因为 Dog 实现了 Speaker

fmt.Println(speaker.Speak()) // 实际调用 Dog 的 Speak 方法

speaker.Speak() 调用的是接口里实际保存值对应的方法。保存 Dog 就调用 Dog.Speak()，保存 Cat 就调用 Cat.Speak()。

什么时候使用接口

多个类型要完成同一行为时，就可以考虑接口。

有多个不同类型，要做同一件事。
你希望调用方只关心“能不能做”，不关心“具体是什么类型”。
以后可能还会新增更多同类实现。

场景：发送通知

假设程序现在支持邮件通知和短信通知。它们的共同点都是“发送通知”，只是实现方式不同。

不使用接口时

不用接口时，通常会为每种类型单独写函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


type Email struct{}

func (email Email) Send(message string) {
 fmt.Println("邮件通知：", message)
}

type SMS struct{}

func (sms SMS) Send(message string) {
 fmt.Println("短信通知：", message)
}

func sendEmail(email Email, message string) { // 只能处理 Email
 email.Send(message)
}

func sendSMS(sms SMS, message string) { // 只能处理 SMS
 sms.Send(message)
}

调用时要分别写：

1
2


sendEmail(Email{}, "订单已支付")
sendSMS(SMS{}, "验证码是 1234")

问题在于：

每增加一种通知方式，往往就要多写一个函数。
调用代码不统一，函数名会越来越多。
以后新增微信通知，还得继续补 sendWeChat。

使用接口时

把“发送通知”抽成接口后，可以统一处理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


type Notifier interface {
 Send(message string)
}

type Email struct{}

func (email Email) Send(message string) {
 fmt.Println("邮件通知：", message)
}

type SMS struct{}

func (sms SMS) Send(message string) {
 fmt.Println("短信通知：", message)
}

func notify(notifier Notifier, message string) { // 统一接收所有满足 Notifier 的类型
 notifier.Send(message)
}

调用时统一写成：

1
2


notify(Email{}, "订单已支付")
notify(SMS{}, "验证码是 1234")

为什么更方便

调用方式统一，只需要 notify(...)。
新增实现时，通常不用改原来的 notify 函数。
调用方只关心“能不能发送通知”，不关心具体类型。

如果以后新增微信通知，只要实现同样的方法即可：

1
2
3
4
5
6
7


type WeChat struct{}

func (wechat WeChat) Send(message string) {
 fmt.Println("微信通知：", message)
}

notify(WeChat{}, "你有一条新消息") // 新类型只要实现同样方法，也能直接复用 notify

什么时候适合用接口

适合：

多个类型有相同行为。
希望同一个函数处理多种类型。
代码以后可能扩展新的实现。

暂时不一定要用：

只有一个具体类型。
业务非常简单，不存在“多种实现”。
为了用接口而用接口，反而会让代码更绕。

常见错误

以为 Go 需要显式声明实现接口，实际只看方法集合是否匹配。
把 Dog{Name: "dog"} 误认为函数调用，实际它是创建 Dog 结构体值。
方法名、参数或返回值有一点不同，就不能满足接口。
把接口当成“任意类型容器”使用，忽略接口本质是行为约束。

9.2 类型断言

Sat, 11 Apr 2026 09:30:00 +0800

类型断言

先解决一个常见疑问

很多初学者看到下面这种函数时，会先卡在这里：

1
2


func printLength(value any) {
}

这行代码可以拆开理解：

printLength 是函数名。
value 是参数名，也就是调用函数时传进来的变量名。
any 是参数类型，不是你自己定义的变量。
any 是 Go 内置的类型别名，它等价于 interface{}。
any 的意思是“这里可以接收任意类型的值”。

也就是说，下面这些调用都是允许的：

1
2
3


printLength("golang")
printLength(100)
printLength(true)

因为 string、int、bool 都可以赋值给 any。

但问题也来了：
函数虽然能接收任意类型，可程序运行时到底传进来的是 string，还是 int，还是 bool？
如果你想把它当成某个具体类型来使用，就需要类型断言。

概念说明

类型断言用于从接口值中取出它实际保存的具体类型。

你可以先这样理解：

接口类型负责“统一接收”。
具体类型负责“真正干活”。
类型断言负责“把里面真实的类型拿出来确认一下”。

比如：

1

var value any = "golang"

从变量声明看，value 的类型是 any。
但它里面实际保存的值，是一个 string。

这时如果你写：

1

text, ok := value.(string)

它的意思就是：
“请检查一下 value 里面装的是不是 string，如果是，就把它取出来给我。”

为什么需要类型断言

接口的好处是可以统一处理很多不同类型。
但统一之后，有些操作只有具体类型才能做。

例如：

只有 string 才适合计算字符串长度。
只有 int 才能直接参与某些整数运算。
只有某个具体结构体，才能访问它自己的字段。

所以，类型断言的作用不是“多此一举”，而是：

先用接口把不同类型统一接进来。
再在真正需要的时候，安全地拿回具体类型。

语法/规则

基础写法是 value := x.(T)，如果断言失败，程序会 panic。
安全写法是 value, ok := x.(T)，更推荐使用。
类型断言只能用于接口值，比如 any、interface{} 或其他接口类型。
ok 的值是布尔值，true 表示断言成功，false 表示断言失败。
如果要判断很多种类型，通常使用 type switch 会更清晰。

类型断言示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import "fmt"

func printLength(value any) { // value 是参数名；any 表示这个参数可以接收任意类型
 text, ok := value.(string) // 尝试把 value 断言成 string
 if !ok { // 如果 value 里面装的不是 string，断言就失败
 fmt.Println("not string")
 return
 }

 // 到这里说明断言成功了
 // text 已经是一个真正的 string，可以安全地计算长度
 fmt.Println(len(text))
}

func main() {
 printLength("golang") // 传入 string，断言成功
 printLength(100) // 传入 int，断言失败
}

输出结果：

1
2


6
not string

怎么理解这个示例

printLength(value any) 的意思是：这个函数接收一个名叫 value 的参数，它的类型是 any。
any 是 Go 内置的类型别名，等价于 interface{}，不需要你自己定义。
text, ok := value.(string) 的意思是：尝试判断 value 里面保存的是不是 string。
第一次调用 printLength("golang") 时，value 里面确实是字符串，所以断言成功，text 得到 "golang"，输出 6。
第二次调用 printLength(100) 时，value 里面其实是 int，不是 string，所以 ok 是 false，输出 not string。
这里之所以能安全运行，是因为我们用了 ok 来接收断言结果。

如果这里写成下面这样：

1

text := value.(string)

那么当你传入 100 时，程序会直接 panic，因为它不是字符串。

使用断言的场景

一个很常见的场景是：

你先用接口统一处理不同类型。
但在某一步里，你又需要某个具体类型的字段或能力。
这时就要用类型断言把具体类型取出来。

下面这个例子接着上一节接口的内容来看会更直观。

场景示例：接口统一接收，但只对 Dog 做额外处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


package main

import "fmt"

type Speaker interface {
 Speak() string
}

type Dog struct {
 Name string
}

func (dog Dog) Speak() string {
 return dog.Name + ": wang"
}

type Cat struct {
 Name string
}

func (cat Cat) Speak() string {
 return cat.Name + ": miao"
}

func printDogName(speaker Speaker) {
 // 不管传进来的是 Dog 还是 Cat，都可以先当作 Speaker 使用
 fmt.Println("speak:", speaker.Speak())

 // 但如果我们想拿到 Dog 的具体字段 Name
 // 就必须先断言它里面实际装的是不是 Dog
 dog, ok := speaker.(Dog)
 if !ok {
 fmt.Println("this is not a Dog")
 return
 }

 fmt.Println("dog name:", dog.Name)
}

func main() {
 printDogName(Dog{Name: "buddy"})
 printDogName(Cat{Name: "kitty"})
}

输出结果：

1
2
3
4


speak: buddy: wang
dog name: buddy
speak: kitty: miao
this is not a Dog

这个场景说明了什么

speaker Speaker 让函数可以统一接收 Dog 和 Cat。
通过接口，我们可以直接调用共同的方法 Speak()。
但接口里没有 Name 这个字段，所以不能直接写 speaker.Name。
如果我们确定某些情况下需要拿到 Dog 这个具体类型，就可以写 speaker.(Dog) 来断言。
这就是类型断言最典型的用途之一：接口先统一，断言再细分。

type switch 示例

当你不是只判断一种类型，而是要判断很多种类型时，用 type switch 会更方便。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func printValue(value any) {
 switch v := value.(type) { // 根据 value 里面真实保存的类型，进入不同分支
 case string:
 fmt.Println("string:", v)
 case int:
 fmt.Println("int:", v)
 case bool:
 fmt.Println("bool:", v)
 default:
 fmt.Println("unknown")
 }
}

func main() {
 printValue("go")
 printValue(18)
 printValue(true)
 printValue(3.14)
}

输出结果：

1
2
3
4


string: go
int: 18
bool: true
unknown

怎么理解 type switch

switch v := value.(type) 会自动判断 value 里面到底是什么类型。
如果是 string，就进入 case string。
如果是 int，就进入 case int。
如果是 bool，就进入 case bool。
如果前面都不匹配，就进入 default。

所以：

当你只关心一种具体类型时，常用 value, ok := x.(T)。
当你要处理很多种可能类型时，常用 type switch。

常见错误

把类型断言和类型转换混为一谈。int(3.14) 是类型转换，value.(int) 是类型断言，它们不是一回事。
使用 value := x.(T) 却没有处理失败情况，导致程序 panic。
对非接口类型使用类型断言，编译无法通过。
在接口方法已经足够表达行为时，仍频繁断言具体类型，说明接口设计可能需要调整。

9.3 空接口

Sat, 11 Apr 2026 09:30:00 +0800

空接口

概念说明

空接口写作 interface{}，它没有声明任何方法。
因为所有类型都至少实现了“零个方法”，所以任意类型都满足空接口。

Go 1.18 之后可以使用 any 表示 interface{}。
any 更短，也更能表达“任意类型”的含义。

语法/规则

interface{} 可以接收任意类型的值。
any 是 interface{} 的类型别名。
从空接口中取具体值时，通常需要类型断言或 type switch。
空接口会削弱类型约束，能不用就不要滥用。
常见场景是日志、序列化、通用容器、泛型出现前的通用函数。

空接口接收任意值示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

func printAny(value any) {
 switch v := value.(type) { // 根据实际类型进入不同分支
 case string:
 fmt.Println("string:", v)
 case int:
 fmt.Println("int:", v)
 case bool:
 fmt.Println("bool:", v)
 default:
 fmt.Println("other")
 }
}

func main() {
 printAny("go")
 printAny(21)
 printAny(true)
}

输出结果：

1
2
3


string: go
int: 21
bool: true

常见错误

把 any 当成“不需要类型”的意思，实际运行时仍然要面对具体类型。
大量使用空接口让函数签名失去约束，调用方不容易知道应该传什么。
忘记断言失败的情况，导致处理空接口时发生 panic。

9.4 练习

Sun, 12 Apr 2026 13:00:00 +0800

练习

学完本章你应该掌握

能围绕“行为”定义接口，并让结构体、自定义类型等不同值通过方法集隐式实现接口。
能把接口和切片、map、函数、循环、输入输出结合起来，写出统一调用多种实现的代码。
能区分“接口用于约束行为”和“any 用于临时接收任意值”这两类场景，而不是混着使用。
能在需要时通过类型断言和 type switch 安全拿回具体类型，并继续访问字段或做更细分的处理。
能识别并修正常见接口错误，例如方法签名不匹配、指针接收者导致接口赋值失败、断言失败未处理。
能把 01-08 单元的结构体、方法、切片、map、判断、循环、函数、高阶函数、自定义类型等知识自然接到接口题目里。

一般

第 1 题：统一调用多个会说话的角色

第 1 题一般

编写一个 Go 程序，完成下面要求：

定义接口 Speaker，要求实现 Speak() string
定义结构体 Student 和 Robot
Student.Speak() 返回：学生小李：我在学接口
Robot.Speak() 返回：机器人R1：ready
再编写函数 sayAll(list []Speaker)，统一输出切片里每个值的说话内容
在 main 中构造一个 []Speaker 并调用 sayAll

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import "fmt"

type Speaker interface {
 Speak() string
}

type Student struct {
 Name string
}

func (s Student) Speak() string {
 return fmt.Sprintf("学生%s：我在学接口", s.Name)
}

type Robot struct {
 ID string
}

func (r Robot) Speak() string {
 return fmt.Sprintf("机器人%s：ready", r.ID)
}

func sayAll(list []Speaker) {
 for _, item := range list {
 fmt.Println(item.Speak())
 }
}

func main() {
 list := []Speaker{
 Student{Name: "小李"},
 Robot{ID: "R1"},
 }

 sayAll(list)
}

说明：这道题的重点不是“定义两个结构体”，而是体会 sayAll 为什么可以只接收 []Speaker，却同时处理不同具体类型。

第 2 题：用接口统一计算付款金额

第 2 题一般

编写一个 Go 程序，完成下面要求：

定义接口 Payable，要求实现 Pay() int
定义结构体 CourseOrder，字段有 Title string、Price int
定义结构体 BookOrder，字段有 Title string、Price int、Discount int
CourseOrder.Pay() 返回课程价格
BookOrder.Pay() 返回 Price - Discount
再编写函数 calcTotal(items []Payable) int，统计总付款金额
在 main 中放入下面两笔订单：

1
2


CourseOrder{Title: "Go 接口课", Price: 128}
BookOrder{Title: "Go 练习册", Price: 99, Discount: 20}

最后输出 total=207

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


package main

import "fmt"

type Payable interface {
 Pay() int
}

type CourseOrder struct {
 Title string
 Price int
}

func (c CourseOrder) Pay() int {
 return c.Price
}

type BookOrder struct {
 Title string
 Price int
 Discount int
}

func (b BookOrder) Pay() int {
 return b.Price - b.Discount
}

func calcTotal(items []Payable) int {
 total := 0
 for _, item := range items {
 total += item.Pay()
 }
 return total
}

func main() {
 items := []Payable{
 CourseOrder{Title: "Go 接口课", Price: 128},
 BookOrder{Title: "Go 练习册", Price: 99, Discount: 20},
 }

 fmt.Printf("total=%d\n", calcTotal(items))
}

说明：这道题把接口和切片、循环、函数结合起来了。调用方只关心“这项内容能不能算出应付金额”，不关心它到底是课程订单还是图书订单。

第 3 题：按问候风格查询接口实现

第 3 题一般

编写一个 Go 程序，完成下面要求：

定义接口 Greeter，要求实现 Greet(name string) string
定义 ChineseGreeter 和 EnglishGreeter
ChineseGreeter.Greet("小王") 返回 你好，小王
EnglishGreeter.Greet("Tom") 返回 Hello, Tom
使用 map[string]Greeter 保存两种问候方式： cn 对应中文问候 en 对应英文问候
读取两个输入：问候方式和姓名
如果存在该问候方式，就输出结果
如果不存在，输出 不支持这种问候方式

例如输入：

1

cn 小王

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import "fmt"

type Greeter interface {
 Greet(name string) string
}

type ChineseGreeter struct{}

func (ChineseGreeter) Greet(name string) string {
 return "你好，" + name
}

type EnglishGreeter struct{}

func (EnglishGreeter) Greet(name string) string {
 return "Hello, " + name
}

func main() {
 styles := map[string]Greeter{
 "cn": ChineseGreeter{},
 "en": EnglishGreeter{},
 }

 var style string
 var name string

 fmt.Print("请输入问候方式和姓名：")
 fmt.Scan(&style, &name)

 if greeter, ok := styles[style]; ok {
 fmt.Println(greeter.Greet(name))
 } else {
 fmt.Println("不支持这种问候方式")
 }
}

说明：这里的 map[string]Greeter 很关键。它把“键查找”与“接口统一调用”接在了一起，是很常见的基础设计方式。

第 4 题：修正指针接收者导致的接口赋值问题

第 4 题一般

下面程序的目标是输出：

1
2


go_new
go_new

但它现在不能通过编译。请改正代码，让它正常运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import "fmt"

type Updater interface {
 Update() string
}

type Profile struct {
 Name string
}

func (p *Profile) Update() string {
 p.Name = p.Name + "_new"
 return p.Name
}

func main() {
 p := Profile{Name: "go"}
 var u Updater = p

 fmt.Println(u.Update())
 fmt.Println(p.Name)
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import "fmt"

type Updater interface {
 Update() string
}

type Profile struct {
 Name string
}

func (p *Profile) Update() string {
 p.Name = p.Name + "_new"
 return p.Name
}

func main() {
 p := Profile{Name: "go"}
 var u Updater = &p

 fmt.Println(u.Update())
 fmt.Println(p.Name)
}

原因说明：

Update 是定义在 *Profile 上的方法，不是定义在 Profile 值上的方法。
所以满足 Updater 接口的是 *Profile，不是 Profile。
这里把 p 改成 &p 后，接口里保存的就是结构体地址，修改会同步反映到外部变量。

第 5 题：实现一个 `any` 通用说明器

第 5 题一般

编写一个函数 describe(value any)，完成下面要求：

如果传入的是 string，输出：string chars=字符数
如果传入的是 int，输出：int square=平方值
如果传入的是 Student，输出：student 姓名分数
其他类型输出：unknown

要求：

自己定义结构体 Student
在 main 中至少测试下面四个值： "接口" 12 Student{Name: "小李", Score: 88} true

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import "fmt"

type Student struct {
 Name string
 Score int
}

func describe(value any) {
 switch v := value.(type) {
 case string:
 fmt.Printf("string chars=%d\n", len([]rune(v)))
 case int:
 fmt.Printf("int square=%d\n", v*v)
 case Student:
 fmt.Printf("student %s %d\n", v.Name, v.Score)
 default:
 fmt.Println("unknown")
 }
}

func main() {
 describe("接口")
 describe(12)
 describe(Student{Name: "小李", Score: 88})
 describe(true)
}

说明：

any 等价于 interface{}，适合临时接收任意类型的值。
这里用 type switch 做分流；字符串长度使用 len([]rune(v))，这样中文按字符数统计更直观。

第 6 题：从混合切片中提取实现了接口的值

第 6 题一般

编写一个 Go 程序，完成下面要求：

定义接口 Speaker，要求实现 Speak() string
定义结构体 Dog 和 Cat，都实现 Speak() string
编写函数 collectSpeeches(items []any) []string
这个函数遍历混合切片，只把实现了 Speaker 的值取出来，并收集它们的说话内容
在 main 中准备下面这组数据：

1
2
3
4
5
6
7


items := []any{
 1,
 "go",
 Dog{Name: "旺财"},
 true,
 Cat{Name: "咪咪"},
}

最后逐行输出收集到的内容

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


package main

import "fmt"

type Speaker interface {
 Speak() string
}

type Dog struct {
 Name string
}

func (d Dog) Speak() string {
 return d.Name + ": wang"
}

type Cat struct {
 Name string
}

func (c Cat) Speak() string {
 return c.Name + ": miao"
}

func collectSpeeches(items []any) []string {
 result := []string{}

 for _, item := range items {
 speaker, ok := item.(Speaker)
 if !ok {
 continue
 }
 result = append(result, speaker.Speak())
 }

 return result
}

func main() {
 items := []any{
 1,
 "go",
 Dog{Name: "旺财"},
 true,
 Cat{Name: "咪咪"},
 }

 for _, text := range collectSpeeches(items) {
 fmt.Println(text)
 }
}

说明：这道题体现了“先用 any 容纳混合数据，再通过类型断言挑出满足某个接口的值”这条常见处理路线。

进阶

下面 6 题会把接口和自定义类型、结构体指针、切片、map、函数、高阶函数、循环菜单一起用起来，更接近真实的程序组织方式。

第 7 题：让自定义类型也实现接口

第 7 题进阶

编写一个 Go 程序，完成下面要求：

定义接口 Textable，要求实现 Text() string
定义自定义类型 OrderStatus，底层类型是 int
定义自定义类型 TaskStatus，底层类型是 int
给这两个自定义类型都绑定 Text() string 方法
准备一个 []Textable
让它同时保存订单状态和任务状态
最后统一输出每一项的文字描述

提示：这道题的重点是体会“接口并不只给结构体用，自定义类型同样可以实现接口”。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


package main

import "fmt"

type Textable interface {
 Text() string
}

type OrderStatus int
type TaskStatus int

const (
 OrderPending OrderStatus = 1
 OrderPaid OrderStatus = 2
)

const (
 TaskTodo TaskStatus = 1
 TaskDone TaskStatus = 2
)

func (s OrderStatus) Text() string {
 switch s {
 case OrderPending:
 return "订单待支付"
 case OrderPaid:
 return "订单已支付"
 default:
 return "未知订单状态"
 }
}

func (s TaskStatus) Text() string {
 switch s {
 case TaskTodo:
 return "任务待开始"
 case TaskDone:
 return "任务已完成"
 default:
 return "未知任务状态"
 }
}

func main() {
 items := []Textable{
 OrderPaid,
 TaskTodo,
 OrderPending,
 TaskDone,
 }

 for _, item := range items {
 fmt.Println(item.Text())
 }
}

说明：这里真正实现接口的不是结构体，而是两个自定义类型。只要方法匹配，接口并不关心底层到底是什么。

第 8 题：用接口统一处理不同学习资源

第 8 题进阶

编写一个 Go 程序，完成下面要求：

定义接口 Resource，要求实现两个方法： Title() string StudyMinutes() int
定义结构体 Article，字段有： Name string WordCount int
定义结构体 Video，字段有： Name string Duration int
约定文章阅读时间按“每 200 字算 1 分钟，向上取整”计算
编写函数 calcPlan(resources []Resource) int，统计总学习时间
在 main 中准备下面这组资源：

1
2
3


Article{Name: "接口入门", WordCount: 850}
Video{Name: "类型断言实战", Duration: 12}
Article{Name: "空接口复盘", WordCount: 400}

先逐行输出每个资源的标题和学习时间
再输出总学习时间

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


package main

import "fmt"

type Resource interface {
 Title() string
 StudyMinutes() int
}

type Article struct {
 Name string
 WordCount int
}

func (a Article) Title() string {
 return a.Name
}

func (a Article) StudyMinutes() int {
 if a.WordCount%200 == 0 {
 return a.WordCount / 200
 }
 return a.WordCount/200 + 1
}

type Video struct {
 Name string
 Duration int
}

func (v Video) Title() string {
 return v.Name
}

func (v Video) StudyMinutes() int {
 return v.Duration
}

func calcPlan(resources []Resource) int {
 total := 0
 for _, item := range resources {
 total += item.StudyMinutes()
 }
 return total
}

func main() {
 resources := []Resource{
 Article{Name: "接口入门", WordCount: 850},
 Video{Name: "类型断言实战", Duration: 12},
 Article{Name: "空接口复盘", WordCount: 400},
 }

 for _, item := range resources {
 fmt.Printf("%s -> %d分钟\n", item.Title(), item.StudyMinutes())
 }

 fmt.Printf("total=%d\n", calcPlan(resources))
}

说明：这道题把结构体、方法、接口、切片、循环和判断连起来了。文章和视频字段不同，但对外都能回答“标题是什么”“要学多久”。

第 9 题：用指针接收者和接口批量给学生加分

第 9 题进阶

编写一个 Go 程序，完成下面要求：

定义接口 BonusAdder，要求实现： AddBonus(points int) Summary() string
定义结构体 Student，字段有： Name string Score int
让 Student 用指针接收者实现这两个方法
准备下面这组学生数据：

1
2
3
4
5


students := []Student{
 {Name: "小李", Score: 58},
 {Name: "小王", Score: 76},
 {Name: "小张", Score: 59},
}

只把分数小于 60 的学生放进 []BonusAdder
统一给这些学生加 5 分
最后按原切片顺序输出所有学生的最终成绩

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


package main

import "fmt"

type BonusAdder interface {
 AddBonus(points int)
 Summary() string
}

type Student struct {
 Name string
 Score int
}

func (s *Student) AddBonus(points int) {
 s.Score += points
}

func (s *Student) Summary() string {
 return fmt.Sprintf("%s: %d", s.Name, s.Score)
}

func applyBonus(list []BonusAdder, points int) {
 for _, item := range list {
 item.AddBonus(points)
 }
}

func main() {
 students := []Student{
 {Name: "小李", Score: 58},
 {Name: "小王", Score: 76},
 {Name: "小张", Score: 59},
 }

 targets := make([]BonusAdder, 0)
 for i := range students {
 if students[i].Score < 60 {
 targets = append(targets, &students[i])
 }
 }

 applyBonus(targets, 5)

 for _, student := range students {
 fmt.Printf("%s: %d\n", student.Name, student.Score)
 }
}

说明：

这里一定要把 &students[i] 放进接口切片，否则改到的就只是副本。
这道题把“指针接收者能修改原值”和“接口可以统一批量操作”真正组合到了一起。

第 10 题：统计接口切片中每种具体类型的数量

第 10 题进阶

编写一个 Go 程序，完成下面要求：

定义接口 Speaker
定义结构体 Dog、Cat、Robot
三者都实现 Speak() string
准备下面这个接口切片：

1
2
3
4
5
6


list := []Speaker{
 Dog{Name: "旺财"},
 Cat{Name: "咪咪"},
 Dog{Name: "大黄"},
 Robot{ID: "R1"},
}

编写函数 countKinds(list []Speaker) map[string]int
使用 type switch 统计每种具体类型的数量
最后按下面顺序输出：

1
2
3


Dog: 2
Cat: 1
Robot: 1

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


package main

import "fmt"

type Speaker interface {
 Speak() string
}

type Dog struct {
 Name string
}

func (d Dog) Speak() string {
 return d.Name + ": wang"
}

type Cat struct {
 Name string
}

func (c Cat) Speak() string {
 return c.Name + ": miao"
}

type Robot struct {
 ID string
}

func (r Robot) Speak() string {
 return r.ID + ": ready"
}

func countKinds(list []Speaker) map[string]int {
 counts := make(map[string]int)

 for _, item := range list {
 switch item.(type) {
 case Dog:
 counts["Dog"]++
 case Cat:
 counts["Cat"]++
 case Robot:
 counts["Robot"]++
 }
 }

 return counts
}

func main() {
 list := []Speaker{
 Dog{Name: "旺财"},
 Cat{Name: "咪咪"},
 Dog{Name: "大黄"},
 Robot{ID: "R1"},
 }

 counts := countKinds(list)
 order := []string{"Dog", "Cat", "Robot"}
 for _, name := range order {
 fmt.Printf("%s: %d\n", name, counts[name])
 }
}

说明：这道题先把不同类型统一放进接口切片，再用 type switch 做“二次细分”，很适合理解接口和具体类型的关系。

第 11 题：用高阶函数筛选接口值

第 11 题进阶

编写一个 Go 程序，完成下面要求：

定义接口 Speaker
定义结构体 Student 和 Robot，都实现 Speak() string
编写函数 filterSpeakers(list []Speaker, checker func(string) bool) []Speaker
它的作用是：只保留 Speak() 返回值满足条件的对象
再编写闭包工厂函数 makeKeywordChecker(keyword string) func(string) bool
它返回的新函数用于判断一段文本里是否包含指定关键字
在 main 中准备下面这组数据：

1
2
3
4
5


list := []Speaker{
 Student{Name: "小李", Message: "我在学接口"},
 Robot{ID: "R1", Message: "ready"},
 Student{Name: "小王", Message: "接口真的重要"},
}

使用关键字 接口 进行筛选
最后输出筛选后的说话内容

提示：可以使用 strings.Contains

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


package main

import (
 "fmt"
 "strings"
)

type Speaker interface {
 Speak() string
}

type Student struct {
 Name string
 Message string
}

func (s Student) Speak() string {
 return s.Name + "：" + s.Message
}

type Robot struct {
 ID string
 Message string
}

func (r Robot) Speak() string {
 return r.ID + "：" + r.Message
}

func filterSpeakers(list []Speaker, checker func(string) bool) []Speaker {
 result := []Speaker{}

 for _, item := range list {
 if checker(item.Speak()) {
 result = append(result, item)
 }
 }

 return result
}

func makeKeywordChecker(keyword string) func(string) bool {
 return func(text string) bool {
 return strings.Contains(text, keyword)
 }
}

func main() {
 list := []Speaker{
 Student{Name: "小李", Message: "我在学接口"},
 Robot{ID: "R1", Message: "ready"},
 Student{Name: "小王", Message: "接口真的重要"},
 }

 checker := makeKeywordChecker("接口")
 filtered := filterSpeakers(list, checker)

 for _, item := range filtered {
 fmt.Println(item.Speak())
 }
}

说明：

filterSpeakers 体现了“函数作为参数”的高阶函数用法。
makeKeywordChecker 体现了闭包，它会记住外层传进来的 keyword。
strings.Contains 用来判断字符串中是否包含某段子串。

第 12 题：实现一个多渠道提醒中心

第 12 题进阶

请完成一个稍微完整一点的小场景：

定义接口 Notifier，要求实现 Send(user, message string) string
定义三种实现： EmailNotifier SMSNotifier AppNotifier
使用 map[int]Notifier 保存这三种通知渠道： 1 表示邮件 2 表示短信 3 表示 App
使用 for {} 做循环菜单
每轮读取一个选项： 1、2、3 表示发送通知 0 表示退出程序
如果输入合法，就给用户 小李 发送消息 今晚完成接口练习
如果输入其他值，输出 无效选项

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


package main

import "fmt"

type Notifier interface {
 Send(user, message string) string
}

type EmailNotifier struct {
 Address string
}

func (e EmailNotifier) Send(user, message string) string {
 return fmt.Sprintf("邮件[%s] -> %s：%s", e.Address, user, message)
}

type SMSNotifier struct {
 Sign string
}

func (s SMSNotifier) Send(user, message string) string {
 return fmt.Sprintf("短信[%s] -> %s：%s", s.Sign, user, message)
}

type AppNotifier struct {
 AppName string
}

func (a AppNotifier) Send(user, message string) string {
 return fmt.Sprintf("App[%s] -> %s：%s", a.AppName, user, message)
}

func main() {
 channels := map[int]Notifier{
 1: EmailNotifier{Address: "study@example.com"},
 2: SMSNotifier{Sign: "Go课代表"},
 3: AppNotifier{AppName: "GoStudy"},
 }

 for {
 var choice int

 fmt.Print("请输入选项（1邮件 2短信 3App 0退出）：")
 fmt.Scan(&choice)

 if choice == 0 {
 fmt.Println("退出程序")
 return
 }

 if notifier, ok := channels[choice]; ok {
 fmt.Println(notifier.Send("小李", "今晚完成接口练习"))
 } else {
 fmt.Println("无效选项")
 }
 }
}

说明：这道题把接口、结构体、map、输入、循环和条件分流全都串起来了。以后你再增加一种通知方式时，通常只需要新增一个实现，而不用重写整套菜单逻辑。

10.1 协程

Sat, 11 Apr 2026 09:30:00 +0800

协程

概念说明

Go 中的协程通常指 goroutine。
使用 go 关键字可以让一个函数并发执行。

初学时可以先把 goroutine 理解成“一个可以和当前代码同时推进的轻量任务”。
它和操作系统线程不是完全一样的概念，但在学习并发时，你可以先抓住重点：
goroutine 启动后，不会堵住当前代码继续往下走。

需要特别注意：
如果 main 函数结束，整个程序会退出，未执行完的 goroutine 也会一起结束。

语法/规则

使用 go 函数调用 启动一个 goroutine。
goroutine 的执行顺序由调度器决定，不要依赖固定顺序。
main 函数不会自动等待其他 goroutine。
需要等待任务结束时，应使用 sync.WaitGroup、channel 或其他同步方式。
多个 goroutine 共享变量时，要考虑线程安全问题。

语法模板

1

go 函数名(参数列表)

启动 goroutine 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
 "fmt"
 "time"
)

func printTask(name string) {
 for i := 1; i <= 3; i++ { // 每个任务打印 3 次
 fmt.Println(name, i)
 }
}

func main() {
 go printTask("goroutine") // 启动一个新的 goroutine 去执行 printTask("goroutine")
 printTask("main") // 主 goroutine 不会等待上一行执行完，而是立刻继续执行这里

 time.Sleep(100 * time.Millisecond) // 临时等一小会儿，避免 main 过早结束
}

输出结果（顺序可能不同）：

1
2
3
4
5
6


main 1
goroutine 1
main 2
goroutine 2
main 3
goroutine 3

也可能是：

1
2
3
4
5
6


main 1
main 2
main 3
goroutine 1
goroutine 2
goroutine 3

注意这个细节

go printTask("goroutine") 不是先把这个函数执行完再往下走。
它只是启动一个新的 goroutine，主 goroutine 会立刻继续执行 printTask("main")，所以两边可能同时推进。

从运行结果就能看出来，它们不是固定顺序执行：

1
2
3
4
5
6


main 1
goroutine 1
main 2
goroutine 2
main 3
goroutine 3

也可能是：

1
2
3
4
5
6


main 1
main 2
main 3
goroutine 1
goroutine 2
goroutine 3

常见错误

启动 goroutine 后立即让 main 结束，导致后台任务还没来得及执行。
依赖并发输出的固定顺序，实际不同机器或不同运行次数可能不一样。
多个 goroutine 同时修改同一个变量却不加同步保护，容易产生数据竞争。

10.2 WaitGroup

Sat, 11 Apr 2026 09:30:00 +0800

WaitGroup

概念说明

sync.WaitGroup 用于等待一组 goroutine 完成。
它内部维护一个计数器：任务开始前增加计数，任务结束后减少计数，主流程等待计数归零。

语法/规则

Add(n) 表示增加 n 个待完成任务。
Done() 表示一个任务完成，通常配合 defer 使用。
Wait() 会阻塞，直到计数器归零。
Add 通常要在启动 goroutine 之前调用。
Add 和 Done 次数必须匹配，否则可能死锁或 panic。

等待多个任务示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "fmt"
 "sync"
)

func main() {
 var wg sync.WaitGroup // 声明一个 WaitGroup 变量，变量名 wg 是 WaitGroup 的常见缩写写法

 for i := 1; i <= 3; i++ {
 wg.Add(1) // 每准备启动一个 goroutine，就先把计数器加 1
 go func(id int) {
 defer wg.Done() // 当前 goroutine 执行结束前，把计数器减 1
 fmt.Println("task", id)
 }(i) // 把当前循环里的 i 作为参数传进去，避免多个 goroutine 读到同一个 i
 }

 wg.Wait() // 阻塞等待，直到前面 3 个 goroutine 都调用 Done
 fmt.Println("done")
}

输出结果（任务顺序可能不同）：

1
2
3
4


task 1
task 2
task 3
done

怎么理解这个示例

这段代码的核心流程是：先登记 3 个任务，再并发执行它们，最后统一等待它们全部结束。
done 一定会在所有 task 输出之后出现，因为主 goroutine 会卡在 wg.Wait()，不会提前往下执行。
task 1、task 2、task 3 的先后顺序不固定，因为 goroutine 的调度顺序不是手动控制的。

场景示例：并发下载多个文件后，再进入下一步

假设程序要同时下载 3 个文件。
下载可以并发进行，但“开始打包”这一步必须等 3 个文件都下载完成后才能继续。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import (
 "fmt"
 "sync"
 "time"
)

func downloadFile(fileName string, wg *sync.WaitGroup) { // 接收 WaitGroup 指针，表示操作的是同一个计数器
 defer wg.Done() // 当前文件下载完成后，把计数器减 1

 time.Sleep(100 * time.Millisecond) // 模拟下载耗时
 fmt.Println(fileName, "downloaded")
}

func main() {
 files := []string{"a.jpg", "b.jpg", "c.jpg"}

 var wg sync.WaitGroup

 for _, fileName := range files {
 wg.Add(1) // 每启动一个下载任务，就先登记 1 个待完成任务
 go downloadFile(fileName, &wg) // 把同一个 WaitGroup 传给每个 goroutine
 }

 wg.Wait() // 等全部文件下载完成后，再继续往下执行
 fmt.Println("start package")
}

输出结果（顺序可能不同）：

1
2
3
4


b.jpg downloaded
a.jpg downloaded
c.jpg downloaded
start package

WaitGroup 在这里起到什么作用

3 个文件可以同时下载，所以前面的下载任务适合用 goroutine 并发执行。
但 start package 不能太早执行，否则可能还有文件没下载完。
WaitGroup 的作用就是：让主 goroutine 等所有下载任务都完成后，再继续下一步。
它的独特点是只负责“等全部做完”，不负责传递结果，也不负责控制执行顺序。

常见错误

在 goroutine 内部调用 Add，主流程可能先执行到 Wait，造成时序问题。
忘记调用 Done，导致 Wait 一直阻塞。
Done 调用次数多于 Add，会导致计数器变成负数并触发 panic。
循环启动 goroutine 时没有把循环变量作为参数传进去，容易读到意外值。

10.3 channel

Sat, 11 Apr 2026 09:30:00 +0800

channel

概念说明

channel 是 goroutine 之间传递数据的管道。
它既能传值，也能同步执行时机。

默认创建的是无缓冲 channel。
无缓冲 channel 的特点是：发送和接收必须同时准备好，否则其中一方就会等待。

语法/规则

使用 make(chan T) 创建 channel。
使用 ch <- value 向 channel 发送数据。
使用 value := <-ch 从 channel 接收数据。
发送方可以使用 close(ch) 关闭 channel，表示后面不会再发送数据。
使用 for value := range ch 可以持续读取，直到 channel 被关闭。
不要向已经关闭的 channel 发送数据，会触发 panic。

语法模板

1
2
3
4
5
6
7


ch := make(chan int)

go func() {
 ch <- 1
}()

value := <-ch

channel 传递数据示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 numbers := make(chan int) // 创建一个 int 类型的 channel，用来传递数字

 go func() {
 for i := 1; i <= 3; i++ {
 numbers <- i // 把 i 发送到 channel 中
 }
 close(numbers) // 发送完成后关闭 channel，告诉接收方“后面没有数据了”
 }()

 for number := range numbers { // 持续接收数据，直到 numbers 被关闭
 fmt.Println(number)
 }
}

输出结果：

怎么理解这个示例

一个 goroutine 发送数据，主 goroutine 负责接收并打印。
for number := range numbers 会一直读，直到 numbers 被关闭。
所以这个例子既展示了“怎么传值”，也展示了“怎么通知接收方数据发完了”。

什么时候会用到 channel

当多个 goroutine 之间需要传数据或配合同步时，就会用到 channel。
下面两个示例分别演示了“连续发送一组数据”和“把计算结果交回主 goroutine”这两种常见用法。

场景：后台计算结果后，把结果交给主 goroutine

goroutine 不能像普通函数那样直接把返回值交回调用位置。
这时可以让后台 goroutine 通过 channel 把结果送回来：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func sum(a int, b int, resultCh chan int) {
 result := a + b
 resultCh <- result // 计算完成后，把结果发送给 channel
}

func main() {
 resultCh := make(chan int) // 创建一个 channel，用来接收结果

 go sum(10, 20, resultCh) // 启动 goroutine 进行计算

 result := <-resultCh // 等待接收结果；结果没来之前，这里会阻塞
 fmt.Println("result:", result)
}

输出结果：

1

result: 30

这个场景说明了什么

go sum(10, 20, resultCh) 在后台计算结果。
result := <-resultCh 会等待结果到来，而不是靠 time.Sleep 猜时间。
这就是 channel 的常见用法：一个 goroutine 算，一个 goroutine 收。

常见错误

只有发送没有接收，或只有接收没有发送，导致程序死锁。
接收方关闭 channel，容易让发送方继续发送时 panic；通常由发送方关闭。
误以为关闭 channel 是必须的，实际只有接收方需要判断结束时才需要关闭。
向已经关闭的 channel 发送数据，会触发 send on closed channel。

10.4 select

Sat, 11 Apr 2026 09:30:00 +0800

select

概念说明

select 用于同时等待多个 channel 操作。
哪个 case 的 channel 先准备好，就执行哪个分支。

如果多个分支同时可执行，Go 会随机选择一个。
因此不要把业务逻辑建立在固定选择顺序上。

语法/规则

select 的每个 case 通常对应一次 channel 发送或接收。
如果没有任何 channel 准备好，select 会阻塞。
可以使用 default 分支避免阻塞。
可以配合 time.After 实现超时控制。
多个分支同时就绪时，执行哪个分支是不固定的。

select 同时等待多个消息示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import (
 "fmt"
 "time"
)

func main() {
 fast := make(chan string)
 slow := make(chan string)

 go func() {
 time.Sleep(50 * time.Millisecond)
 fast <- "fast channel"
 }()

 go func() {
 time.Sleep(100 * time.Millisecond)
 slow <- "slow channel"
 }()

 for i := 0; i < 2; i++ { // 一共接收两次消息
 select {
 case msg := <-fast:
 fmt.Println("receive:", msg) // fast 先准备好时，先进入这个分支
 case msg := <-slow:
 fmt.Println("receive:", msg) // slow 准备好时，进入这个分支
 }
 }
}

输出结果：

1
2


receive: fast channel
receive: slow channel

这个示例体现了什么

select 会同时等待 fast 和 slow 两个 channel。
哪个 channel 先准备好，就先执行哪个 case。
第一次进入 select 时，fast 更早发送数据，所以先输出 fast channel。
第二次进入 select 时，再接收 slow 里的数据。
如果多个 case 同时准备好，select 选择哪个分支是不固定的。

这段代码是怎么运行的

先看发送方：

1
2
3
4
5
6
7
8
9


go func() {
 time.Sleep(50 * time.Millisecond)
 fast <- "fast channel"
}()

go func() {
 time.Sleep(100 * time.Millisecond)
 slow <- "slow channel"
}()

可以先理解成：

1
2


50ms 后，向 fast 发送一条消息
100ms 后，向 slow 发送一条消息

再看接收方：

1
2
3
4
5
6
7
8


for i := 0; i < 2; i++ {
 select {
 case msg := <-fast:
 fmt.Println("receive:", msg)
 case msg := <-slow:
 fmt.Println("receive:", msg)
 }
}

它不是“for 一直空转检查”。
真正等待消息的是 select。

运行过程可以理解成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


第 1 次循环
-> 进入 select
-> fast 和 slow 都还没消息
-> select 阻塞等待
-> 50ms 后 fast 收到消息
-> 执行 case msg := <-fast

第 2 次循环
-> 再次进入 select
-> slow 还没消息
-> select 继续阻塞等待
-> 100ms 后 slow 收到消息
-> 执行 case msg := <-slow

所以这里：

1

for i := 0; i < 2; i++

表示“总共接收 2 次消息”。

如果你不知道要接收多少次，而是想一直等，就会写成：

1
2
3
4
5
6
7
8


for {
 select {
 case msg := <-fast:
 fmt.Println("receive:", msg)
 case msg := <-slow:
 fmt.Println("receive:", msg)
 }
}

常见错误

以为 select 会按 case 书写顺序检查，实际多个分支同时就绪时会随机选择。
没有 default 且所有 channel 都不就绪，导致程序阻塞。
在 default 分支里写空循环，可能造成 CPU 空转。
把 select 和普通 switch 混淆，select 专门用于 channel 操作。

10.5 协程超时处理

Sat, 11 Apr 2026 09:30:00 +0800

协程超时处理

概念说明

并发任务可能因为网络、IO 或业务逻辑迟迟不返回。
如果调用方一直等待，程序就容易卡住。

常见做法是让任务结果通过 channel 返回，再用 select 同时等待“结果”和“超时信号”。

语法/规则

用结果 channel 接收 goroutine 的执行结果。
用 time.After(duration) 创建超时信号。
用 select 谁先到就处理谁。
真实项目中也常用 context.WithTimeout 统一控制取消。
超时后仍要考虑后台 goroutine 是否会泄漏。

超时处理示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "time"
)

func main() {
 result := make(chan string, 1) // 带 1 个缓冲，超时后发送方也不容易被卡住

 go func() {
 time.Sleep(200 * time.Millisecond) // 模拟耗时任务，200ms 后才完成
 result <- "success" // 任务完成后，把结果发送到 result
 }()

 select { // 同时等待“任务结果”和“超时信号”
 case msg := <-result:
 fmt.Println(msg) // 如果先拿到结果，就输出结果
 case <-time.After(100 * time.Millisecond):
 fmt.Println("timeout") // 如果 100ms 先到了，就进入超时分支
 }
}

输出结果：

1

timeout

这段 `select` 是怎么运行的

先看这两个等待对象：

1
2


case msg := <-result
case <-time.After(100 * time.Millisecond)

可以先理解成：

1
2


等待 1：goroutine 什么时候把结果发到 result
等待 2：100ms 什么时候到

再看 goroutine：

1
2
3
4


go func() {
 time.Sleep(200 * time.Millisecond)
 result <- "success"
}()

它的意思是：

1

200ms 后，result 才会收到 "success"

所以时间顺序就是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


0ms:
进入 select
同时等待 result 和 time.After(100ms)

100ms:
time.After(100ms) 先到
进入 case <-time.After(100 * time.Millisecond)
输出 timeout

200ms:
goroutine 才准备把 "success" 发到 result
但前面的 select 已经结束了

所以这里进入超时分支，不是随机的。
而是因为：

1

200ms > 100ms

结果还没来，超时信号先到了，所以执行：

1
2


case <-time.After(100 * time.Millisecond):
 fmt.Println("timeout")

常见错误

只等待结果 channel，没有设置超时，导致调用方可能一直阻塞。
使用无缓冲结果 channel，超时后后台 goroutine 发送结果时可能被卡住。
认为超时分支执行后 goroutine 会自动停止，实际它仍可能继续运行。

10.6 练习

Sun, 12 Apr 2026 08:00:00 +0800

练习

学完本章你应该掌握

能使用 go 启动 goroutine，理解主 goroutine 不会自动等待其他任务，并能判断为什么并发输出顺序不固定。
能正确使用 sync.WaitGroup 的 Add、Done、Wait 协调一组任务结束，并识别计数不匹配、循环变量传递错误等常见问题。
能使用 channel 在 goroutine 之间传递数据、通知结束，并写对 close、range、发送与接收的配合关系。
能使用 select 同时等待多个 channel 事件，区分阻塞等待、default 非阻塞检查和“哪个先准备好就先处理”的行为。
能使用 time.After 为并发任务增加超时控制，并理解为什么超时场景里常配合带缓冲结果 channel。
能把 01-09 单元的函数、结构体、切片、map、自定义类型、接口、判断和循环自然放进并发题目里，而不是只会写孤立语法。

简单

第 1 题：并发启动三个学习任务并等待结束

第 1 题简单

编写一个 Go 程序，完成下面要求：

准备一个切片：

1

tasks := []string{"变量复习", "切片复习", "协程入门"}

编写函数 runTask(name string, wg *sync.WaitGroup)
这个函数输出：开始：任务名
在 main 中为每个任务启动一个 goroutine
使用 sync.WaitGroup 等待这 3 个任务都输出完成
最后输出：全部任务已启动完成

说明：前 3 行任务输出顺序不固定，只要最后一行一定出现在全部任务输出之后即可。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import (
 "fmt"
 "sync"
)

func runTask(name string, wg *sync.WaitGroup) {
 defer wg.Done()
 fmt.Println("开始：", name)
}

func main() {
 tasks := []string{"变量复习", "切片复习", "协程入门"}

 var wg sync.WaitGroup

 for _, task := range tasks {
 wg.Add(1)
 go runTask(task, &wg)
 }

 wg.Wait()
 fmt.Println("全部任务已启动完成")
}

说明：这道题的重点是体会 go 启动任务后，主 goroutine 仍会继续往下走，所以必须用 WaitGroup 明确等待。

第 2 题：用 channel 取回两个数的和

第 2 题简单

编写一个 Go 程序，完成下面要求：

编写函数 calcSum(a, b int, resultCh chan int)
这个函数把 a + b 的结果发送到 resultCh
在 main 中创建一个 chan int
使用 goroutine 调用 calcSum(12, 30, resultCh)
在主 goroutine 中接收结果，并输出：

1

sum=42

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func calcSum(a, b int, resultCh chan int) {
 resultCh <- a + b
}

func main() {
 resultCh := make(chan int)

 go calcSum(12, 30, resultCh)

 result := <-resultCh
 fmt.Printf("sum=%d\n", result)
}

说明：这里主 goroutine 不是靠 time.Sleep 猜时间，而是直接在 <-resultCh 处等待结果到来。

第 3 题：修正不会结束的 channel 遍历

第 3 题简单

下面程序的目标是输出：

但它现在会一直卡住。请改正代码，让它在输出完 1、2、3 后正常结束。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 numbers := make(chan int)

 go func() {
 for i := 1; i <= 3; i++ {
 numbers <- i
 }
 }()

 for number := range numbers {
 fmt.Println(number)
 }
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 numbers := make(chan int)

 go func() {
 for i := 1; i <= 3; i++ {
 numbers <- i
 }
 close(numbers)
 }()

 for number := range numbers {
 fmt.Println(number)
 }
}

原因说明：

for number := range numbers 会一直读取，直到 numbers 被关闭。
原程序只发送了 3 个值，但没有 close(numbers)，所以接收方不知道“数据已经发完了”，就会继续阻塞等待。
这里由发送方关闭 channel，更符合这一章的常见写法。

一般

第 4 题：并发生成学生成绩摘要

第 4 题一般

编写一个 Go 程序，完成下面要求：

定义结构体 Student，字段包括： Name string Score int
准备下面这组数据：

1
2
3
4
5


students := []Student{
 {Name: "小李", Score: 82},
 {Name: "小王", Score: 59},
 {Name: "小张", Score: 91},
}

编写函数 buildSummary(student Student) string
返回格式如下：如果分数大于等于 60，返回 小李: 82 (及格) 否则返回 小王: 59 (不及格)
为每个学生启动一个 goroutine 生成摘要，并把摘要发送到 summaryCh
使用 WaitGroup 等待所有 goroutine 完成后关闭 summaryCh
在 main 中使用 for range 读取并输出所有摘要

说明：摘要输出顺序不固定。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


package main

import (
 "fmt"
 "sync"
)

type Student struct {
 Name string
 Score int
}

func buildSummary(student Student) string {
 level := "不及格"
 if student.Score >= 60 {
 level = "及格"
 }
 return fmt.Sprintf("%s: %d (%s)", student.Name, student.Score, level)
}

func main() {
 students := []Student{
 {Name: "小李", Score: 82},
 {Name: "小王", Score: 59},
 {Name: "小张", Score: 91},
 }

 summaryCh := make(chan string)
 var wg sync.WaitGroup

 for _, student := range students {
 wg.Add(1)
 go func(s Student) {
 defer wg.Done()
 summaryCh <- buildSummary(s)
 }(student)
 }

 go func() {
 wg.Wait()
 close(summaryCh)
 }()

 for summary := range summaryCh {
 fmt.Println(summary)
 }
}

说明：这道题把结构体、函数、判断、切片、goroutine、WaitGroup 和 channel 串起来了，很接近“并发生产结果，主流程统一收集”的基本模型。

第 5 题：谁先返回就先显示哪条消息

第 5 题一般

编写一个 Go 程序，完成下面要求：

创建两个 chan string： articleCh exerciseCh
启动两个 goroutine：一个在 120ms 后向 articleCh 发送 文章：channel 入门 一个在 60ms 后向 exerciseCh 发送 练习：WaitGroup 实战
使用 select 接收这两条消息
总共接收 2 次，并按“谁先准备好就先输出谁”的顺序打印

期望输出类似这样：

1
2


练习：WaitGroup 实战
文章：channel 入门

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import (
 "fmt"
 "time"
)

func main() {
 articleCh := make(chan string)
 exerciseCh := make(chan string)

 go func() {
 time.Sleep(120 * time.Millisecond)
 articleCh <- "文章：channel 入门"
 }()

 go func() {
 time.Sleep(60 * time.Millisecond)
 exerciseCh <- "练习：WaitGroup 实战"
 }()

 for i := 0; i < 2; i++ {
 select {
 case msg := <-articleCh:
 fmt.Println(msg)
 case msg := <-exerciseCh:
 fmt.Println(msg)
 }
 }
}

说明：这道题的重点是理解 select 不是按 case 书写顺序执行，而是谁先准备好就先进入谁。

第 6 题：用 `select + default` 写一个等待提示器

第 6 题一般

编写一个 Go 程序，完成下面要求：

创建 doneCh := make(chan string)
启动一个 goroutine，在 120ms 后向 doneCh 发送 批改完成
在主 goroutine 中使用 for {} + select
如果 doneCh 里还没有消息，就输出 等待中...
一旦收到 批改完成，就输出它并结束程序

要求：

使用 default 分支
为了避免 CPU 空转，请在 default 里加一点点等待时间

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import (
 "fmt"
 "time"
)

func main() {
 doneCh := make(chan string)

 go func() {
 time.Sleep(120 * time.Millisecond)
 doneCh <- "批改完成"
 }()

 for {
 select {
 case msg := <-doneCh:
 fmt.Println(msg)
 return
 default:
 fmt.Println("等待中...")
 time.Sleep(30 * time.Millisecond)
 }
 }
}

说明：

default 让 select 在“还没有消息”时也能先执行别的逻辑。
如果 default 里什么都不做，循环会疯狂空转，所以通常要配合 time.Sleep 或其他阻塞操作。

第 7 题：实现一个带超时的订单确认函数

第 7 题一般

编写一个 Go 程序，完成下面要求：

编写函数 confirmOrder(orderID int, workTime time.Duration) string
在这个函数里启动一个 goroutine，模拟后台确认订单
如果后台任务在 100ms 内完成，就返回：

1

订单1001确认完成

如果超过 100ms 还没完成，就返回：

1

订单1001确认超时

要求：

使用结果 channel 接收后台 goroutine 的返回值
使用 select + time.After 做超时控制
在 main 中至少测试两次：一次成功一次超时

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import (
 "fmt"
 "time"
)

func confirmOrder(orderID int, workTime time.Duration) string {
 resultCh := make(chan string, 1)

 go func() {
 time.Sleep(workTime)
 resultCh <- fmt.Sprintf("订单%d确认完成", orderID)
 }()

 select {
 case msg := <-resultCh:
 return msg
 case <-time.After(100 * time.Millisecond):
 return fmt.Sprintf("订单%d确认超时", orderID)
 }
}

func main() {
 fmt.Println(confirmOrder(1001, 50*time.Millisecond))
 fmt.Println(confirmOrder(1002, 200*time.Millisecond))
}

一种可能的输出结果：

1
2


订单1001确认完成
订单1002确认超时

说明：这里把结果 channel 写成 make(chan string, 1)，是为了让超时后后台 goroutine 仍然有机会把结果放进去，不容易被卡在发送位置。

第 8 题：并发计算切片平方并按原顺序输出

第 8 题一般

编写一个 Go 程序，完成下面要求：

准备一个切片：

1

nums := []int{2, 4, 6, 8}

定义结构体 SquareResult，字段包括： Index int Value int
为切片中的每个数字启动一个 goroutine，计算平方
每个 goroutine 把结果以 SquareResult 的形式发送到 resultCh
主 goroutine 收集所有结果，并恢复成原来的顺序
最后输出：

1

[4 16 36 64]

要求：

使用 WaitGroup
所有结果发送完成后关闭 resultCh

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


package main

import (
 "fmt"
 "sync"
)

type SquareResult struct {
 Index int
 Value int
}

func calcSquare(index, num int, resultCh chan SquareResult, wg *sync.WaitGroup) {
 defer wg.Done()
 resultCh <- SquareResult{
 Index: index,
 Value: num * num,
 }
}

func main() {
 nums := []int{2, 4, 6, 8}
 resultCh := make(chan SquareResult)
 results := make([]int, len(nums))

 var wg sync.WaitGroup

 for index, num := range nums {
 wg.Add(1)
 go calcSquare(index, num, resultCh, &wg)
 }

 go func() {
 wg.Wait()
 close(resultCh)
 }()

 for item := range resultCh {
 results[item.Index] = item.Value
 }

 fmt.Println(results)
}

说明：并发结果的返回顺序不一定和原切片顺序一样，所以这里额外把下标一起传回来，再由主 goroutine 按 Index 放回去。

进阶

下面 5 题会把 goroutine、WaitGroup、channel、select、超时处理和前面学过的结构体、自定义类型、接口、函数、切片、map 一起用起来，更接近真实的并发程序组织方式。

第 9 题：实现一个双工人任务处理队列

第 9 题进阶

请完成一个稍微完整一点的小场景：

定义结构体 Task，字段包括： ID int Name string
准备下面这组任务：

1
2
3
4
5
6
7


tasks := []Task{
 {ID: 1, Name: "复习变量"},
 {ID: 2, Name: "复习切片"},
 {ID: 3, Name: "完成 channel 练习"},
 {ID: 4, Name: "整理接口笔记"},
 {ID: 5, Name: "复盘协程超时"},
}

创建任务 channel jobCh 和结果 channel resultCh
编写函数 worker(workerID int, jobCh chan Task, resultCh chan string, wg *sync.WaitGroup)
启动 2 个 worker goroutine，共同处理同一条任务队列
每个 worker 处理完一项任务后，向 resultCh 发送类似下面的结果：

1

worker1 handled task 2: 复习切片

所有任务发完后关闭 jobCh
所有 worker 结束后关闭 resultCh
主 goroutine 使用 for range 输出所有处理结果

说明：结果输出顺序不固定。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


package main

import (
 "fmt"
 "sync"
 "time"
)

type Task struct {
 ID int
 Name string
}

func worker(workerID int, jobCh chan Task, resultCh chan string, wg *sync.WaitGroup) {
 defer wg.Done()

 for task := range jobCh {
 time.Sleep(40 * time.Millisecond)
 resultCh <- fmt.Sprintf("worker%d handled task %d: %s", workerID, task.ID, task.Name)
 }
}

func main() {
 tasks := []Task{
 {ID: 1, Name: "复习变量"},
 {ID: 2, Name: "复习切片"},
 {ID: 3, Name: "完成 channel 练习"},
 {ID: 4, Name: "整理接口笔记"},
 {ID: 5, Name: "复盘协程超时"},
 }

 jobCh := make(chan Task)
 resultCh := make(chan string)

 var wg sync.WaitGroup
 for workerID := 1; workerID <= 2; workerID++ {
 wg.Add(1)
 go worker(workerID, jobCh, resultCh, &wg)
 }

 go func() {
 for _, task := range tasks {
 jobCh <- task
 }
 close(jobCh)
 }()

 go func() {
 wg.Wait()
 close(resultCh)
 }()

 for result := range resultCh {
 fmt.Println(result)
 }
}

说明：这道题体现了 channel 既可以传“结果”，也可以当“任务队列”使用。两个 worker 同时从同一个 jobCh 取任务，是很常见的并发模型。

第 10 题：并发统计任务状态数量

第 10 题进阶

编写一个 Go 程序，完成下面要求：

定义自定义类型 TaskStatus，底层类型是 int
定义三个状态常量： StatusTodo StatusDoing StatusDone
给 TaskStatus 绑定方法 Text() string
定义结构体 Task，字段包括： Name string Status TaskStatus
准备下面这组任务：

1
2
3
4
5
6
7


tasks := []Task{
 {Name: "看课程", Status: StatusTodo},
 {Name: "写代码", Status: StatusDoing},
 {Name: "做练习", Status: StatusDone},
 {Name: "复盘", Status: StatusTodo},
 {Name: "提交作业", Status: StatusDone},
}

为每个任务启动一个 goroutine
每个 goroutine 把自己的 Status 发送到 statusCh
主 goroutine 使用 map[TaskStatus]int 统计每种状态的数量
最后按下面顺序输出：

1
2
3


待开始: 2
进行中: 1
已完成: 2

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68


package main

import (
 "fmt"
 "sync"
)

type TaskStatus int

const (
 StatusTodo TaskStatus = 1
 StatusDoing TaskStatus = 2
 StatusDone TaskStatus = 3
)

func (s TaskStatus) Text() string {
 switch s {
 case StatusTodo:
 return "待开始"
 case StatusDoing:
 return "进行中"
 case StatusDone:
 return "已完成"
 default:
 return "未知状态"
 }
}

type Task struct {
 Name string
 Status TaskStatus
}

func main() {
 tasks := []Task{
 {Name: "看课程", Status: StatusTodo},
 {Name: "写代码", Status: StatusDoing},
 {Name: "做练习", Status: StatusDone},
 {Name: "复盘", Status: StatusTodo},
 {Name: "提交作业", Status: StatusDone},
 }

 statusCh := make(chan TaskStatus)
 counts := make(map[TaskStatus]int)

 var wg sync.WaitGroup
 for _, task := range tasks {
 wg.Add(1)
 go func(t Task) {
 defer wg.Done()
 statusCh <- t.Status
 }(task)
 }

 go func() {
 wg.Wait()
 close(statusCh)
 }()

 for status := range statusCh {
 counts[status]++
 }

 order := []TaskStatus{StatusTodo, StatusDoing, StatusDone}
 for _, status := range order {
 fmt.Printf("%s: %d\n", status.Text(), counts[status])
 }
}

说明：这道题把自定义类型、方法、结构体、切片、map 和并发收集放到了一起。真正要练的不是“统计本身”，而是把多个 goroutine 产出的值安全汇总到主流程。

第 11 题：修正超时后仍可能卡住发送方的程序

第 11 题进阶

下面程序会输出：

1

timeout

但它还存在一个问题：超时之后，后台 goroutine 仍可能卡在发送结果的位置。
请改正代码，让它在保持超时输出的同时，不再让发送方因为结果没人接收而被卡住。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "time"
)

func main() {
 resultCh := make(chan string)

 go func() {
 time.Sleep(200 * time.Millisecond)
 resultCh <- "success"
 }()

 select {
 case msg := <-resultCh:
 fmt.Println(msg)
 case <-time.After(100 * time.Millisecond):
 fmt.Println("timeout")
 }
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "time"
)

func main() {
 resultCh := make(chan string, 1)

 go func() {
 time.Sleep(200 * time.Millisecond)
 resultCh <- "success"
 }()

 select {
 case msg := <-resultCh:
 fmt.Println(msg)
 case <-time.After(100 * time.Millisecond):
 fmt.Println("timeout")
 }
}

原因说明：

原来的 resultCh 是无缓冲 channel。
超时分支先执行后，主 goroutine 不再接收 resultCh，后台 goroutine 到了 resultCh <- "success" 这一步就可能一直等着。
改成 make(chan string, 1) 后，就算主 goroutine已经走到超时分支，后台 goroutine 仍可以把一个结果先放进 channel 里，不容易卡死在发送位置。

第 12 题：实现首个搜索结果优先的资源搜索器

第 12 题进阶

请完成一个稍微完整一点的小场景：

定义接口 Searcher，要求实现： Search(keyword string) string
定义两个实现： ArticleSearcher VideoSearcher
两个结构体都带一个字段： Delay time.Duration
Search 方法里先等待 Delay，再返回对应结果文字
编写函数 firstResult(keyword string, list []Searcher) string
这个函数要为切片中的每个搜索器启动一个 goroutine
使用 select 同时等待“最快返回的搜索结果”和“150ms 超时”
如果先拿到结果，就直接返回该结果
如果超时先到，就返回 timeout

要求：

在 main 中至少测试两组数据：一组能在超时前拿到结果一组会超时

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


package main

import (
 "fmt"
 "time"
)

type Searcher interface {
 Search(keyword string) string
}

type ArticleSearcher struct {
 Delay time.Duration
}

func (a ArticleSearcher) Search(keyword string) string {
 time.Sleep(a.Delay)
 return "文章结果：" + keyword
}

type VideoSearcher struct {
 Delay time.Duration
}

func (v VideoSearcher) Search(keyword string) string {
 time.Sleep(v.Delay)
 return "视频结果：" + keyword
}

func firstResult(keyword string, list []Searcher) string {
 resultCh := make(chan string, len(list))

 for _, item := range list {
 go func(searcher Searcher) {
 resultCh <- searcher.Search(keyword)
 }(item)
 }

 select {
 case result := <-resultCh:
 return result
 case <-time.After(150 * time.Millisecond):
 return "timeout"
 }
}

func main() {
 fastList := []Searcher{
 ArticleSearcher{Delay: 80 * time.Millisecond},
 VideoSearcher{Delay: 200 * time.Millisecond},
 }

 slowList := []Searcher{
 ArticleSearcher{Delay: 180 * time.Millisecond},
 VideoSearcher{Delay: 220 * time.Millisecond},
 }

 fmt.Println(firstResult("channel", fastList))
 fmt.Println(firstResult("timeout", slowList))
}

一种可能的输出结果：

1
2


文章结果：channel
timeout

说明：

这里的重点是“谁先返回就用谁”，而不是把所有结果都等齐。
resultCh 使用了 len(list) 大小的缓冲，这样即使主流程已经拿到第一个结果或进入超时分支，后面慢一点的 goroutine 也不容易被卡在发送上。

第 13 题：实现一个并发成绩分析中心

第 13 题进阶

请完成一个综合练习：

定义结构体 Student，字段包括： Name string Score int
准备下面这组数据：

1
2
3
4
5
6


students := []Student{
 {Name: "小李", Score: 82},
 {Name: "小王", Score: 59},
 {Name: "小张", Score: 91},
 {Name: "小周", Score: 76},
}

编写三个函数： calcTotal(students []Student, ch chan int) calcPassCount(students []Student, ch chan int) findTopStudent(students []Student, ch chan Student)
分别启动 3 个 goroutine 去计算：总分及格人数最高分学生
主 goroutine 使用 3 个不同的 channel 接收结果
再用 select 循环收集这 3 份结果
最后输出：

1
2
3


total=308
passCount=3
top=小张 91

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69


package main

import "fmt"

type Student struct {
 Name string
 Score int
}

func calcTotal(students []Student, ch chan int) {
 total := 0
 for _, student := range students {
 total += student.Score
 }
 ch <- total
}

func calcPassCount(students []Student, ch chan int) {
 count := 0
 for _, student := range students {
 if student.Score >= 60 {
 count++
 }
 }
 ch <- count
}

func findTopStudent(students []Student, ch chan Student) {
 top := students[0]
 for _, student := range students[1:] {
 if student.Score > top.Score {
 top = student
 }
 }
 ch <- top
}

func main() {
 students := []Student{
 {Name: "小李", Score: 82},
 {Name: "小王", Score: 59},
 {Name: "小张", Score: 91},
 {Name: "小周", Score: 76},
 }

 totalCh := make(chan int, 1)
 passCh := make(chan int, 1)
 topCh := make(chan Student, 1)

 go calcTotal(students, totalCh)
 go calcPassCount(students, passCh)
 go findTopStudent(students, topCh)

 total := 0
 passCount := 0
 var top Student

 for i := 0; i < 3; i++ {
 select {
 case total = <-totalCh:
 case passCount = <-passCh:
 case top = <-topCh:
 }
 }

 fmt.Printf("total=%d\n", total)
 fmt.Printf("passCount=%d\n", passCount)
 fmt.Printf("top=%s %d\n", top.Name, top.Score)
}

说明：这道题把结构体、切片、函数、goroutine、多个 channel 和 select 全串起来了。真正想练的是“把不同类型的并发结果分别算出来，再在主流程统一收集”。

11.1 线程安全

Sat, 11 Apr 2026 09:30:00 +0800

线程安全

概念说明

当多个 goroutine 同时访问同一份共享数据时，如果至少有一个 goroutine 在写数据，就可能产生数据竞争。
数据竞争会让结果不稳定，也可能让程序在运行时出现难以复现的问题。

线程安全的目标是：
多个并发任务同时执行时，共享数据仍然保持正确状态。

语法/规则

并发读取同一份不可变数据通常是安全的。
并发读写或并发写同一个变量时，需要同步保护。
简单数值计数可以使用 sync/atomic。
复杂临界区通常使用 sync.Mutex。
可以使用 go test -race 或 go run -race 检测数据竞争。

原子计数示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
 "fmt"
 "sync"
 "sync/atomic"
)

func main() {
 var count int64 // 共享计数器，多个 goroutine 都会修改它
 var wg sync.WaitGroup // 用来等待前面启动的 goroutine 全部执行完成

 for i := 0; i < 3; i++ {
 wg.Add(1) // 每启动一个 goroutine，就先登记 1 个待完成任务
 go func() {
 defer wg.Done() // defer 不是立刻执行；它会在当前 goroutine 结束前执行 Done
 atomic.AddInt64(&count, 1) // 安全地把 count 加 1，避免多个 goroutine 同时修改出错
 }()
 }

 wg.Wait() // 等待前面 3 个 goroutine 都调用 Done
 fmt.Println(count) // 所有 goroutine 都结束后，再输出最终结果
}

输出结果：

1

3

这里的 `defer wg.Done()` 怎么理解

先看这行代码：

1

defer wg.Done()

在这个示例里，可以先把它理解成：

1

这个 goroutine 快结束时，再执行 wg.Done()

也就是说，它不是一写到这里就立刻执行。
而是先把 wg.Done() 记下来，等当前 goroutine 里的代码快执行完时再调用。

所以这段 goroutine 更接近下面这种理解：

1
2
3
4


go func() {
 atomic.AddInt64(&count, 1)
 wg.Done()
}()

只是写成 defer wg.Done() 更安全。
因为即使后面 goroutine 里的代码变多了，Done() 也更不容易漏写。

这两个包在这里是做什么的

示例里导入了这两个包：

1
2
3
4


import (
 "sync"
 "sync/atomic"
)

在这篇里可以先这样理解：

sync 是 Go 标准库里处理并发同步的包。
这篇示例里，sync 只用到了 WaitGroup。
WaitGroup 的作用是：等待前面启动的所有 goroutine 都执行完成。

对应到代码里就是：

1
2
3
4


var wg sync.WaitGroup
wg.Add(1)
wg.Done()
wg.Wait()

而 sync/atomic 也可以先这样理解：

sync/atomic 是 Go 标准库里提供原子操作的包。
这篇示例里，sync/atomic 只用到了 atomic.AddInt64(&count, 1)。
它的作用是：安全地把 count 加 1，避免多个 goroutine 同时修改时出现数据竞争。

对应到代码里就是：

1

atomic.AddInt64(&count, 1)

可以先把它理解成：

1

安全地执行 count += 1

所以在这个示例中：

sync.WaitGroup 负责等所有 goroutine 做完。
sync/atomic 负责让多个 goroutine 安全地修改同一个计数器。

常见错误

认为 count++ 是一个原子操作，实际它包含读取、计算、写回多个步骤。
只在写入时加锁，读取时不加锁，仍可能产生数据竞争。
不使用 -race 检测并发代码，导致问题只在压力场景中暴露。

11.2 同步锁

Sat, 11 Apr 2026 09:30:00 +0800

同步锁

概念说明

sync.Mutex 是互斥锁。
同一时间只允许一个 goroutine 进入被锁保护的代码区域。

这段被保护的代码区域通常叫临界区。
临界区里一般会读写共享变量、map、切片等数据。

语法/规则

使用 mu.Lock() 加锁。
使用 mu.Unlock() 解锁。
推荐在加锁后立即写 defer mu.Unlock()，避免提前返回忘记解锁。
锁保护的是 Lock() 到 Unlock() 之间这段共享数据操作，不是整个 goroutine。
不要复制已经使用过的 sync.Mutex。

场景示例：两个 goroutine 都要修改同一个计数器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


package main

import (
 "fmt"
 "sync"
 "time"
)

func writeFromA(mu *sync.Mutex, wg *sync.WaitGroup, count *int) {
 defer wg.Done()
 fmt.Println("A: want lock") // 这里还没有加锁

 mu.Lock()
 fmt.Println("A: get lock") // A 拿到锁后，其他 goroutine 只能在 Lock 处等待

 current := *count
 time.Sleep(100 * time.Millisecond) // 为了观察等待效果，这里故意放慢；实际开发不建议把耗时操作放在锁内
 *count = current + 1
 fmt.Println("A: write count =", *count)

 mu.Unlock() // 到这里才真正解锁，锁保护范围结束
}

func writeFromB(mu *sync.Mutex, wg *sync.WaitGroup, count *int) {
 defer wg.Done()
 fmt.Println("B: want lock") // 这里还没有加锁

 mu.Lock()
 fmt.Println("B: get lock") // 只有 A 解锁后，B 才能拿到锁

 current := *count
 *count = current + 1
 fmt.Println("B: write count =", *count)

 mu.Unlock() // 到这里解锁
}

func main() {
 var mu sync.Mutex
 var wg sync.WaitGroup
 count := 0

 wg.Add(1)
 go writeFromA(&mu, &wg, &count)

 time.Sleep(10 * time.Millisecond) // 给 A 一点时间先拿到锁，便于观察锁的效果

 wg.Add(1)
 go writeFromB(&mu, &wg, &count)

 wg.Wait()
 fmt.Println("final count:", count)
}

输出结果（为了便于观察，下面是一种常见结果）：

1
2
3
4
5
6
7


A: want lock
A: get lock
B: want lock
A: write count = 1
B: get lock
B: write count = 2
final count: 2

锁保护的范围在哪里

看 writeFromA 里的这几行：

1
2
3
4
5


mu.Lock()
current := *count
time.Sleep(100 * time.Millisecond)
*count = current + 1
mu.Unlock()

锁保护的就是这段范围：

1
2
3


mu.Lock() 开始加锁
...
mu.Unlock() 结束解锁

也就是说：

fmt.Println("A: want lock") 不在锁保护范围内。
current := *count 和 *count = current + 1 在锁保护范围内。
writeFromB 执行到 mu.Lock() 时，如果 A 还没解锁，就只能等待。
不是“锁住了 A 这个 goroutine”，而是“谁拿到同一把锁，谁才能进入这段共享数据操作”。

这个示例体现了什么

writeFromA 和 writeFromB 是两个不同函数，它们都在修改同一个 count。
没有锁时，它们可能同时读写 count，从而产生数据竞争。
加锁后，同一时间只有一个 goroutine 能进入 count 的读写区域。
这就是 Mutex 的独特作用：让共享数据的修改变成“一个一个来”。

常见错误

加锁后忘记解锁，导致其他 goroutine 永久阻塞。
锁的范围过大，把耗时 IO 也放在锁内，降低并发性能。
在不同地方用不同锁保护同一份数据，导致保护失效。
复制带锁的结构体，可能造成锁状态混乱。

11.3 sync.Map

Sat, 11 Apr 2026 09:30:00 +0800

sync.Map

概念说明

普通 map 不支持并发读写。
如果多个 goroutine 同时读写普通 map，可能出现数据竞争，严重时会直接触发运行时错误。

sync.Map 是标准库提供的并发安全 map。
它适合读多写少、键集合相对稳定等场景。

语法/规则

使用 Store(key, value) 写入数据。
使用 Load(key) 读取数据，返回 value, ok。
使用 Delete(key) 删除数据。
使用 Range(func(key, value any) bool) 遍历数据。
Range 返回 false 表示停止遍历。
如果需要强类型和复杂一致性，普通 map 加锁可能更清晰。

sync.Map 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "fmt"
 "sync"
)

func main() {
 var users sync.Map // 声明一个并发安全的 map

 users.Store("name", "abin") // 写入一组键值对
 users.Store("age", 21) // 再写入一组键值对

 name, ok := users.Load("name") // 读取 key 为 "name" 的值
 fmt.Println(name, ok) // ok 表示这个 key 是否存在

 users.Range(func(key, value any) bool { // 遍历 sync.Map 中的所有键值对
 fmt.Println(key, value)
 return true // 返回 true 表示继续遍历
 })
}

输出结果（遍历顺序可能不同）：

1
2
3


abin true
name abin
age 21

常见错误

并发读写普通 map，可能触发 fatal error: concurrent map writes。
忘记 Load 返回的是 any，使用具体类型前需要断言。
以为 Range 遍历顺序固定，实际不要依赖顺序。
在所有场景都使用 sync.Map，忽略普通 map 加锁可能更简单。

11.4 练习

Sun, 12 Apr 2026 13:30:00 +0800

练习

学完本章你应该掌握

能识别哪些并发场景会发生数据竞争，并知道共享变量、切片、map 在并发写入时都需要同步保护。
能使用 sync/atomic 安全地维护简单计数器，并理解为什么 count++ 在并发场景下不可靠。
能使用 sync.Mutex 保护共享临界区，写对 Lock、Unlock 和 defer 的基本范围。
能使用 sync.Map 完成并发安全的存取、删除、遍历，并在取值后做必要的类型断言。
能把前面学过的结构体、方法、切片、map、函数、WaitGroup、channel、select 等知识自然组合到线程安全场景里。

简单

第 1 题：用原子操作统计完成的练习数

第 1 题简单

编写一个 Go 程序，完成下面要求：

准备切片：

1

tasks := []string{"变量", "切片", "函数", "接口"}

为每个任务启动一个 goroutine
每个 goroutine 输出 xxx 完成
使用 sync/atomic 安全统计完成数量
使用 sync.WaitGroup 等待所有 goroutine 结束
最后输出：

1

finished=4

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import (
 "fmt"
 "sync"
 "sync/atomic"
)

func main() {
 tasks := []string{"变量", "切片", "函数", "接口"}

 var finished int64
 var wg sync.WaitGroup

 for _, task := range tasks {
 wg.Add(1)
 go func(task string) {
 defer wg.Done()
 fmt.Println(task, "完成")
 atomic.AddInt64(&finished, 1)
 }(task)
 }

 wg.Wait()
 fmt.Printf("finished=%d\n", finished)
}

说明：前面每一行 xxx 完成 的输出顺序不固定，但最终的 finished 应该稳定等于 4。

第 2 题：修正并发点赞数代码

第 2 题简单

下面程序的目标是稳定输出：

1

likes=100

但它现在有线程安全问题。请改正后让它正常运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "fmt"
 "sync"
)

func main() {
 var likes int64
 var wg sync.WaitGroup

 for i := 0; i < 100; i++ {
 wg.Add(1)
 go func() {
 defer wg.Done()
 likes++
 }()
 }

 wg.Wait()
 fmt.Printf("likes=%d\n", likes)
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
 "fmt"
 "sync"
 "sync/atomic"
)

func main() {
 var likes int64
 var wg sync.WaitGroup

 for i := 0; i < 100; i++ {
 wg.Add(1)
 go func() {
 defer wg.Done()
 atomic.AddInt64(&likes, 1)
 }()
 }

 wg.Wait()
 fmt.Printf("likes=%d\n", likes)
}

关键点：

likes++ 不是原子操作，它包含“读取旧值、加 1、写回新值”多个步骤。
多个 goroutine 同时执行这几个步骤时，就可能把彼此的结果覆盖掉。
这里的共享数据只是一个简单计数器，用 atomic.AddInt64 最直接。

第 3 题：给购物车总价加互斥锁

第 3 题简单

编写一个 Go 程序，完成下面要求：

定义结构体 Cart
字段包括： mu sync.Mutex Total int
给它绑定方法 Add(price int)
在 Add 里用互斥锁保护 Total
在 main 中启动两个 goroutine，分别调用： cart.Add(99) cart.Add(71)
等两个 goroutine 都结束后，输出：

1

total=170

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import (
 "fmt"
 "sync"
)

type Cart struct {
 mu sync.Mutex
 Total int
}

func (c *Cart) Add(price int) {
 c.mu.Lock()
 defer c.mu.Unlock()

 c.Total += price
}

func main() {
 var wg sync.WaitGroup
 cart := &Cart{}

 wg.Add(2)

 go func() {
 defer wg.Done()
 cart.Add(99)
 }()

 go func() {
 defer wg.Done()
 cart.Add(71)
 }()

 wg.Wait()
 fmt.Printf("total=%d\n", cart.Total)
}

说明：这里的共享数据不是单个计数器，而是结构体里的字段，所以更适合用 sync.Mutex 保护临界区。

一般

第 4 题：实现线程安全的词频统计器

第 4 题一般

编写一个 Go 程序，完成下面要求：

定义结构体 WordCounter
字段包括： mu sync.Mutex data map[string]int
给它绑定两个方法： Add(word string) Get(word string) int
准备下面这个切片：

1

words := []string{"go", "go", "map", "mutex", "go", "mutex"}

为每个单词启动一个 goroutine，调用 Add
等全部 goroutine 完成后，按下面顺序输出统计结果：

1
2
3


go: 3
map: 1
mutex: 2

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package main

import (
 "fmt"
 "sync"
)

type WordCounter struct {
 mu sync.Mutex
 data map[string]int
}

func (w *WordCounter) Add(word string) {
 w.mu.Lock()
 defer w.mu.Unlock()

 w.data[word]++
}

func (w *WordCounter) Get(word string) int {
 w.mu.Lock()
 defer w.mu.Unlock()

 return w.data[word]
}

func main() {
 words := []string{"go", "go", "map", "mutex", "go", "mutex"}

 counter := &WordCounter{
 data: make(map[string]int),
 }

 var wg sync.WaitGroup
 for _, word := range words {
 wg.Add(1)
 go func(word string) {
 defer wg.Done()
 counter.Add(word)
 }(word)
 }

 wg.Wait()

 order := []string{"go", "map", "mutex"}
 for _, word := range order {
 fmt.Printf("%s: %d\n", word, counter.Get(word))
 }
}

说明：这道题除了练习加锁，还顺手复习了结构体、方法、切片遍历和 map 计数。

第 5 题：使用 `sync.Map` 保存课程字符数

第 5 题一般

编写一个 Go 程序，完成下面要求：

准备切片：

1

lessons := []string{"变量", "切片", "接口"}

为每个课程名启动一个 goroutine
每个 goroutine 把“课程名 -> 字符数”存进 sync.Map
等所有 goroutine 完成后：
1. 使用 Load("接口") 输出

1

接口 chars=2

删除 "切片"
再次读取 "切片"，如果不存在，输出

1

切片 已删除

使用 Range 统计剩余课程名的总字符数，并输出

1

totalChars=4

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


package main

import (
 "fmt"
 "sync"
)

func main() {
 lessons := []string{"变量", "切片", "接口"}

 var lessonMap sync.Map
 var wg sync.WaitGroup

 for _, lesson := range lessons {
 wg.Add(1)
 go func(lesson string) {
 defer wg.Done()
 lessonMap.Store(lesson, len([]rune(lesson)))
 }(lesson)
 }

 wg.Wait()

 value, ok := lessonMap.Load("接口")
 if ok {
 chars := value.(int)
 fmt.Printf("接口 chars=%d\n", chars)
 }

 lessonMap.Delete("切片")

 _, ok = lessonMap.Load("切片")
 if !ok {
 fmt.Println("切片 已删除")
 }

 totalChars := 0
 lessonMap.Range(func(key, value any) bool {
 chars, ok := value.(int)
 if ok {
 totalChars += chars
 }
 return true
 })

 fmt.Printf("totalChars=%d\n", totalChars)
}

说明：

Load 取出的值类型是 any，这里需要断言成 int 才能继续使用。
这道题顺手复习了前面字符串章节里的 []rune，因为题目要求按“字符数”而不是字节数来统计。

第 6 题：修正并发切片追加程序

第 6 题一般

下面程序的目标是：

每个 goroutine 往 logs 里追加一条日志
最后输出日志总数 count=3

但它现在有线程安全问题。请改正后让它正常运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import (
 "fmt"
 "sync"
)

func main() {
 names := []string{"阿斌", "小李", "小王"}
 logs := []string{}

 var wg sync.WaitGroup

 for _, name := range names {
 wg.Add(1)
 go func(name string) {
 defer wg.Done()
 logs = append(logs, name+" 完成了线程安全练习")
 }(name)
 }

 wg.Wait()

 fmt.Printf("count=%d\n", len(logs))
 for _, log := range logs {
 fmt.Println(log)
 }
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


package main

import (
 "fmt"
 "sync"
)

func main() {
 names := []string{"阿斌", "小李", "小王"}
 logs := []string{}

 var mu sync.Mutex
 var wg sync.WaitGroup

 for _, name := range names {
 wg.Add(1)
 go func(name string) {
 defer wg.Done()

 mu.Lock()
 logs = append(logs, name+" 完成了线程安全练习")
 mu.Unlock()
 }(name)
 }

 wg.Wait()

 fmt.Printf("count=%d\n", len(logs))
 for _, log := range logs {
 fmt.Println(log)
 }
}

说明：

append 操作可能触发切片扩容和底层数组变更，所以并发追加也需要同步保护。
最后三条日志的先后顺序不固定，只要总数是 3 且每条日志都成功追加即可。

进阶

下面两题会把前面学过的结构体、方法、切片、map、WaitGroup、channel 和 select 一起串起来，但真正要解决的问题仍然是共享数据的线程安全。

第 7 题：实现并发订单统计中心

第 7 题进阶

编写一个 Go 程序，完成下面要求：

定义结构体 Order，字段包括： User string Amount int
定义结构体 OrderCenter，字段包括： mu sync.Mutex totals map[string]int processed int64
给 OrderCenter 绑定方法 Record(order Order)
在 Record 中：
1. 用 Mutex 安全更新每个用户的订单总金额
2. 用原子操作安全统计已处理订单数
准备下面这组订单：

1
2
3
4
5
6


orders := []Order{
 {User: "阿斌", Amount: 120},
 {User: "小李", Amount: 80},
 {User: "阿斌", Amount: 30},
 {User: "小王", Amount: 50},
}

为每笔订单启动一个 goroutine 调用 Record
等全部处理完成后，输出：

1
2
3
4


processed=4
阿斌: 150
小李: 80
小王: 50

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


package main

import (
 "fmt"
 "sync"
 "sync/atomic"
)

type Order struct {
 User string
 Amount int
}

type OrderCenter struct {
 mu sync.Mutex
 totals map[string]int
 processed int64
}

func (c *OrderCenter) Record(order Order) {
 c.mu.Lock()
 c.totals[order.User] += order.Amount
 c.mu.Unlock()

 atomic.AddInt64(&c.processed, 1)
}

func main() {
 orders := []Order{
 {User: "阿斌", Amount: 120},
 {User: "小李", Amount: 80},
 {User: "阿斌", Amount: 30},
 {User: "小王", Amount: 50},
 }

 center := &OrderCenter{
 totals: make(map[string]int),
 }

 var wg sync.WaitGroup
 for _, order := range orders {
 wg.Add(1)
 go func(order Order) {
 defer wg.Done()
 center.Record(order)
 }(order)
 }

 wg.Wait()

 fmt.Printf("processed=%d\n", atomic.LoadInt64(&center.processed))

 orderUsers := []string{"阿斌", "小李", "小王"}
 for _, user := range orderUsers {
 fmt.Printf("%s: %d\n", user, center.totals[user])
 }
}

说明：这道题里两类共享数据的保护方式不同。

processed 是简单计数器，适合用原子操作。
totals 是共享 map，适合用互斥锁保护整段读写。

第 8 题：实现带超时的并发学习结果表

第 8 题进阶

请完成一个稍微完整一点的小场景：

定义结构体 LessonResult，字段包括： Name string Status string
准备切片：

1

lessons := []string{"变量", "函数", "接口"}

为每个课程启动一个 goroutine
每个 goroutine 先模拟学习耗时，再把结果写入 sync.Map
sync.Map 的 key 使用课程名，value 使用 LessonResult
另外准备一个 doneCh，每完成一个课程就发送一次完成信号
主 goroutine 使用 select 同时等待：
1. doneCh 的完成信号
2. time.After(1 * time.Second) 的超时信号
如果全部课程都完成，就按 lessons 的顺序输出：

1
2
3


变量 -> 已完成
函数 -> 已完成
接口 -> 已完成

如果先超时，就输出：

1

timeout

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


package main

import (
 "fmt"
 "sync"
 "time"
)

type LessonResult struct {
 Name string
 Status string
}

func main() {
 lessons := []string{"变量", "函数", "接口"}

 var results sync.Map
 doneCh := make(chan struct{}, len(lessons))
 timeout := time.After(1 * time.Second)

 for _, lesson := range lessons {
 go func(lesson string) {
 time.Sleep(50 * time.Millisecond)

 results.Store(lesson, LessonResult{
 Name: lesson,
 Status: "已完成",
 })

 doneCh <- struct{}{}
 }(lesson)
 }

 completed := 0
 for completed < len(lessons) {
 select {
 case <-doneCh:
 completed++
 case <-timeout:
 fmt.Println("timeout")
 return
 }
 }

 for _, lesson := range lessons {
 value, ok := results.Load(lesson)
 if !ok {
 continue
 }

 result := value.(LessonResult)
 fmt.Printf("%s -> %s\n", result.Name, result.Status)
 }
}

说明：

这里真正和本章强相关的是 sync.Map，因为多个 goroutine 会同时写入同一张结果表。
doneCh 和 select 是前一章的知识，在这道题里只是自然地承担“完成通知”和“超时控制”的角色。

12.1 error 向上抛

Sat, 11 Apr 2026 09:30:00 +0800

error 向上抛

概念说明

Go 的常规错误处理方式是返回 error。
函数遇到无法处理的问题时，把错误作为返回值交给调用方，由调用方决定记录、重试、返回响应或中断流程。

这种方式不是自动抛异常。
它更像是把失败结果显式写在函数签名里。

语法/规则

约定把 error 放在返回值列表最后。
没有错误时返回 nil。
调用方使用 if err != nil 处理错误。
使用 fmt.Errorf("...: %w", err) 可以包装底层错误。
不要忽略关键错误返回值。

向上返回错误示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import (
 "fmt"
 "strconv"
)

func parseAge(text string) (int, error) {
 age, err := strconv.Atoi(text) // 尝试把字符串转换成 int
 if err != nil { // 转换失败时，不在这里硬处理，而是把错误继续向上返回
 return 0, fmt.Errorf("parse age: %w", err) // 包装底层错误，补充“parse age”这层上下文
 }
 return age, nil // 转换成功，返回年龄和 nil 错误
}

func main() {
 age, err := parseAge("abc") // 故意传入错误数据，观察错误如何向上返回
 if err != nil { // 调用方拿到错误后，决定怎么处理
 fmt.Println(err)
 return
 }

 fmt.Println(age)
}

输出结果：

1

parse age: strconv.Atoi: parsing "abc": invalid syntax

这里的 `strconv.Atoi` 是做什么的

在这段代码里：

1

age, err := strconv.Atoi(text)

strconv.Atoi 的作用是：把字符串转换成整数。

例如：

1
2


strconv.Atoi("18") // 得到 18, nil
strconv.Atoi("abc") // 得到 0, error

所以在这个示例中：

如果 text 像 "18" 这样是正常数字字符串，就能成功转成整数。
如果 text 像 "abc" 这样不是数字，就会返回错误。
parseAge 再把这个底层错误包装成 parse age: ...，继续向上交给调用方处理。

常见错误

忽略 err，导致后续逻辑拿着无效数据继续执行。
返回错误时丢失上下文，调用方只知道失败，不知道失败发生在哪里。
没有错误时返回一个空字符串错误，正确做法是返回 nil。
把所有错误都 panic，导致可恢复的业务失败也中断程序。

12.2 panic 中断程序

Sat, 11 Apr 2026 09:30:00 +0800

panic 中断程序

概念说明

panic 表示程序遇到了无法继续执行的严重问题。
触发 panic 后，当前函数会停止正常流程，并开始向上展开调用栈。

普通业务错误应优先返回 error。
panic 更适合表示程序员错误、不可恢复状态或初始化阶段的致命问题。

语法/规则

使用 panic(value) 主动触发 panic。
数组越界、空指针解引用等运行时错误也会触发 panic。
panic 会执行当前 goroutine 中已经注册的 defer。
没有被 recover 捕获时，程序会打印 panic 信息并退出。
不要把 panic 当成普通流程控制。

panic 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

func mustPositive(count int) {
 if count <= 0 {
 panic("count must be positive")
 }
}

func main() {
 mustPositive(0)
}

关键输出：

1

panic: count must be positive

上面的例子更偏向语法演示。
下面这个场景更能体现 panic 什么时候该用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import "fmt"

type Config struct {
 DBURL string
}

func mustLoadConfig(cfg Config) {
 if cfg.DBURL == "" {
 // 启动必须依赖的配置缺失，程序已经无法继续正常工作
 panic("missing DB_URL")
 }
}

func main() {
 cfg := Config{} // 假设启动时没有读取到数据库配置
 mustLoadConfig(cfg)

 // 不会执行到这里，因为 panic 已经中断了当前程序
 fmt.Println("server started")
}

这个例子想说明：

用户输入错误、参数校验失败，通常返回 error 更合适。
像“启动必需配置缺失”这种程序根本无法继续运行的情况，才更适合 panic。

常见错误

把用户输入错误、校验失败等普通业务问题都写成 panic。
以为 panic 后面的普通语句还会继续执行，实际当前正常流程会被打断。
忘记 panic 只影响当前 goroutine 的调用栈，跨 goroutine 需要在各自内部处理。

12.3 recover 恢复程序

Sat, 11 Apr 2026 09:30:00 +0800

recover 恢复程序

概念说明

recover 用于捕获当前 goroutine 中正在发生的 panic。
它必须在 defer 调用的函数中使用，才能拦截 panic 并让程序恢复到可控状态。

恢复 panic 不等于问题消失。
捕获后通常还要记录日志、返回错误或做兜底处理。

语法/规则

recover() 只有在 deferred 函数中直接调用才有效。
没有发生 panic 时，recover() 返回 nil。
recover 只能捕获当前 goroutine 的 panic。
捕获 panic 后，当前函数不会回到 panic 发生点继续执行。
不要用 recover 隐藏所有错误，否则排查问题会更困难。

recover 示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import "fmt"

func safeRun() {
 // defer 会在 safeRun 即将结束时执行。
 // 如果函数里发生了 panic，Go 会先执行 defer，再决定是否继续向外抛出 panic。
 defer func() {
 // recover 必须在 defer 的函数里直接调用才有效。
 // 如果当前正在处理 panic，这里就能拿到 panic 的内容。
 if err := recover(); err != nil {
 fmt.Println("recovered:", err)
 // 一旦 recover 成功，这次 panic 就被拦住了。
 // safeRun 不会回到 panic 那一行继续执行，而是直接结束并返回给调用者。
 }
 }()

 fmt.Println("safeRun: start")

 // 这里触发 panic。
 // 从这一行开始，safeRun 后面的普通代码都不会继续执行。
 panic("something wrong")

 // 这一行永远不会执行，因为 panic 发生后流程会立刻转去执行 defer。
 // fmt.Println("safeRun: end")
}

func main() {
 // safeRun 内部已经把 panic recover 掉了，
 // 所以 panic 不会继续传到 main。
 safeRun()

 // 所谓“恢复”，指的是程序没有因为这次 panic 整体崩溃，
 // main 还能继续执行后面的代码。
 fmt.Println("main continues")
}

这里的“恢复”不是回到 panic("something wrong") 那一行后面继续跑，
而是把原本会继续向上传播的 panic 截住，让 safeRun() 正常结束，随后 main() 继续往下执行。

输出结果：

1
2
3


safeRun: start
recovered: something wrong
main continues

常见错误

在普通函数调用中直接写 recover()，无法捕获 panic。
以为 recover 可以跨 goroutine 捕获 panic，实际每个 goroutine 要自己处理。
捕获后什么也不做，导致错误被静默吞掉。
认为 recover 后会回到 panic 那一行继续执行，实际不会。

12.4 练习

Sun, 12 Apr 2026 00:10:00 +0800

练习

学完本章你应该掌握

能把普通失败设计成 error 返回值，并在调用方先判断 err 再决定继续、提示、返回还是中断当前流程。
能使用 fmt.Errorf("...: %w", err) 为底层错误补充上下文，让调用方知道错误发生在哪一层。
能区分哪些场景应该返回 error，哪些场景更适合使用 panic 表示程序无法继续执行的严重问题。
能使用 defer + recover() 在合适的边界兜住 panic，并把崩溃改造成日志、提示或错误结果。
能理解 recover 只对当前 goroutine 生效，不会回到 panic 发生点继续执行，也不会替你跨 goroutine 捕获异常。
能把本章知识自然放进前面学过的函数、结构体、切片、map、输入校验、goroutine 和 channel 场景里。

简单

第 1 题：编写返回 `error` 的分数解析函数

第 1 题简单

编写一个 Go 程序，完成下面要求：

编写函数 parseScore(text string) (int, error)
使用 strconv.Atoi 把字符串分数转成整数
如果转换失败，直接把错误返回给调用方
如果分数不在 0 ~ 100 之间，返回错误 score out of range
在 main 中至少测试两次：一次传入 "88" 一次传入 "abc"
调用方必须先判断 err

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


package main

import (
 "errors"
 "fmt"
 "strconv"
)

func parseScore(text string) (int, error) {
 score, err := strconv.Atoi(text)
 if err != nil {
 return 0, err
 }

 if score < 0 || score > 100 {
 return 0, errors.New("score out of range")
 }

 return score, nil
}

func main() {
 score, err := parseScore("88")
 if err != nil {
 fmt.Println("parse error:", err)
 } else {
 fmt.Println(score)
 }

 score, err = parseScore("abc")
 if err != nil {
 fmt.Println("parse error:", err)
 return
 }

 fmt.Println(score)
}

一种可能的输出结果：

1
2


88
parse error: strconv.Atoi: parsing "abc": invalid syntax

说明：这道题的重点不是 Atoi 本身，而是让你把“失败也算结果的一部分”真正写进函数签名里。

第 2 题：补全错误包装语句

第 2 题简单

补全下面代码中的空白，让底层错误在向上返回时带上 load age 这层上下文：

1
2
3
4
5
6
7


func loadAge(text string) (int, error) {
 age, err := strconv.Atoi(text)
 if err != nil {
 return 0, _______________________
 }
 return age, nil
}

查看参考答案

应补全为：

1

fmt.Errorf("load age: %w", err)

完整函数如下：

1
2
3
4
5
6
7


func loadAge(text string) (int, error) {
 age, err := strconv.Atoi(text)
 if err != nil {
 return 0, fmt.Errorf("load age: %w", err)
 }
 return age, nil
}

说明：%w 的作用是把底层错误包进新的错误里，这样调用方既能看到当前这层上下文，也不会丢失原始错误信息。

第 3 题：修正把普通输入错误写成 `panic` 的程序

第 3 题简单

下面程序把普通用户输入错误直接写成了 panic。
请改正代码，让它在输入有误时给出提示并结束当前流程，而不是直接崩溃程序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import (
 "fmt"
 "strconv"
)

func main() {
 var ageText string

 fmt.Print("请输入年龄：")
 fmt.Scan(&ageText)

 age, err := strconv.Atoi(ageText)
 if err != nil {
 panic(err)
 }

 if age < 0 || age > 120 {
 panic("bad age")
 }

 fmt.Println(age + 1)
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import (
 "fmt"
 "strconv"
)

func main() {
 var ageText string

 fmt.Print("请输入年龄：")
 _, err := fmt.Scan(&ageText)
 if err != nil {
 fmt.Println("输入有误：", err)
 return
 }

 age, err := strconv.Atoi(ageText)
 if err != nil {
 fmt.Println("年龄必须是整数")
 return
 }

 if age < 0 || age > 120 {
 fmt.Println("年龄范围不合法")
 return
 }

 fmt.Println(age + 1)
}

关键点：

用户输入错误属于普通业务失败，优先返回提示或结束当前流程，不要动不动就 panic
panic 更适合“程序根本无法继续”的场景，而不是“这次输入不合法”

第 4 题：编写必须加载配置函数

第 4 题简单

编写一个 Go 程序，完成下面要求：

定义结构体 Config，字段为 DBURL string
编写函数 mustLoadConfig(cfg Config)
如果 cfg.DBURL == ""，触发 panic("missing DB_URL")
在 main 中故意传入一个空配置，观察程序中断

关键输出应类似这样：

1

panic: missing DB_URL

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

type Config struct {
 DBURL string
}

func mustLoadConfig(cfg Config) {
 if cfg.DBURL == "" {
 panic("missing DB_URL")
 }
}

func main() {
 cfg := Config{}
 mustLoadConfig(cfg)
}

说明：这里的配置缺失会导致程序启动后根本无法继续工作，所以比起返回普通 error，更适合用 panic 直接中断。

第 5 题：使用 `recover` 让主流程继续

第 5 题简单

编写一个 Go 程序，完成下面要求：

编写函数 safeRun()
在 safeRun 中先输出 safeRun start
然后触发 panic("lesson broken")
使用 defer + recover() 捕获这次 panic，并输出 recovered: lesson broken
在 main 中调用 safeRun() 后，再输出 main continues

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func safeRun() {
 defer func() {
 if err := recover(); err != nil {
 fmt.Println("recovered:", err)
 }
 }()

 fmt.Println("safeRun start")
 panic("lesson broken")
}

func main() {
 safeRun()
 fmt.Println("main continues")
}

输出结果：

1
2
3


safeRun start
recovered: lesson broken
main continues

说明：所谓“恢复”，不是回到 panic 那一行后面继续执行，而是把原本要继续向上传播的 panic 截住，让外层流程还能往下走。

一般

第 6 题：封装资料卡生成函数并向上抛错

第 6 题一般

编写一个 Go 程序，完成下面要求：

编写函数 parseAge(text string) (int, error)
在这个函数里使用 strconv.Atoi
如果转换失败，返回 fmt.Errorf("parse age: %w", err)
再编写函数 buildProfile(name, ageText string) (string, error)
如果 name == ""，返回错误 name is empty
如果年龄解析失败，继续向上包装成 fmt.Errorf("build profile: %w", err)
成功时返回：

1

姓名：小王，年龄：18

在 main 中至少测试一次错误场景

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import (
 "errors"
 "fmt"
 "strconv"
)

func parseAge(text string) (int, error) {
 age, err := strconv.Atoi(text)
 if err != nil {
 return 0, fmt.Errorf("parse age: %w", err)
 }
 return age, nil
}

func buildProfile(name, ageText string) (string, error) {
 if name == "" {
 return "", errors.New("name is empty")
 }

 age, err := parseAge(ageText)
 if err != nil {
 return "", fmt.Errorf("build profile: %w", err)
 }

 return fmt.Sprintf("姓名：%s，年龄：%d", name, age), nil
}

func main() {
 profile, err := buildProfile("小王", "abc")
 if err != nil {
 fmt.Println(err)
 return
 }

 fmt.Println(profile)
}

输出结果：

1

build profile: parse age: strconv.Atoi: parsing "abc": invalid syntax

说明：这道题真正要练的是“每一层只补充自己知道的上下文”，而不是一出错就把底层细节丢掉。

第 7 题：修正放错位置的 `recover`

第 7 题一般

下面程序想捕获 panic，但现在写法不对。
请改正代码，让它最终输出：

1
2
3


start
recovered: boom
main continues

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func safeRun() {
 fmt.Println("start")
 panic("boom")

 if err := recover(); err != nil {
 fmt.Println("recovered:", err)
 }
}

func main() {
 safeRun()
 fmt.Println("main continues")
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func safeRun() {
 defer func() {
 if err := recover(); err != nil {
 fmt.Println("recovered:", err)
 }
 }()

 fmt.Println("start")
 panic("boom")
}

func main() {
 safeRun()
 fmt.Println("main continues")
}

原因说明：

recover() 必须在 defer 调用的函数中直接使用才有效
原程序把 recover() 放在普通流程里，而且 panic 发生后那几行本来就不会继续执行

第 8 题：把 `panic` 转成 `error` 返回

第 8 题一般

编写一个 Go 程序，完成下面要求：

编写函数 runJob(name string) (err error)
如果 name == ""，触发 panic("job name empty")
使用 defer + recover() 捕获这次 panic
捕获后把它转换成错误返回给调用方，例如：

1

run job: job name empty

如果 name 不为空，输出 run ok: 任务名
在 main 中至少测试一次正常场景和一次失败场景

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import "fmt"

func runJob(name string) (err error) {
 defer func() {
 if r := recover(); r != nil {
 err = fmt.Errorf("run job: %v", r)
 }
 }()

 if name == "" {
 panic("job name empty")
 }

 fmt.Println("run ok:", name)
 return nil
}

func main() {
 if err := runJob("parse report"); err != nil {
 fmt.Println(err)
 }

 if err := runJob(""); err != nil {
 fmt.Println(err)
 }
}

一种可能的输出结果：

1
2


run ok: parse report
run job: job name empty

说明：这类写法常见于程序边界层。内部出现了 panic，但边界层不想让整个程序直接崩掉，而是希望把它整理成一个可处理的错误结果。

第 9 题：判断哪些场景该用 `error`，哪些该用 `panic`

第 9 题一般

下面四种情况里，哪些更适合返回 error，哪些更适合使用 panic？请分别写出判断，并简要说明原因。

1
2
3
4


A. 用户输入的年龄不是数字
B. 程序启动时 DB_URL 为空，服务根本无法工作
C. 订单确认等待超过 100ms
D. 代码把 nums[len(nums)] 写成了数组访问

查看参考答案

一种合理的判断如下：

1
2
3
4


A -> error
B -> panic
C -> error
D -> panic

原因说明：

A 属于普通业务输入错误，应该交给调用方提示用户或重新输入
B 属于启动阶段的致命配置问题，程序无法继续正常工作，更适合直接中断
C 是可预期的业务失败或超时结果，通常应作为 error 或失败状态返回
D 更像代码 bug 或运行时严重错误，这类问题通常会触发 panic，而不是正常业务分支

第 10 题：为高阶执行器加上恢复保护

第 10 题一般

编写一个 Go 程序，完成下面要求：

编写函数 executeSafely(fn func()) error
在函数内部执行传入的 fn
如果 fn 发生 panic，使用 recover 捕获，并返回：

1

execute failed: bad task

在 main 中至少测试两次：一次传入正常函数一次传入会 panic("bad task") 的函数

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import "fmt"

func executeSafely(fn func()) (err error) {
 defer func() {
 if r := recover(); r != nil {
 err = fmt.Errorf("execute failed: %v", r)
 }
 }()

 fn()
 return nil
}

func main() {
 err := executeSafely(func() {
 fmt.Println("task 1 ok")
 })
 if err != nil {
 fmt.Println(err)
 }

 err = executeSafely(func() {
 panic("bad task")
 })
 if err != nil {
 fmt.Println(err)
 }
}

一种可能的输出结果：

1
2


task 1 ok
execute failed: bad task

说明：这道题顺手复习了上一章的高阶函数。executeSafely 接收的不是普通数据，而是一个“待执行的行为”。

进阶

下面四题会把异常处理和前面学过的结构体、函数、切片、goroutine、channel 串起来，重点考察你能不能在更真实一点的程序边界里区分 error、panic 和 recover。

第 11 题：解析成绩表并补充学生上下文

第 11 题进阶

编写一个 Go 程序，完成下面要求：

定义结构体 StudentInput，字段包括： Name string ScoreText string
编写函数 parseOneScore(text string) (int, error)
再编写函数 buildScoreMap(inputs []StudentInput) (map[string]int, error)
buildScoreMap 需要遍历输入切片，把 "文本分数" 转成真正的整数分数
如果某个学生解析失败，要返回带学生名上下文的错误，例如：

1

student 小王: strconv.Atoi: parsing "abc": invalid syntax

成功时返回 map[string]int

测试数据可以使用：

1
2
3
4
5


inputs := []StudentInput{
 {Name: "小李", ScoreText: "92"},
 {Name: "小王", ScoreText: "abc"},
 {Name: "小张", ScoreText: "76"},
}

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


package main

import (
 "errors"
 "fmt"
 "strconv"
)

type StudentInput struct {
 Name string
 ScoreText string
}

func parseOneScore(text string) (int, error) {
 score, err := strconv.Atoi(text)
 if err != nil {
 return 0, err
 }

 if score < 0 || score > 100 {
 return 0, errors.New("score out of range")
 }

 return score, nil
}

func buildScoreMap(inputs []StudentInput) (map[string]int, error) {
 result := make(map[string]int)

 for _, input := range inputs {
 score, err := parseOneScore(input.ScoreText)
 if err != nil {
 return nil, fmt.Errorf("student %s: %w", input.Name, err)
 }

 result[input.Name] = score
 }

 return result, nil
}

func main() {
 inputs := []StudentInput{
 {Name: "小李", ScoreText: "92"},
 {Name: "小王", ScoreText: "abc"},
 {Name: "小张", ScoreText: "76"},
 }

 scores, err := buildScoreMap(inputs)
 if err != nil {
 fmt.Println(err)
 return
 }

 fmt.Println(scores)
}

说明：这道题把结构体、切片、map、函数和错误包装放到了一起。真正要练的是“错误不只要往上抛，还要带着足够的定位信息一起抛”。

第 12 题：在 goroutine 中各自 recover 任务 panic

第 12 题进阶

编写一个 Go 程序，完成下面要求：

定义结构体 Task，字段包括： ID int Name string
编写函数 worker(task Task, resultCh chan string, wg *sync.WaitGroup)
在 worker 中使用 defer + recover()
如果 task.Name == ""，触发 panic("task name empty")
如果没有 panic，就发送：

1

task 1 done: 复习 error

如果发生 panic，就发送：

1

task 2 failed: task name empty

在 main 中准备 3 个任务，其中 1 个任务名为空
使用 goroutine 启动所有任务
使用 WaitGroup 等待全部完成后关闭 resultCh
使用 for range 输出所有结果

说明：输出顺序不固定。

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


package main

import (
 "fmt"
 "sync"
)

type Task struct {
 ID int
 Name string
}

func worker(task Task, resultCh chan string, wg *sync.WaitGroup) {
 defer wg.Done()

 defer func() {
 if err := recover(); err != nil {
 resultCh <- fmt.Sprintf("task %d failed: %v", task.ID, err)
 }
 }()

 if task.Name == "" {
 panic("task name empty")
 }

 resultCh <- fmt.Sprintf("task %d done: %s", task.ID, task.Name)
}

func main() {
 tasks := []Task{
 {ID: 1, Name: "复习 error"},
 {ID: 2, Name: ""},
 {ID: 3, Name: "练习 recover"},
 }

 resultCh := make(chan string)
 var wg sync.WaitGroup

 for _, task := range tasks {
 wg.Add(1)
 go worker(task, resultCh, &wg)
 }

 go func() {
 wg.Wait()
 close(resultCh)
 }()

 for result := range resultCh {
 fmt.Println(result)
 }
}

说明：这道题最关键的点不是 WaitGroup 或 channel，而是体会“每个 goroutine 要自己 recover 自己的 panic”。

第 13 题：修正试图在 `main` 中 recover 子 goroutine 的代码

第 13 题进阶

下面程序想在 main 中统一 recover 一个子 goroutine 里的 panic，但它现在做不到。
请改正代码，让它稳定输出：

1
2


worker recovered: worker broken
main end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "fmt"
 "time"
)

func main() {
 defer func() {
 if err := recover(); err != nil {
 fmt.Println("main recovered:", err)
 }
 }()

 go func() {
 panic("worker broken")
 }()

 time.Sleep(100 * time.Millisecond)
 fmt.Println("main end")
}

查看参考答案

修正后的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import (
 "fmt"
 "sync"
)

func main() {
 var wg sync.WaitGroup

 wg.Add(1)
 go func() {
 defer wg.Done()

 defer func() {
 if err := recover(); err != nil {
 fmt.Println("worker recovered:", err)
 }
 }()

 panic("worker broken")
 }()

 wg.Wait()
 fmt.Println("main end")
}

原因说明：

main 里的 recover 只能处理 main 这个 goroutine 自己的 panic
子 goroutine 里的 panic，必须在那个 goroutine 自己的 defer 里恢复
这里顺手把 time.Sleep 换成了 WaitGroup，等待方式更稳定

第 14 题：实现一个并发批改中心

第 14 题进阶

请完成一个综合练习：

定义结构体 CheckTask，字段包括： Index int Name string ScoreText string
定义结构体 CheckResult，字段包括： Index int Text string
编写函数 parseScore(text string) (int, error) 使用 strconv.Atoi 如果解析失败，返回 fmt.Errorf("parse score: %w", err) 如果分数不在 0 ~ 100 范围内，返回 score out of range
编写函数 levelOf(score int) string 按 A / B / C / D 返回等级
编写 goroutine 函数 checkTask(task CheckTask, resultCh chan CheckResult, wg *sync.WaitGroup) 在里面使用 defer + recover() 如果 task.Name == ""，触发 panic("missing student name") 如果文本分数解析失败，发送失败结果如果成功，发送成功结果
在 main 中准备下面这组任务：

1
2
3
4
5
6


tasks := []CheckTask{
 {Index: 1, Name: "小李", ScoreText: "92"},
 {Index: 2, Name: "", ScoreText: "88"},
 {Index: 3, Name: "小王", ScoreText: "abc"},
 {Index: 4, Name: "小张", ScoreText: "59"},
}

为每个任务启动一个 goroutine
使用 channel + WaitGroup 收集结果
最后按 Index 的原始顺序输出结果

期望输出类似这样：

1
2
3
4


任务1成功：小李 92 A
任务2失败：missing student name
任务3失败：parse score: strconv.Atoi: parsing "abc": invalid syntax
任务4成功：小张 59 D

查看参考答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107


package main

import (
 "errors"
 "fmt"
 "strconv"
 "sync"
)

type CheckTask struct {
 Index int
 Name string
 ScoreText string
}

type CheckResult struct {
 Index int
 Text string
}

func parseScore(text string) (int, error) {
 score, err := strconv.Atoi(text)
 if err != nil {
 return 0, fmt.Errorf("parse score: %w", err)
 }

 if score < 0 || score > 100 {
 return 0, errors.New("score out of range")
 }

 return score, nil
}

func levelOf(score int) string {
 switch {
 case score >= 90:
 return "A"
 case score >= 80:
 return "B"
 case score >= 60:
 return "C"
 default:
 return "D"
 }
}

func checkTask(task CheckTask, resultCh chan CheckResult, wg *sync.WaitGroup) {
 defer wg.Done()

 defer func() {
 if r := recover(); r != nil {
 resultCh <- CheckResult{
 Index: task.Index,
 Text: fmt.Sprintf("任务%d失败：%v", task.Index, r),
 }
 }
 }()

 if task.Name == "" {
 panic("missing student name")
 }

 score, err := parseScore(task.ScoreText)
 if err != nil {
 resultCh <- CheckResult{
 Index: task.Index,
 Text: fmt.Sprintf("任务%d失败：%v", task.Index, err),
 }
 return
 }

 resultCh <- CheckResult{
 Index: task.Index,
 Text: fmt.Sprintf("任务%d成功：%s %d %s", task.Index, task.Name, score, levelOf(score)),
 }
}

func main() {
 tasks := []CheckTask{
 {Index: 1, Name: "小李", ScoreText: "92"},
 {Index: 2, Name: "", ScoreText: "88"},
 {Index: 3, Name: "小王", ScoreText: "abc"},
 {Index: 4, Name: "小张", ScoreText: "59"},
 }

 resultCh := make(chan CheckResult, len(tasks))
 results := make([]string, len(tasks))

 var wg sync.WaitGroup
 for _, task := range tasks {
 wg.Add(1)
 go checkTask(task, resultCh, &wg)
 }

 go func() {
 wg.Wait()
 close(resultCh)
 }()

 for result := range resultCh {
 results[result.Index-1] = result.Text
 }

 for _, text := range results {
 fmt.Println(text)
 }
}

说明：

解析失败属于普通业务错误，所以这里用 error 返回
学生名缺失被题目约定成不可继续的严重问题，所以这里用 panic
checkTask 再用 recover 把单个任务的崩溃兜住，避免整个批改中心一起退出
这道题把 01-12 单元里学过的结构体、切片、函数、判断、goroutine、channel 和异常处理真正串起来了

Hobin's Blog

1.1 高频标准库包

Go 常用包总览

学习目标

常用包速查表

fmt：格式化输出的起点

strings 与 strconv：文本处理的高频组合

time：时间、日期与格式化

os、io、bufio、path/filepath：文件与系统操作

encoding/json：结构体与 JSON 互转

net/http：服务端和客户端都会用到

选包思路

常见误区

延伸阅读

1.1 标题

标题语法概览

ATX 风格（#）

基本语法

书写规则

Setext 风格（= / -）

标题层级结构

推荐结构

不推荐结构

常见错误

1.1 开发环境准备

学习目标

环境清单

实操步骤

验证标准

1.1 变量定义

变量定义

概念说明

语法/规则

单变量声明与零值示例

多变量与作用域示例

常见错误

1.2 文本格式

文本格式语法概览

换行与分段

行内换行（行尾两个空格）

分段（空一行）

强调语法

粗体

斜体

粗斜体

分割线

删除线、下划线与高亮

删除线

下划线（HTML 写法）

高亮（HTML 写法）

脚注

行内代码

基本写法

代码中包含反引号

常见错误

1.2 输出

输出

概念说明

语法/规则

示例

常见错误

1.3 列表

列表语法概览

无序列表

有序列表

自动编号技巧

列表嵌套

无序列表嵌套

有序列表嵌套

混合嵌套

任务列表

基本语法

实战示例

项目待办清单

设计阶段

开发阶段

测试阶段

常见错误

1.3 输入

输入

`fmt`：格式化输出的起点

`strings` 与 `strconv`：文本处理的高频组合

`time`：时间、日期与格式化

`os`、`io`、`bufio`、`path/filepath`：文件与系统操作

`encoding/json`：结构体与 JSON 互转

`net/http`：服务端和客户端都会用到

ATX 风格（`#`）

Setext 风格（`=` / `-`）

第 4 题：补全 `Printf` 的占位符

外层使用波浪号 `~~~`