Go：基础语法到底怎么学才不会只会写玩具代码

发表于 分类于 本文字数： 5.6k 阅读时长 ≈ 20 分钟
Go 基础语法不能只按 var、if、for、func 分开背，而要放进一个能运行、能校验、能测试的小工具里学。这篇文章围绕一个任务结果汇总 CLI，把变量、分支、循环、函数、错误返回和最小测试串起来。

Go 的基础语法表面上看很少：

  • 变量声明
  • if
  • for
  • switch
  • func

正因为会觉得“语法不多”，基础语法才很容易学偏。

常见过程通常是这样的：

  • 今天看 var
  • 明天看 if
  • 后天看 for range
  • 再过两天写一个 Hello, World

每个语法点单看都不难，但一旦开始写一个稍微完整点的功能，代码马上会暴露出几个问题：

  • 不知道数据该怎么组织
  • 不知道什么时候该返回 error
  • 不知道为什么 Go 对未使用变量这么严格
  • 不知道为什么代码能编译，却统计结果不对
  • 不知道怎么验证这段代码不是“碰巧跑通”

这一篇不按语法词典来讲，而是直接围绕一个实际小功能展开：做一个任务结果汇总工具。

这个工具做的事很简单：

  • 接收一批任务执行结果
  • 解析任务名、状态和耗时
  • 统计成功、失败、跳过数量
  • 找出慢任务
  • 对非法输入给出明确报错

这个场景足够小，但已经能把 Go 基础语法里最该先掌握的东西串起来。

一、这篇文章要解决什么问题

读完这一篇，应该能独立完成下面这些动作：

  • 用 var、:=、const 写出清楚的变量声明
  • 用 if、switch、for 处理一段实际业务流程
  • 把一坨 main 函数逻辑拆成几个小函数
  • 让函数返回业务结果和 error
  • 处理最常见的输入校验问题
  • 用 go test 给核心逻辑补最小测试

如果这些动作都能独立做出来，Go 基础语法就不再只是“知道长什么样”，而是开始能支撑一个真正的小功能。

二、先看最终要做出来的功能

先把目标钉住，不然后面语法一多，学习又会散。

这篇文章最终要做的工具，输入长这样：

1
2
3
4
login,success,120
search,success,80
checkout,failed,310
notify,skipped,0

每一行代表一条任务结果，包含三个字段：

  • 任务名
  • 执行状态
  • 耗时，单位毫秒

最终希望程序输出类似这样：

1
2
3
4
5
6
7
总任务数: 4
成功: 2
失败: 1
跳过: 1
平均耗时: 127.50ms
慢任务:
- checkout 310ms (failed)

如果输入里混入非法内容，例如：

1
broken-line

程序还应该把错误指出来，而不是悄悄吞掉。

这已经不是“玩具打印练习”了，因为它开始涉及：

  • 输入格式
  • 业务规则
  • 统计过程
  • 错误处理
  • 结果验证

三、先从一个最小可运行版本开始

先不要急着写解析和统计，先把最小版本跑起来。

main.go：

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

import "fmt"

func main() {
	rawResults := []string{
		"login,success,120",
		"search,success,80",
		"checkout,failed,310",
	}

	fmt.Println(rawResults)
}

执行：

1
go run main.go

输出：

1
[login,success,120 search,success,80 checkout,failed,310]

这个版本几乎没做事，但已经出现了几层最基础的 Go 结构：

  • package main 表示这是可执行程序入口包
  • import 引入依赖
  • func main() 是程序入口
  • []string 是一组字符串数据

这一步很容易被忽略，注意力也会直接被带到更花的语法上。
其实 Go 入门最稳的方式，恰恰是先把“程序入口 + 数据 + 输出”这条最短路径走通。

四、变量、常量和零值，不要只背语法定义

1. var 和 := 怎么选

Go 最常见的变量声明方式有两种：

1
2
var total int
successCount := 0

