go入门学习 on Hobin's Blog

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
 var nickname string = "阿斌"
 city := "上海"

 fmt.Println(age)
 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 输出

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("姓名：")
 fmt.Println(name)
 fmt.Printf("年龄：%d\n", age)
 fmt.Printf("成绩：%.1f\n", score)
}

输出结果：

1
2
3


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

常见错误

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

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，输入异常时程序行为不明确，不利于排查问题。

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)

 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
 var delta int8 = -12

 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)
 fmt.Printf("int8 范围：%d ~ %d\n", math.MinInt8, math.MaxInt8)
}

输出结果：

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
 var price64 float64 = 19.9

 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'
 var chinese rune = '中'

 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: 你(3字节) + 好(3字节) = 6字节

 fmt.Println(text)
 fmt.Printf("len(word)=%d\n", len(word)) // len 返回字节数(byte): 6字节 = 48位(bit)
 fmt.Printf("字符数=%d\n", utf8.RuneCountInString(word)) // RuneCount 返回字符(rune)数量: 2
}

输出结果：

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 字节）

常见错误

用单引号定义字符串，例如 '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
 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，会编译报错。

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 {
 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 表示当前索引对应的元素值。

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

如果你想进一步了解 range 在字符串、map、channel 上的行为，可以查看 range 详解。

常见错误

使用越界索引（例如 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, "阿斌")
 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)
 b[0], b[1] = 10, 20

 base := [5]int{10, 20, 30, 40, 50}
 part := base[1:4]

 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 详解。

