487 lines
16 KiB
Markdown
487 lines
16 KiB
Markdown
---
|
||
tags: [Go, 后端开发, 武科大, Week02, 错题精讲]
|
||
create time: 2026-05-02 14:30
|
||
---
|
||
|
||
# 金山考试 - 武科大服务端 - 第二次课 · 错题精讲
|
||
|
||
## 概述
|
||
|
||
本次测试涵盖 **切片与数组、map、结构体与方法、接口、JSON、标准库（fmt/os/time）、内存分配 new vs make、并发（channel/sync）** 八大模块，共 37 道题（21 单选 + 3 多选）。其中 **36 道答对，1 道错题**，集中在 `map` 的引用语义与 `json.Unmarshal` 参数传递规则上。本笔记以错题为切入点，逐层展开相关知识。
|
||
|
||
> [!tip] 使用建议
|
||
> 先看错题本身的「为什么错 → 为什么对」，再顺着带出的知识点体系理解关联概念，最后用「高频考点速览」串联记忆薄弱点。
|
||
|
||
---
|
||
|
||
## 一、map 的引用语义与 json.Unmarshal 必须传地址
|
||
|
||
### 单6：关于 map 的正确说法
|
||
|
||
| 项目 | 内容 |
|
||
|------|------|
|
||
| ❌ 你的答案 | B |
|
||
| ✅ 正确答案 | **A** |
|
||
|
||
```go
|
||
// 【题目】关于 map，下面说法正确的是？
|
||
// A. map 反序列化时 json.Unmarshal() 的入参必须为 map 的地址 ✅
|
||
// B. 在函数调用中传递 map，则子函数中对 map 元素的增加不会导致父函数中 map 的修改 ❌
|
||
// C. 不能使用内置函数 delete() 删除 map 的元素 ❌
|
||
// D. 以上都不对 ❌
|
||
```
|
||
|
||
> [!error] 你的误区根源
|
||
> 你选了 **B**，认为「map 传进去后子函数的增删改不会影响外部」。这是把 map 当成了**值类型**。实际上 map 是 Go 中的**引用类型**——它的底层是一个指向哈希表的指针（runtime hmap），无论怎么传，大家都指向同一个数据源。
|
||
|
||
### 为什么 A 对：Unmarshal 必须传地址
|
||
|
||
```go
|
||
m := make(map[string]int)
|
||
|
||
// ❌ 错误：传值，内部修改只在局部生效
|
||
// json.Unmarshal([]byte(`{"a":1}`), m) // panic: assignment to entry in nil map
|
||
|
||
// ✅ 正确：传地址 &m，Unmarshal 才能往里写
|
||
json.Unmarshal([]byte(`{"a":1,"b":2}`), &m)
|
||
fmt.Println(m) // map[a:1 b:2]
|
||
```
|
||
|
||
> [!abstract] Unmarshal 的设计原理
|
||
|
||
```mermaid
|
||
flowchart TD
|
||
A["json.Unmarshal data"] --> B{入参是 *any}
|
||
B -->|"传的是 &m"| C["*map 解引用 → 拿到原始 map 指针"]
|
||
C --> D["向原始 map 写入 key-value ✅"]
|
||
B -->|"传的是 m（值）"| E["m 本身是指针，传给 any 后丢失"]
|
||
E --> F["无法获取原始引用，写入失败或无效果 ❌"]
|
||
|
||
style C fill:#9f9
|
||
style F fill:#f99
|
||
```
|
||
|
||
核心逻辑：`json.Unmarshal` 的签名是 `func Unmarshal(data []byte, v any)`，第二个参数接收 `any` 类型。当传入 `&m` 时，内部通过反射检查到这是一个指向 map 的指针，于是能直接向原 map 写入数据。如果传 `m`，由于 map 本身就是引用类型但不满足 `Settable` 条件（reflect 层面 value 不可取址），写入会静默失败或直接 panic。
|
||
|
||
### 为什么 B 错：map 是引用类型，子函数可以修改父函数
|
||
|
||
```go
|
||
func addElement(m map[string]int) {
|
||
m["newKey"] = 999 // ✅ 直接往原 map 里添加
|
||
}
|
||
|
||
func main() {
|
||
m := make(map[string]int)
|
||
m["a"] = 1
|
||
addElement(m)
|
||
fmt.Println(m) // map[a:1 newKey:999] ← 父函数可见！
|
||
}
|
||
```
|
||
|
||
> [!memory] map 不是"副本"
|
||
> map 变量本质上就是一个指针（准确说是 runtime hmap 的引用）。赋值、传参都是共享同一个底层数据结构。
|
||
|
||
### 对比验证：切片 vs array 的行为差异
|
||
|
||
> [!note] 这个对比帮你彻底分清引用类型和值类型
|
||
>
|
||
> ```go
|
||
> // --- slice：引用类型，子函数内增删改对外可见 ---
|
||
> func modifySlice(s []int) {
|
||
> s[0] = 99 // 修改元素 → 外可见 ✅
|
||
> s = append(s, 100) // append 可能换底层数组 → 外不可见（取决于是否扩容）
|
||
> }
|
||
>
|
||
> // --- array：值类型，子函数拿到完整副本 ---
|
||
> func modifyArray(a [3]int) {
|
||
> a[0] = 99 // 只改了副本 → 外不可见 ❌
|
||
> }
|
||
>
|
||
> func main() {
|
||
> arr := [3]int{1, 2, 3}
|
||
> modifyArray(arr)
|
||
> fmt.Println(arr) // [1 2 3] ← 没变
|
||
>
|
||
> sl := []int{1, 2, 3}
|
||
> modifySlice(sl)
|
||
> fmt.Println(sl) // [99 2 3] ← 变了
|
||
> }
|
||
> ```
|
||
|
||
### C 选项为什么错：delete 可以正常删除
|
||
|
||
```go
|
||
m := map[string]int{"a": 1, "b": 2, "c": 3}
|
||
delete(m, "b") // ✅ 成功删除
|
||
fmt.Println(m) // map[a:1 c:3]
|
||
delete(m, "z") // ✅ key 不存在也没事，不 panic
|
||
```
|
||
|
||
---
|
||
|
||
## 二、由 map 带出：切片的引用语义
|
||
|
||
### 单4 & 多选3：切片与数组的核心区别
|
||
|
||
既然上面提到了切片和 map 一样是引用类型，这里一并梳理清楚。
|
||
|
||
> [!summary] slice header 结构
|
||
|
||
```mermaid
|
||
flowchart LR
|
||
A["slice header"] --> B["pointer → 底层数组首元素"]
|
||
A --> C["len → 当前长度"]
|
||
A --> D["cap → 容量"]
|
||
|
||
E["底层数组 [10 3 4 5 ...]"] -.->|"pointer 指向"| B
|
||
|
||
style A fill:#e1d5e
|
||
```
|
||
|
||
```go
|
||
// 单选题4：切片操作改变底层数组
|
||
arr := [5]int{1, 2, 3, 4, 5}
|
||
slice := arr[1:4] // slice = [2, 3, 4], 底层共享 arr[1..4]
|
||
slice[0] = 10 // slice[0] → arr[1]
|
||
fmt.Println(arr) // [1 10 3 4 5] ✅ 选 B
|
||
```
|
||
|
||
> [!question] 💡 思考
|
||
> 以下代码输出什么？为什么和上一题结果不同？
|
||
|
||
```go
|
||
src := []int{1, 2, 3} // cap = 3
|
||
dst := append(src, 4) // cap 不够，翻倍分配到新底层数组
|
||
src[0] = 99 // 只改 src 的底层
|
||
fmt.Println(dst[0]) // ? → 1（因为 dst 已脱离共享）
|
||
```
|
||
|
||
### 多选题3：数组和切片的四组说法全辨析
|
||
|
||
> [!error] 这道题你全选了 ABCD —— 恭喜答对了，巩固一下记忆：
|
||
|
||
| 说法 | 对错 | 解析 |
|
||
|------|------|------|
|
||
| A. 数组定义时必须指定长度，且长度是类型的一部分 | ✅ | `[5]int` 和 `[6]int` 是**不同类型** |
|
||
| B. 切片定义不需要指定长度，长度运行时动态变化 | ✅ | `[]int` 没有固定大小 |
|
||
| C. 数组作为函数参数传的是副本 | ✅ | 整个数组会被拷贝，代价大 |
|
||
| D. 切片传参传的是 header 副本，但对内容的修改反映到原始切片 | ✅ | 拷贝的是 pointer/len/cap，不改这三个就行 |
|
||
|
||
---
|
||
|
||
## 三、声明方式：new vs make
|
||
|
||
### 单选题1 & 单选题14
|
||
|
||
> [!abstract] new 和 make 是 Go 新手最容易混淆的概念之一
|
||
|
||
```go
|
||
// make — 仅用于 slice / map / channel，返回类型本身
|
||
s := make([]int, 0, 10) // 创建一个 len=0, cap=10 的整型切片 ✅ 单选题2 答案
|
||
m := make(map[string]int) // 初始化一个可用的 map
|
||
ch := make(chan int, 5) // 创建缓冲大小为 5 的 channel
|
||
|
||
// new — 适用于任何类型，返回 *T（指向零值的指针）
|
||
p := new(int) // *int，p 指向 0
|
||
per := new(Person) // *Person，per 指向 Person{} 零值实例 ✅ 单选题14 答案
|
||
```
|
||
|
||
> [!warning] ⭐ 单选题1的经典陷阱
|
||
> `new([]int)` **不是**一个切片，而是一个 `*[]int`（指向 nil 切片的指针）！所以单选题1 选 D 是错误的声明方式。
|
||
|
||
| 维度 | make(T, args) | new(T) |
|
||
|------|---------------|--------|
|
||
| 返回类型 | T 本身 | *T |
|
||
| 适用类型 | 仅限 slice/map/channel | 任意类型 |
|
||
| 初始化 | 完成内部数据结构分配 | 仅分配零值内存 |
|
||
|
||
---
|
||
|
||
## 四、结构体与方法
|
||
|
||
### 单选题7：字段访问语法
|
||
|
||
> [!note] Go 中没有 `->` 运算符
|
||
|
||
```go
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
p := Person{Name: "Alice", Age: 20}
|
||
|
||
p.Name // ✅ 值访问
|
||
pp := &p
|
||
pp.Name // ✅ 指针也直接用 .（编译器自动解引用）
|
||
(*pp).Name // ✅ 手动解引用，等价于上一行
|
||
// pp->Name // ❌ Go 不支持这种语法
|
||
```
|
||
|
||
### 单选题8 & 单选题20 & 单选题21：值接收者 vs 指针接收者
|
||
|
||
> [!memory] 三条铁律
|
||
>
|
||
> 1. **方法需要修改对象 → 必须用指针接收者**
|
||
> 2. **结构体很大 → 优先用指针接收者避免拷贝开销**
|
||
> 3. **同一类型的部分方法用了指针接收者 → 其余方法也应统一用指针**
|
||
|
||
```go
|
||
// 单选题21 原代码解析
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
// 值接收者 — p 是副本，修改不影响原对象
|
||
func (p Person) ChangeName(newName string) {
|
||
p.Name = newName // 只改了副本
|
||
}
|
||
|
||
func main() {
|
||
p := Person{Name: "Alice"}
|
||
p.ChangeName("Bob")
|
||
fmt.Println(p.Name) // Alice ❌ 没有被修改（选 B）
|
||
}
|
||
|
||
// 如果用指针接收者，就会修改原对象
|
||
func (p *Person) SetName(newName string) {
|
||
p.Name = newName // 修改原对象
|
||
}
|
||
|
||
func main() {
|
||
p := Person{Name: "Alice"}
|
||
p.SetName("Bob") // 编译器自动转 (&p).SetName("Bob")
|
||
fmt.Println(p.Name) // Bob ✅
|
||
}
|
||
```
|
||
|
||
> [!question] 💡 单选题8 为什么选 C 是错的？
|
||
> C 说「值接收者在传递参数时效率更高」——这不一定！对于小结构体差别不大，但对于大结构体，值拷贝反而更慢。**值接收者的真正用途是保证方法不修改对象**，而非性能优化。因此 C 是错误的说法。
|
||
|
||
---
|
||
|
||
## 五、接口实现
|
||
|
||
### 单选题9：如何实现一个接口
|
||
|
||
> [!abstract] 鸭子类型（Duck Typing）
|
||
>
|
||
> "如果一个东西走起来像鸭子、叫起来像鸭子，那它就是鸭子。"
|
||
|
||
```go
|
||
type Writer interface {
|
||
Write(data []byte) (n int, err error)
|
||
}
|
||
|
||
// 只需实现接口中的所有方法，无需显式声明 implements
|
||
type MyWriter struct { buf []byte }
|
||
func (w MyWriter) Write(data []byte) (n int, err error) {
|
||
w.buf = append(w.buf, data...)
|
||
return len(data), nil
|
||
}
|
||
|
||
var _ Writer = MyWriter{} // 编译期校验：MyWriter 确实实现了 Writer
|
||
```
|
||
|
||
> [!memory] 一句话口诀
|
||
> **"只需要声明并实现接口中的所有方法 —— 编译器自动完成适配。"**
|
||
>
|
||
> B 错在「部分实现」，A 不完整（还需要「实现」），D 错在接口不能被继承（Go 没有继承概念）。
|
||
|
||
---
|
||
|
||
## 六、标准库用法
|
||
|
||
### 单选题10：JSON 处理
|
||
|
||
```go
|
||
import "encoding/json"
|
||
|
||
data := map[string]int{"a": 1, "b": 2}
|
||
bytes, err := json.Marshal(data) // 序列化
|
||
var result map[string]int
|
||
err = json.Unmarshal(bytes, &result) // 反序列化（注意 &result）
|
||
```
|
||
|
||
> [!tip] 优先使用 `encoding/json` 标准库即可，除非有特殊性能需求才考虑 jsoniter 等第三方包。单选题10 选 A。
|
||
|
||
### 单选题11：格式化输出
|
||
|
||
```go
|
||
fmt.Print("hello") // 无换行
|
||
fmt.Println("hello") // 自动换行
|
||
fmt.Printf("%d %s", 42, "hi") // 格式化输出 ✅ 单选题11 答案
|
||
// fmt.Format() 不存在
|
||
```
|
||
|
||
### 单选题12：读取文件
|
||
|
||
```go
|
||
// ✅ 现代写法（Go 1.16+）
|
||
data, err := os.ReadFile("config.json")
|
||
|
||
// ⚠️ ioutil 已在 Go 1.16 标记废弃
|
||
// data, err := ioutil.ReadFile("config.json") // 旧写法
|
||
```
|
||
|
||
### 单选题13：时间处理
|
||
|
||
```go
|
||
import "time"
|
||
|
||
now := time.Now() // 当前时间
|
||
formatted := now.Format("2006-01-02 15:04:05") // 格式化
|
||
```
|
||
|
||
> [!note] Go 的时间格式固定使用 reference time：`2006-01-02 15:04:05`（即 2006-1-2 15:04:05 MST）
|
||
|
||
---
|
||
|
||
## 七、并发编程
|
||
|
||
### 单选题15：无缓冲 channel 的特点
|
||
|
||
> [!abstract] 无缓冲 channel = 同步通信
|
||
|
||
```go
|
||
ch := make(chan int) // 无缓冲
|
||
|
||
go func() { ch <- 42 }() // 启动发送方
|
||
x := <-ch // 接收方等待 → 收发同时发生 ✅ 单选题15 答案
|
||
|
||
// 如果只有发送方在运行，<-ch 会永久阻塞（goroutine leak）
|
||
```
|
||
|
||
> [!warning] ⭐ 核心概念
|
||
> 无缓冲 channel 的发送和接收**必须同时就绪**，缺一不可。这是一种 goroutine 之间的握手同步机制。
|
||
|
||
### 单选题16：Select 语句
|
||
|
||
```go
|
||
select {
|
||
case msg := <-ch1:
|
||
fmt.Println(msg)
|
||
case ch2 <- data:
|
||
fmt.Println("sent")
|
||
default:
|
||
fmt.Println("none ready") // 都不阻塞时的兜底
|
||
}
|
||
```
|
||
|
||
> [!memory] select = switch for channels
|
||
> 监听多个 channel 操作，哪个准备好了执行哪个；都不就绪且有 default 则立即走 default。单选题16 选 C（监听多个 Channel 操作）。
|
||
|
||
### 单选题17：sync.WaitGroup 确保 goroutine 同步
|
||
|
||
```go
|
||
var wg sync.WaitGroup
|
||
for i := 0; i < 5; i++ {
|
||
wg.Add(1)
|
||
go func(id int) {
|
||
defer wg.Done() // 退出时计数器 -1
|
||
doWork(id)
|
||
}(i)
|
||
}
|
||
wg.Wait() // 阻塞直到所有 goroutine 完成 ✅ 单选题17 答案
|
||
```
|
||
|
||
> [!note] Mutex 更适合保护临界区，Atomic 适合简单计数，Context 适合取消信号传递。WaitGroup 是唯一专门用于「等一组 goroutine 完成」的原语。
|
||
|
||
### 单选题19：RWMutex vs Mutex
|
||
|
||
```mermaid
|
||
flowchart LR
|
||
subgraph Mutex["sync.Mutex"]
|
||
M1["同一时刻只能有\n一个 goroutine\n进入临界区"]
|
||
end
|
||
|
||
subgraph RWMutex["sync.RWMutex"]
|
||
R1["多个读锁\n可同时持有"]
|
||
R2["或一个写锁\n独占访问"]
|
||
end
|
||
|
||
Mutex -->|"读少写多时更高效"| W1
|
||
RWMutex -->|"读多写少时优势明显"| W2
|
||
|
||
style R1 fill:#9f9
|
||
```
|
||
|
||
> [!memory] 一句话区分
|
||
> **Mutex 一人进出，RWMutex 多人同读一人独写。**
|
||
|
||
---
|
||
|
||
## 八、基础语法补遗
|
||
|
||
### 单选题18：取地址运算符
|
||
|
||
```go
|
||
x := 42
|
||
px := &x // & 获取地址 → *int
|
||
fmt.Println(*px) // * 解引用 → 42
|
||
|
||
// 结构体同理
|
||
p := Person{Name: "Alice"}
|
||
pp := &p
|
||
pp.Name // Go 自动解引用（等价于 (*p).Name）
|
||
```
|
||
|
||
> [!memory] Go 中关于地址的两个符号
|
||
>
|
||
> | 符号 | 名称 | 作用 |
|
||
> |------|------|------|
|
||
> | `&` | 取地址符 | `px := &x` |
|
||
> | `*` | 解引用 / 指针类型前缀 | `val := *px`, `var px *int` |
|
||
|
||
### 多选题1：通过指针访问成员变量的方式
|
||
|
||
> [!abstract] 多选题1 全辨析
|
||
|
||
| 选项 | 代码 | 对错 | 解析 |
|
||
|------|------|------|------|
|
||
| A | `p.name` | ✅ | Go 的语法糖，自动解引用 |
|
||
| B | `(&p).name` | ❌ | `p` 已经是变量名，再加 `&` 变成指向指针的指针 |
|
||
| C | `(*p).name` | ✅ | 先解引用拿到结构体，再访问字段 |
|
||
| D | `p->name` | ❌ | Go 没有 `->` 运算符 |
|
||
|
||
> [!note] 注意区分：如果是 `p` 已经是 `*Person` 指针类型，则 `p.name` 和 `(*p).name` 都合法。`&p` 会得到 `**Person`，多了一层无意义间接。
|
||
|
||
---
|
||
|
||
## 错题自测表
|
||
|
||
> [!summary] 遮住右侧，自己检验是否真正理解了
|
||
|
||
| 题目 | 考查点 | ❌ 你的原答案 | ✅ 正确答案 | 关键概念 |
|
||
|------|--------|-------------|------------|---------|
|
||
| 单6 | map 的引用语义 + json.Unmarshal 参数 | B | **A** | Unmarshal 需传地址；map 是引用类型 |
|
||
|
||
---
|
||
|
||
## 高频考点速览
|
||
|
||
> [!tip] 考前快速过一遍
|
||
|
||
| 类别 | 考点 | 一句话口诀 |
|
||
|------|------|-----------|
|
||
| make vs new | make 初始化引用类型，new 分配零值内存 | **"make 建结构，new 清空白"** |
|
||
| slice 共享底层 | 修改切片元素 = 修改原数组对应位置 | **"切片是视图，底层是一家的"** |
|
||
| map 引用语义 | 传 map 不拷贝数据，内外同步可见 | **"map 传指针，改哪都看见"** |
|
||
| json.Unmarshal 参数 | 必须传 `&mapVar` 才能写入 | **"没地址写不进"** |
|
||
| 结构体字段访问 | Go 统一用 `.` | **Go 里没有 `->`** |
|
||
| 值 vs 指针接收者 | 要修改对象必须用指针 | **要改就用指针** |
|
||
| 接口隐式实现 | 实现全部方法即满足 | **鸭子类型，不用 declare** |
|
||
| 无缓冲 channel | 收发必须同时就绪 | **"等你，你等我"** |
|
||
| select | 多路复用 channel 操作 | **"谁先好谁先上"** |
|
||
| WaitGroup | 等待一组 goroutine 完成 | **加 1 → 起任务 → Done → Wait** |
|
||
| RWMutex | 读共享、写独占 | **多人同读，一人独写** |
|
||
| 取地址运算符 | `&` 取地址，`*` 解引用 | **"& 取 *" |
|
||
| ioutil 废弃 | 被 os/io 包取代 | **Go 1.16+ 别再用 ioutil** |
|
||
|
||
---
|
||
|
||
## 关联笔记
|
||
|
||
- [[hzh/EXAM]]
|