它们都能声明变量，但语义不完全一样：

  • var total int 更强调“这里先定义一个明确类型的变量”
  • successCount := 0 更强调“在当前作用域里声明并初始化一个新变量”

在函数内部，大多数局部变量会更常用 :=。
但只要你想让类型、零值和作用域更清楚，var 一样很有价值。

例如：

1
2
3
4
5
6
var total int
var avgDuration float64
var hasFailed bool
var note string

fmt.Println(total, avgDuration, hasFailed, note)

输出：

1
0 0 false

这里最值得注意的是：Go 会给变量一个稳定的零值。

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

这不是小细节，而是很多 Go 代码默认约定的一部分。

2. const 用来固定规则，而不是随手写死数字

例如慢任务阈值：

1
const slowThreshold = 200

后面统计逻辑里就不要再散落一堆 200 了。

把规则提成常量，有两个直接好处：

  • 业务含义更明确
  • 后续改阈值时不会漏改

3. 一个实际错误：把字符串当成数字

错误写法：

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
	duration := "120"
	fmt.Println(duration + 20)
}

这段代码根本编译不过，错误类似：

1
invalid operation: duration + 20 (mismatched types string and untyped int)

Go 在这里一点都不含糊：

  • "120" 是字符串
  • 20 是数字
  • 两者不能混着算

修复写法：

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

import (
	"fmt"
	"strconv"
)

func main() {
	durationText := "120"
	duration, err := strconv.Atoi(durationText)
	if err != nil {
		fmt.Println("invalid duration:", err)
		return
	}

	fmt.Println(duration + 20)
}

输出：

1
140

Go 基础语法学习里很重要的一点就是：类型、转换、错误返回是一整套，不要拆开看。

4. 一个很 Go 的提醒：未使用变量会直接编译失败

第一次碰到这个提示时，通常会不太习惯：

1
2
3
4
5
package main

func main() {
	taskName := "login"
}

报错：

1
declared and not used: taskName

这不是 Go 在故意找麻烦，而是在逼你保持代码整洁：

  • 少留临时变量
  • 少留过期逻辑
  • 少让读代码的人猜这个变量是不是漏用了

这个限制反而有助于更早建立代码卫生习惯。

五、if 和 switch 到底在解决什么问题

1. if 先守住输入边界

在这个任务汇总工具里，最先要守住的是输入合法性。

例如任务名不能为空：

1
2
3
if name == "" {
	return TaskRecord{}, errors.New("task name can not be empty")
}

这类判断不是为了“练一下 if”，而是为了避免后面的统计逻辑建立在脏数据上。

2. switch 处理有限状态会更清楚

任务状态只有几种，switch 往往比连写多个 if 更合适：

1
2
3
4
5
6
7
8
9
10
switch status {
case "success":
	fmt.Println("执行成功")
case "failed":
	fmt.Println("执行失败")
case "skipped":
	fmt.Println("任务跳过")
default:
	fmt.Println("未知状态")
}

这里的价值在于：

  • 状态枚举更完整
  • default 分支更容易被看见
  • 后续新增状态时更容易统一修改

3. 一个实际错误：Go 不会把 int 当成 bool

如果你写过 Python 或 JavaScript，很容易下意识这样写：

1
2
3
if duration {
	fmt.Println("duration exists")
}

Go 会直接报错：

1
non-boolean condition in if statement

原因很简单：

  • duration 是 int
  • if 条件必须是 bool

正确写法应该明确表达你的意图。例如你想表达“耗时大于 0”：

1
2
3
if duration > 0 {
	fmt.Println("duration exists")
}

Go 的这个限制很有价值，因为它逼着你把判断写清楚，而不是依赖隐式真值规则。

六、Go 只有 for，但已经够你写绝大多数基础逻辑

1. 遍历一组现成数据，用 for range

1
2
3
for _, line := range rawResults {
	fmt.Println(line)
}