切片排序示例

 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 包会导致编译失败。

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)
 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["小王"]
 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，会编译失败。

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 {
 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 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:
 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 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，导致非法输入时没有明确提示。

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
 }
 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)
 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 {
 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 {
 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 {
 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 用反，造成循环结果与预期不一致。

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 {
 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 {
 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(){
 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 {
 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

 fmt.Println(*p)

 *p = 20
 fmt.Println(num)
}

输出结果：

常见错误

把 & 和 * 的含义写反，导致读写逻辑错误。
指针未初始化就解引用，触发运行时错误。
误以为指针是“引用类型”本身，忽略了传参时仍然是值拷贝。

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
 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"`
 Age int `json:"age"`
}

func main() {
 student := Student{
 Name: "阿斌",
 Age: 21,
 }

 byteData, _ := json.Marshal(student)
 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:"-"`
}

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 会过滤空字符串之外的所有“无效值”，实际按类型零值规则判断。

defer

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

defer（关键字）

它是做什么的

defer 用于注册“延迟执行”的函数调用。
这些调用会在当前函数即将返回前执行，常用于资源清理（如关闭文件、解锁、释放连接）。

语法/规则

defer 语句会先登记，等函数返回前再执行。
一个函数内有多个 defer 时，执行顺序是后进先出（LIFO）。
defer 调用中的参数在“登记 defer 的那一刻”就会求值。
defer 常与 return、错误处理一起使用，保证清理逻辑稳定执行。

多个 defer 执行顺序示例

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


package main

import "fmt"

func Func() {
 defer fmt.Println("defer2")
 fmt.Println("func")
 defer fmt.Println("defer1")
}

func main() {
 defer fmt.Println("defer4")
 Func()
 defer fmt.Println("defer3")
}

输出结果：

1
2
3
4
5


func
defer1
defer2
defer3
defer4

从栈角度理解 defer

理解这个示例的关键是：
每个函数调用帧都有自己的 defer 栈，互不干扰。
谁先返回，就先清空谁自己的 defer 栈（后进先出）。

为了便于观察，下面把栈都写成“栈顶 -> 栈底”。

逐行 + 栈变化（核心示例）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func Func() {
 defer fmt.Println("defer2")
 fmt.Println("func")
 defer fmt.Println("defer1")
}

func main() {
 defer fmt.Println("defer4")
 Func()
 defer fmt.Println("defer3")
}

步骤拆解如下（栈写法：栈顶 -> 栈底）：

进入 main，执行 defer fmt.Println("defer4")。
main 栈：[defer4]
Func 栈：[]
当前输出：无
调用 Func()，进入 Func 后执行 defer fmt.Println("defer2")。
main 栈：[defer4]
Func 栈：[defer2]
当前输出：无
执行 fmt.Println("func")。
main 栈：[defer4]
Func 栈：[defer2]
当前输出：func
执行 defer fmt.Println("defer1")。
main 栈：[defer4]
Func 栈：[defer1, defer2]
当前输出：func
Func 返回，开始弹出 Func 的 defer 栈（后进先出）。
先执行 defer1，再执行 defer2。
main 栈：[defer4]
Func 栈：[]
当前输出：func -> defer1 -> defer2
回到 main，执行 defer fmt.Println("defer3")。
main 栈：[defer3, defer4]
Func 栈：[]
当前输出：func -> defer1 -> defer2
main 返回，开始弹出 main 的 defer 栈（后进先出）。
先执行 defer3，再执行 defer4。
main 栈：[]
Func 栈：[]
当前输出：func -> defer1 -> defer2 -> defer3 -> defer4

最终输出就是：

1
2
3
4
5


func
defer1
defer2
defer3
defer4

你可以记一句话：
defer 语句只是入栈，函数返回时才出栈执行；同一函数内严格后进先出。

参数求值时机示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 value := 1
 defer fmt.Println("defer value:", value)

 value = 2
 fmt.Println("current value:", value)
}

输出结果：

1
2


current value: 2
defer value: 1

参数求值流程分解

defer fmt.Println("defer value:", value) 里的 value，在声明 defer 那一刻就被确定为 1。
所以后面即使把 value 改成 2，延迟调用里仍然打印的是当时保存的值。

用“栈”来理解就是：
defer 入栈时，调用参数已经打包好放进栈节点里了，不会等到出栈时再重新取最新变量值。

常见错误

误以为多个 defer 按书写顺序执行，实际是后写先执行。
误以为 defer 参数在函数结束时才求值，实际在声明时就求值。
在循环里大量使用 defer 却不关注性能和释放时机，可能造成资源堆积。
把不同函数作用域的 defer 执行顺序混在一起判断，导致输出顺序理解错误。

init

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

init（特殊函数）

它是做什么的

init() 是 Go 的特殊函数，主要用于程序启动前的初始化逻辑。
它会在 main() 执行前自动执行。

语法/规则

init 不能被手动调用，会在程序启动阶段自动执行。
init 不能有参数，也不能有返回值。
一个 Go 文件里可以定义多个 init 函数。
在同一个文件中，多个 init 按出现顺序执行（谁写在前面谁先执行）。
init 通常用于初始化配置、连接、缓存等准备工作。

多个 init 执行顺序示例

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


package main

import "fmt"

func init() {
 fmt.Println("init1")
}

func init() {
 fmt.Println("init2")
}

func init() {
 fmt.Println("init3")
}

func main() {
 fmt.Println("main")
}

输出结果：

1
2
3
4


init1
init2
init3
main

常见错误

在代码中直接调用 init()，会编译报错。
给 init 添加参数或返回值，会编译报错。
误以为所有文件里的 init 都能严格按“视觉顺序”控制，跨文件时不应依赖这种顺序。

make

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

make（内建函数）

它是做什么的

make 用于初始化并返回 slice、map、channel。
这三种类型都依赖运行时结构，通常需要先 make 才能直接使用。

基本写法

1
2
3


s := make([]int, 2, 4) // 切片：长度 2，容量 4
m := make(map[string]int) // map：可直接写入键值
ch := make(chan int, 2) // channel：缓冲区大小 2

参数含义

第一个参数是要创建的类型（仅支持 slice、map、channel）。
后续参数表示长度、容量或缓冲区大小，具体含义取决于类型。
make 返回的是“可直接使用的值”，而不是指针。

结合切片的示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 b := make([]int, 2, 4)
 b[0], b[1] = 10, 20

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

初学者容易踩坑

把 make 当成关键字；实际上它是内建函数。
尝试用 make 创建数组（如 make([3]int, 3)）会编译失败。
make([]int, n) 创建出的切片长度已经是 n，不是空切片。

range

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

range（关键字）

它是做什么的

range 用于“遍历集合类型”的元素，常配合 for 使用。
你会在数组、切片、字符串、map、channel 上看到它。

基本写法

1
2
3


for index, value := range data {
 // 使用 index 和 value
}

如果你只关心其中一个值，可以这样写：

1
2
3
4
5
6
7


for index := range data {
 // 只要索引/键
}

for _, value := range data {
 // 只要值，索引/键用 "_" 忽略
}

在不同类型上的返回值

数组/切片：返回 索引(index) 和 元素值(value)。
字符串：返回 字节下标(index) 和 字符的 rune 值(value)。
map：返回 键(key) 和 值(value)。
channel：每次返回一个接收到的值（只写一个变量更常见）。

结合数组的示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

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

 for i, v := range letters {
 fmt.Printf("index=%d value=%s\n", i, v)
 }
}

初学者容易踩坑

不想用索引时直接省略变量名会语法错误，应使用 _ 占位。
遍历 map 时顺序是不固定的，不能依赖顺序写业务逻辑。
看到字符串的 range 返回值时，误以为 value 是 string；实际上它是 rune。

关键字索引

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

关键字索引

当你在章节里看到不熟悉的关键字时，可以先从这里快速跳转，再回到原章节继续学习。

名称	一句话说明	详情
`range`	用于遍历数组、切片、字符串、map、channel	查看

函数索引

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

函数索引

当你在章节里看到不熟悉的函数时，可以先从这里快速跳转，再回到原章节继续学习。

名称	一句话说明	详情
`make`	初始化并返回 `slice`、`map`、`channel`	查看
`init`	程序启动前自动执行的特殊初始化函数	查看
`defer`	注册延迟调用，函数返回前执行，常用于清理资源	查看

需要查关键字时，可前往关键字索引。