这里的意思很直接：

  • 遍历 rawResults
  • 每次拿到一条记录 line
  • _ 表示当前不关心索引

2. 需要索引时，用经典 for

1
2
3
for i := 0; i < len(rawResults); i++ {
	fmt.Println(i, rawResults[i])
}

这个写法在需要：

  • 访问前后元素
  • 精确控制索引
  • 做窗口处理

时会更常用。

3. 不知道循环多少次时，for 也能写成 while 风格

Go 没有单独的 while 关键字，但完全可以这样写：

1
2
3
4
5
6
retry := 0

for retry < 3 {
	fmt.Println("retry:", retry)
	retry++
}

所以不要把注意力放在“Go 为什么没有 while”这种表面问题上。
真正要掌握的是：什么时候是遍历已有集合，什么时候是在条件满足前持续重复。

4. 一个实际错误：循环里把结果写进了错误的作用域

看下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
records := []TaskRecord{}

for _, line := range rawResults {
	record, err := parseRecord(line)
	if err != nil {
		continue
	}

	records := append(records, record)
}

fmt.Println(len(records))

这里看起来像是会输出真实数量，实际却可能一直是 0。

问题就在这一行：

1
records := append(records, record)

这里用了 :=，会在循环内部创建一个新的局部 records，把外层变量遮蔽掉。

修复写法：

1
records = append(records, record)

这类问题很典型，因为它说明基础语法真正难的地方，不是背 for 的形状，而是理解作用域和变量声明时机。

七、函数和返回值，才是从玩具代码走向功能代码的开始

如果所有逻辑都堆在 main() 里，很快就会变成这样：

  • 解析输入写在一起
  • 状态判断写在一起
  • 统计逻辑写在一起
  • 输出逻辑写在一起

这种代码短期能跑，长期几乎一定难改、难测、难排查。

所以只要逻辑一超过二三十行，就应该开始拆函数。

1. 先拆一个最小函数

1
2
3
func isSlow(duration int, threshold int) bool {
	return duration >= threshold
}

调用：

1
2
fmt.Println(isSlow(120, 200))
fmt.Println(isSlow(310, 200))

输出：

1
2
false
true

2. 再拆解析函数

对于一条原始记录，最值得单独拆出来的就是解析逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
func parseRecord(line string) (TaskRecord, error) {
	parts := strings.Split(line, ",")
	if len(parts) != 3 {
		return TaskRecord{}, fmt.Errorf("invalid record %q: expected 3 fields", line)
	}

	return TaskRecord{
		Name:     strings.TrimSpace(parts[0]),
		Status:   strings.TrimSpace(parts[1]),
		Duration: 0,
	}, nil
}

这个版本还没有把 Duration 解析完整，但已经在做一件很关键的事：
把“怎么把一行输入变成业务数据”单独收进了一个函数。

3. 一个实际错误：把边界校验留到最后

错误写法通常长这样：

1
2
3
4
5
6
7
8
9
10
func parseRecord(line string) (TaskRecord, error) {
	parts := strings.Split(line, ",")
	duration, _ := strconv.Atoi(parts[2])

	return TaskRecord{
		Name:     parts[0],
		Status:   parts[1],
		Duration: duration,
	}, nil
}

这段代码的问题不少：

  • parts[2] 默认假设输入一定有 3 段，长度不对会直接 panic
  • Atoi 的错误被忽略了
  • 任务名和状态没有做任何校验

更稳的写法不是“先跑起来再说”，而是越靠近输入边界，越早把错误挡住。

八、先给数据一个稳定形状：用最小 struct 承载任务结果

严格来说，struct 的系统理解会在后面的文章里展开。
但在这篇基础语法文章里，至少要先建立一个最朴素的认识：真实代码不能长期靠三个并行变量来传数据。

例如下面这种写法很快就会乱：

1
2
3
name := "login"
status := "success"
duration := 120

如果一条记录要在多个函数之间传来传去，更稳的写法是先给它一个固定形状：

1
2
3
4
5
type TaskRecord struct {
	Name     string
	Status   string
	Duration int
}

这里先不要给它加方法，也不要展开组合和方法集。
这一篇只把它当成一个清楚的数据容器就够了。

它的直接好处是：

  • 字段含义集中在一起
  • 函数签名更清楚
  • 测试里更容易构造输入

九、把前面的基础语法串成第一个可用版本

现在把变量、分支、循环、函数和最小 struct 串起来，先做一个能统计成功失败数量的版本。

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"
	"strings"
)

type TaskRecord struct {
	Name     string
	Status   string
	Duration int
}

func parseRecord(line string) (TaskRecord, error) {
	parts := strings.Split(line, ",")
	if len(parts) != 3 {
		return TaskRecord{}, fmt.Errorf("invalid record %q: expected 3 fields", line)
	}

	return TaskRecord{
		Name:     strings.TrimSpace(parts[0]),
		Status:   strings.TrimSpace(parts[1]),
		Duration: 0,
	}, nil
}

func main() {
	rawResults := []string{
		"login,success,120",
		"search,success,80",
		"checkout,failed,310",
	}

	successCount := 0
	failedCount := 0

	for _, line := range rawResults {
		record, err := parseRecord(line)
		if err != nil {
			fmt.Println("parse error:", err)
			continue
		}

		switch record.Status {
		case "success":
			successCount++
		case "failed":
			failedCount++
		}
	}

	fmt.Println("success:", successCount)
	fmt.Println("failed:", failedCount)
}

这段代码还有明显缺点：

  • Duration 还没真正解析
  • 没统计平均耗时
  • 没收集慢任务
  • 状态枚举还不完整

但它已经比“所有内容全写死在 main()”前进了一大步，因为职责已经开始分开了。

十、输入校验和错误返回，为什么也是 Go 基础语法的一部分

“错误处理”很容易被当成后面再学的高级内容。
但在 Go 里，只要开始写真实功能，错误返回几乎就是基础语法的一部分。

把解析函数补完整：

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
func parseRecord(line string) (TaskRecord, error) {
	parts := strings.Split(line, ",")
	if len(parts) != 3 {
		return TaskRecord{}, fmt.Errorf("invalid record %q: expected 3 fields", line)
	}

	name := strings.TrimSpace(parts[0])
	status := strings.TrimSpace(parts[1])
	durationText := strings.TrimSpace(parts[2])

	if name == "" {
		return TaskRecord{}, errors.New("task name can not be empty")
	}

	switch status {
	case "success", "failed", "skipped":
	default:
		return TaskRecord{}, fmt.Errorf("invalid status %q", status)
	}

	duration, err := strconv.Atoi(durationText)
	if err != nil {
		return TaskRecord{}, fmt.Errorf("invalid duration %q: %w", durationText, err)
	}

	if duration < 0 {
		return TaskRecord{}, fmt.Errorf("duration must be >= 0, got %d", duration)
	}

	return TaskRecord{
		Name:     name,
		Status:   status,
		Duration: duration,
	}, nil
}

这里其实就是在反复应用最基础的语法：

  • 用变量接住中间值
  • 用 if 做边界判断
  • 用 switch 校验有限状态
  • 用多返回值把业务值和错误一起带出去

一个常见误区：不要一出错就 panic

第一版代码最容易写成这样：

1
2
3
if err != nil {
	panic(err)
}

panic 不是不能用，但在这种输入校验场景里通常太猛了。
更稳的做法通常是：

  • 返回 error
  • 由调用方决定是跳过、重试，还是终止程序

这正是 Go 代码里非常重要的一层工程感。

十一、一个真实的小项目版本：批量任务结果汇总工具

下面给出一个可以直接运行的完整版本。

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package main

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

const slowThreshold = 200

type TaskRecord struct {
	Name     string
	Status   string
	Duration int
}

type Summary struct {
	Total         int
	Success       int
	Failed        int
	Skipped       int
	TotalDuration int
	SlowTasks     []TaskRecord
}

func parseRecord(line string) (TaskRecord, error) {
	parts := strings.Split(line, ",")
	if len(parts) != 3 {
		return TaskRecord{}, fmt.Errorf("invalid record %q: expected 3 fields", line)
	}

	name := strings.TrimSpace(parts[0])
	status := strings.TrimSpace(parts[1])
	durationText := strings.TrimSpace(parts[2])

	if name == "" {
		return TaskRecord{}, errors.New("task name can not be empty")
	}

	switch status {
	case "success", "failed", "skipped":
	default:
		return TaskRecord{}, fmt.Errorf("invalid status %q", status)
	}

	duration, err := strconv.Atoi(durationText)
	if err != nil {
		return TaskRecord{}, fmt.Errorf("invalid duration %q: %w", durationText, err)
	}

	if duration < 0 {
		return TaskRecord{}, fmt.Errorf("duration must be >= 0, got %d", duration)
	}

	return TaskRecord{
		Name:     name,
		Status:   status,
		Duration: duration,
	}, nil
}

func loadRecords(lines []string) ([]TaskRecord, []error) {
	records := make([]TaskRecord, 0, len(lines))
	errs := make([]error, 0)

	for _, line := range lines {
		record, err := parseRecord(line)
		if err != nil {
			errs = append(errs, err)
			continue
		}

		records = append(records, record)
	}

	return records, errs
}

func collectSummary(records []TaskRecord, threshold int) Summary {
	var summary Summary

	for _, record := range records {
		summary.Total++
		summary.TotalDuration += record.Duration

		switch record.Status {
		case "success":
			summary.Success++
		case "failed":
			summary.Failed++
		case "skipped":
			summary.Skipped++
		}

		if record.Duration >= threshold {
			summary.SlowTasks = append(summary.SlowTasks, record)
		}
	}

	return summary
}

func averageDuration(summary Summary) float64 {
	if summary.Total == 0 {
		return 0
	}

	return float64(summary.TotalDuration) / float64(summary.Total)
}

func printReport(summary Summary) {
	fmt.Printf("总任务数: %d\n", summary.Total)
	fmt.Printf("成功: %d\n", summary.Success)
	fmt.Printf("失败: %d\n", summary.Failed)
	fmt.Printf("跳过: %d\n", summary.Skipped)
	fmt.Printf("平均耗时: %.2fms\n", averageDuration(summary))

	if len(summary.SlowTasks) == 0 {
		fmt.Println("慢任务: 无")
		return
	}

	fmt.Println("慢任务:")
	for _, task := range summary.SlowTasks {
		fmt.Printf("- %s %dms (%s)\n", task.Name, task.Duration, task.Status)
	}
}

func main() {
	rawResults := []string{
		"login,success,120",
		"search,success,80",
		"checkout,failed,310",
		"notify,skipped,0",
		"broken-line",
	}

	records, errs := loadRecords(rawResults)
	summary := collectSummary(records, slowThreshold)

	printReport(summary)

	if len(errs) > 0 {
		fmt.Println("\n解析失败的输入:")
		for _, err := range errs {
			fmt.Printf("- %v\n", err)
		}
	}
}

如果运行这段代码，输出会类似这样：

1
2
3
4
5
6
7
8
9
10
总任务数: 4
成功: 2
失败: 1
跳过: 1
平均耗时: 127.50ms
慢任务:
- checkout 310ms (failed)

解析失败的输入:
- invalid record "broken-line": expected 3 fields

这一版真正重要的不是代码量，而是它已经具备了“小而完整”的几个关键特征：

  • 有稳定的数据结构
  • 有明确的输入边界
  • 有分层函数
  • 有错误收集
  • 有结果输出

这就是从玩具代码迈向功能代码的第一步。

十二、怎么验证这段 Go 代码不是“看起来能跑”

基础语法文章最容易被学成“我看懂了”。
但真正需要追求的是：我自己能改、能测、能确认行为没变。

最小验证动作至少要有三步。

1. 先手动跑一遍主流程

1
go run main.go

确认几点：

  • 统计数量是否对
  • 平均耗时是否对
  • 慢任务列表是否对
  • 非法输入是否被报告出来

2. 再改一个规则，看代码是不是真的可控

例如把：

1
const slowThreshold = 200

改成：

1
const slowThreshold = 100

然后再跑一次，确认慢任务列表有没有按预期变化。

3. 最后给核心函数补测试

主流程能跑，只说明“这个例子碰巧工作”。
真正让代码开始稳下来的，是能单独验证 parseRecord 和 collectSummary 这些核心函数。

十三、测试示例：给解析和统计逻辑补最小测试

先给 parseRecord 和 collectSummary 各补几条最小测试。

main_test.go：

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 "testing"

func TestParseRecord(t *testing.T) {
	record, err := parseRecord("login,success,120")
	if err != nil {
		t.Fatalf("expected nil error, got %v", err)
	}

	if record.Name != "login" {
		t.Fatalf("unexpected name: %s", record.Name)
	}

	if record.Status != "success" {
		t.Fatalf("unexpected status: %s", record.Status)
	}

	if record.Duration != 120 {
		t.Fatalf("unexpected duration: %d", record.Duration)
	}
}

func TestParseRecordInvalidStatus(t *testing.T) {
	_, err := parseRecord("login,unknown,120")
	if err == nil {
		t.Fatal("expected error, got nil")
	}
}

func TestCollectSummary(t *testing.T) {
	records := []TaskRecord{
		{Name: "login", Status: "success", Duration: 120},
		{Name: "checkout", Status: "failed", Duration: 310},
		{Name: "notify", Status: "skipped", Duration: 0},
	}

	summary := collectSummary(records, 200)

	if summary.Total != 3 {
		t.Fatalf("unexpected total: %d", summary.Total)
	}

	if summary.Success != 1 {
		t.Fatalf("unexpected success: %d", summary.Success)
	}

	if summary.Failed != 1 {
		t.Fatalf("unexpected failed: %d", summary.Failed)
	}

	if summary.Skipped != 1 {
		t.Fatalf("unexpected skipped: %d", summary.Skipped)
	}

	if len(summary.SlowTasks) != 1 {
		t.Fatalf("unexpected slow task count: %d", len(summary.SlowTasks))
	}
}

执行：

1
go test ./...

如果测试通过，输出通常类似：

1
ok  	demo	0.003s

注意，这里的价值不是“会写几个断言”，而是建立一个很重要的习惯：

  • 输入解析单独测
  • 统计规则单独测
  • 主流程问题和核心逻辑问题分开看

这一步一旦建立起来，后面学 Go 的错误处理、项目结构、测试分层都会顺很多。

十四、一个常见排错场景：为什么统计结果一直是 0

来看一个非常典型、也非常基础语法化的问题。

错误代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func loadRecords(lines []string) ([]TaskRecord, []error) {
	records := make([]TaskRecord, 0, len(lines))
	errs := make([]error, 0)

	for _, line := range lines {
		record, err := parseRecord(line)
		if err != nil {
			errs = append(errs, err)
			continue
		}

		records := append(records, record)
	}

	return records, errs
}

现象通常是：

  • 程序没有报错
  • parseRecord 明明也成功了
  • 最后 records 却还是空

根因就是前面提过的作用域遮蔽：

1
records := append(records, record)

这里用 := 新建了一个循环内部的 records，外层那个切片根本没被更新。

修复写法：

1
records = append(records, record)

这个案例很有代表性，因为它说明：

  • 很多“业务结果不对”的根因，其实是基础语法没吃透
  • Go 的变量声明和作用域一旦没搞清楚，代码就很容易看着没问题、结果却不对

十五、几个高频报错应该怎么查

1. declared and not used

说明你声明了变量但没用上。
优先检查：

  • 是不是真的忘记使用
  • 还是旧逻辑删了一半没删干净

2. non-boolean condition in if statement

说明你把 int、string 之类的值直接塞进了 if 条件。
Go 不接受隐式真值，需要写成明确判断，例如：

1
2
3
if duration > 0 {
	...
}

3. panic: runtime error: index out of range

在这篇场景里，最常见原因是：

  • 直接访问 parts[2]
  • 但 strings.Split 后长度不够

排查顺序应该很固定：

  1. 先看报错行
  2. 再看切片长度是否校验过
  3. 再回头看输入格式是不是稳定

4. cannot use "120" (untyped string) as int

说明你把字符串当成数字用。
优先检查：

  • 输入是不是文本
  • 是否做过 strconv.Atoi
  • Atoi 的错误有没有被忽略

5. 没报错但统计结果不对

这类情况最值得先查：

  • := 有没有写成了遮蔽外层变量
  • switch 有没有漏掉某个状态
  • 平均值是不是做了整数除法

结果一不对，第一步常会先怀疑算法。
实际更常见的根因，往往还是变量作用域、分支覆盖和类型转换。

十六、这一篇的边界在哪里

这篇文章虽然已经写到了一个完整小工具，但边界还是要明确。

这一篇重点是：

  • 变量和常量
  • 基础类型和零值
  • if / switch / for
  • 函数拆分
  • 多返回值
  • 最小错误处理
  • 最小测试

这一篇还没有深入展开的内容包括：

  • 数组、切片、map 的底层关系和高频坑
  • 值语义、引用语义、指针
  • struct 的方法集、组合和接口设计
  • defer、panic、recover
  • 并发、channel、context

停在这里不是保守，而是为了先把“能写出一个稳定小功能”的语法地基收住。

十七、一个实际练习

可以直接把这篇的任务结果汇总工具改造成一个更贴近测试开发的小练习。

练习目标：做一个“批量接口检查结果汇总器”。

输入格式改成：

1
2
3
user-login,test,success,120
user-login,prod,failed,240
order-submit,prod,success,180

要求：

  1. 每条记录包含接口名、环境、状态、耗时四个字段
  2. 只统计 prod 环境的结果
  3. 输出成功数、失败数、失败率
  4. 输出耗时超过 200ms 的慢接口
  5. 对非法环境和非法状态返回错误
  6. 至少补 3 条测试

如果这个练习能独立做完，说明你对这一篇最核心的 Go 基础语法已经不是“会看”，而是开始会用。

十八、这篇文章学完以后，下一步应该补什么

如果这一篇已经跟着做完，下一步最适合继续补的是：

  1. 数组、切片、map 到底是什么关系，为什么这么容易踩坑
  2. Go 的值类型、引用语义、指针到底应该怎么理解
  3. struct、方法集和组合，为什么比“面向对象语法”更重要

因为到这一步，基础语法已经够你写小功能了。
接下来真正会频繁卡住你的，通常不是 if 和 for 本身，而是数据结构、内存语义和类型组织。

十九、结语

Go 基础语法不适合按孤立词条去背，而应该放进一个完整的小功能里反复组合。

这一篇真正要掌握的，不是把 var、if、for、switch、func 这些词记住，而是知道：

  • 数据进来时先在哪一层做校验
  • 什么时候该返回 error
  • 什么时候该拆函数
  • 变量应该在哪个作用域里声明
  • 怎么用最小测试确认代码不是碰巧跑通

只要这些组合关系开始清楚，Go 的基础语法就不再只是“学过”，而是已经开始能支撑你写出第一批真正可维护的小工具了。