3.Go 关键字与标识符

背景与动机#

Go 的语法看起来很少，但“少”不等于“随便写”。关键字和标识符是 Go 词法层最基础的两类 token：关键字决定语言结构，标识符负责给变量、函数、类型、包等程序实体命名。

学习这个主题的重点，不是死记 25 个关键字，而是搞清楚三件事：

哪些单词是语言保留字，绝对不能拿来当名字。
哪些名字虽然不是关键字，但有特殊语义，比如 _、init、nil、true。
一个合法标识符不仅要“能写出来”，还要符合 Go 的可见性和命名约定。

核心原理拆解#

1. 关键字是什么：语法保留字，不参与命名#

Go 规范里，关键字是语言保留字，不能作为标识符使用。Go 一共 25 个关键字：

1
break    default    func       interface    select
2
case     defer      go         map          struct
3
chan     else       goto       package      switch
4
const    fallthrough if        range        type
5
continue for        import     return       var

这些词的本质是“语法角色”，不是“普通名字”。例如：

func 用来声明函数
var 用来声明变量
go 用来启动 goroutine
defer 用来注册延迟执行
chan 用来声明 channel 类型

也正因为它们承担的是语法职责，所以不能被重新定义成变量名、函数名或类型名。

2. 标识符是什么：给程序实体命名的名字#

标识符是变量名、函数名、类型名、包名、常量名、字段名这些“名字”的统一概念。

Go 规范对标识符的基本要求是：

由字母、数字和下划线等组成
第一个字符必须是字母或下划线
不能直接以数字开头
不能与关键字重名

例如下面这些是合法标识符：

1
name
2
_age
3
value1
4
Reader

下面这些不合法：

1
1name    // 不能数字开头
2
func     // 关键字
3
go       // 关键字
4
user-name // 连字符不是合法组成部分

3. 关键字、预声明标识符、普通标识符不是一回事#

很多初学者会把 int、string、nil、true 也当成关键字，这是一个常见误区。

它们不是关键字，而是预声明标识符。也就是 Go 在 universe block 里预先提供的一批名字，例如：

类型：int、string、bool、error、any
常量：true、false、iota
零值标识：nil
函数：len、cap、make、new、append、close

这类名字和关键字的差别在于：

关键字是语法保留字，不能被重新声明
预声明标识符本质上仍然是标识符，可以被遮蔽，但通常不建议

图意：这张图具体说明 关键字、预声明标识符 和 普通用户标识符 如何分层区分，重点看左侧 go/defer/chan 这类词属于语法保留字、中间 int/nil/len 属于预先声明的名字，最后理解不是所有“看起来很特殊”的词都是关键字。

例如：

1
var len = 10
2
fmt.Println(len)

这在语法上是合法的，但会遮蔽内建函数 len，可读性通常很差。

4. 25 个关键字可以按职责理解，不必死背#

声明相关#

1
package import const var type func

这些关键字负责把包、依赖、常量、变量、类型、函数引入程序结构。

流程控制相关#

1
if else for range switch case default break continue fallthrough goto return

这组关键字决定程序怎么分支、循环、跳转和返回。

复合类型与并发相关#

1
struct interface map chan go defer select

这组关键字更体现 Go 的语言特征：

struct：组合数据
interface：抽象行为
map：哈希映射
chan：通道类型
go：启动并发执行
defer：延迟调用
select：多路通信选择

这样记忆比单纯背表更稳，因为它和语言设计意图直接对应。

5. 标识符的可见性：首字母大写不是风格问题，而是导出规则#

Go 最重要的命名语义之一是“大小写决定导出性”。

首字母大写：导出，可被其他包访问
首字母小写：未导出，仅包内可见

例如：

1
type User struct {
2
  Name string
3
  age  int
4
}

这里：

User 可导出
Name 可导出
age 不可导出

这不是编码约定而已，而是语言层面的访问控制机制。

6. `_` 是特殊标识符，但不是普通变量名#

下划线 _ 叫 blank identifier，中文常说“空白标识符”。

它的特点是：

看起来像标识符
可以出现在赋值、导入、声明位置
但它不会绑定一个可用名字

例如：

1
v, _ := strconv.Atoi("42")

这里 _ 的作用是“我明确忽略这个值”。

它适合解决两个问题：

临时丢弃不需要的返回值
占位，满足语法要求

但如果把 _ 用成习惯性掩盖错误的工具，就会让程序质量下降。

7. `init` 和 `main` 很特殊，但它们不是关键字#

init 和 main 很重要，但它们都不是关键字。

main 是 package main 中的程序入口函数名
init 是包初始化函数名

它们特殊，是因为 Go 工具链对这些名字有约定用途，不是因为它们进入了关键字列表。

这点很重要，因为它说明：

“关键字”是词法层保留字
“特殊名字”可能只是语义层约定名

8. 命名不仅要合法，还要符合 Go 风格#

Go 对标识符的风格偏好很明确：

多单词名称通常用 MixedCaps / camelCase
不推荐大量使用下划线风格
包名通常短、小写、语义直接
不要把类型信息塞进变量名里

例如更 Go 风格的是：

1
userName
2
httpServer
3
NewClient

而不是：

1
user_name
2
http_server_obj
3
Get_User_Name

最小可运行代码示例#

下面这个例子同时展示关键字、普通标识符、导出标识符和空白标识符的基本用法：

1
package main
2

3
import (
4
  "fmt"
5
  "strconv"
6
)
7

8
// User 是一个可导出的类型名。
9
type User struct {
10
  Name string
11
  age  int
12
}
13

14
func main() {
15
  user := User{Name: "Tom", age: 18}
16

17
  // if、:=、var、return 等都依赖关键字和标识符共同构成语法。
18
  if n, err := strconv.Atoi("123"); err == nil {
19
    fmt.Println(user.Name, n)
20
    return
21
  }
22

23
  // _ 用于明确忽略不需要的值。
24
  _, _ = strconv.Atoi("456")
25
}

这个例子里可以观察到：

package、import、type、func、if、return 是关键字
User、Name、user、n、err 是标识符
User、Name 首字母大写，因此具备导出语义
_ 是特殊标识符，用于忽略值

常见陷阱与错误示例#

1. 把关键字当成变量名或函数名#

错误示例：

1
var go = 1
2
var defer = 2
3
func type() {}

这些都会直接语法报错，因为关键字不能作为标识符使用。

2. 把 `int`、`string`、`nil` 当成关键字理解#

这会导致概念混乱。它们是预声明标识符，不是关键字。虽然语法上可能被遮蔽，但通常不应该这样做。

不推荐示例：

1
var string = "hello"
2
var error = fmt.Errorf("x")

虽然部分场景语法可过，但会严重破坏可读性。

3. 误以为首字母大写只是编码风格#

错误理解：

1
type user struct {}

如果你希望其他包能访问它，这样写就不行，因为 user 未导出。Go 的大小写不是“审美差异”，而是包级可见性规则。

4. 滥用 `_` 掩盖错误#

错误示例：

1
n, _ := strconv.Atoi(input)
2
fmt.Println(n)

如果输入非法，错误会被直接吞掉，程序行为可能悄悄出问题。_ 应该用于“这个值确实不重要”，而不是“先别管错误”。

5. 使用不符合 Go 风格的命名#

例如：

1
var user_name string
2
func Get_User_Name() string { return "" }

它们未必语法错误，但不符合 Go 社区的常见约定，阅读成本高，也和标准库风格不一致。

性能影响或设计取舍#

1. 关键字数量少，是 Go 语法简化的一部分#

Go 只有 25 个关键字，这种克制带来的好处是：

词法规则简单
语法更容易学习和实现
工具链更容易分析源码

代价是很多语义不会靠大量关键字展开，而是靠固定组合和上下文表达。

2. 用大小写控制导出性，减少额外访问控制语法#

Go 没有 public、private、protected 这类关键字，而是直接用首字母大小写表达包外可见性。

好处：

规则简单
一眼就能看出 API 边界
工具和人都容易识别

代价：

命名同时承担“语义表达”和“访问控制”双重职责
改名可能不只是风格调整，还会改变可见性

3. 允许遮蔽预声明标识符，灵活但容易制造坑#

例如可以写：

1
var len = 3

设计上更自由，但工程实践里通常不推荐，因为它会让读代码的人以为你在调用内建函数，结果实际上是在访问局部变量。

4. `_` 提供了语法便利，但也降低了错误暴露率#

空白标识符让“忽略值”变得方便，这对多返回值语言很实用；但如果团队把它当成逃避错误处理的捷径，就会牺牲程序可靠性。

面试高频问题#

1. Go 一共有多少个关键字#

Go 一共有 25 个关键字。它们是语法保留字，不能作为标识符使用。

2. `int`、`string`、`nil`、`true` 是不是关键字#

不是。它们属于预声明标识符，不是关键字。关键字绝对不能拿来命名，而预声明标识符理论上可以被遮蔽，但通常不建议。

3. Go 里标识符的导出规则是什么#

首字母是 Unicode 大写字母，并且该名字处于包级声明、字段名或方法名位置时，就是导出的；否则就是未导出的。

4. `_` 是什么，有什么作用#

_ 是空白标识符。它是一个特殊占位符，用来显式忽略值，不引入新的名字绑定，常见于多返回值赋值、未使用导入占位等场景。

5. `main` 和 `init` 是关键字吗#

不是。它们是有特殊语义的约定名字。main 是可执行程序入口函数名，init 是包初始化函数名，但二者都不属于 Go 的 25 个关键字。

6. 为什么说 Go 的大小写不只是风格问题#

因为 Go 用首字母大小写直接决定标识符是否可导出。大写意味着包外可访问，小写意味着仅包内可见，这是语言级别的可见性规则。

一句话总结#

Go 的关键字只有 25 个，它们负责构成语法；而标识符负责命名程序实体，真正要掌握的是区分“保留字、预声明标识符、普通名字”三层概念，并理解大小写导出规则和 _ 这类特殊标识符的真实语义。

音乐

背景与动机#

核心原理拆解#

1. 关键字是什么：语法保留字，不参与命名#

2. 标识符是什么：给程序实体命名的名字#

3. 关键字、预声明标识符、普通标识符不是一回事#

4. 25 个关键字可以按职责理解，不必死背#

声明相关#

流程控制相关#

复合类型与并发相关#

5. 标识符的可见性：首字母大写不是风格问题，而是导出规则#

6. `_` 是特殊标识符，但不是普通变量名#

7. `init` 和 `main` 很特殊，但它们不是关键字#

8. 命名不仅要合法，还要符合 Go 风格#

最小可运行代码示例#

常见陷阱与错误示例#

1. 把关键字当成变量名或函数名#

2. 把 `int`、`string`、`nil` 当成关键字理解#

3. 误以为首字母大写只是编码风格#

4. 滥用 `_` 掩盖错误#

5. 使用不符合 Go 风格的命名#

性能影响或设计取舍#

1. 关键字数量少，是 Go 语法简化的一部分#

2. 用大小写控制导出性，减少额外访问控制语法#

3. 允许遮蔽预声明标识符，灵活但容易制造坑#

4. `_` 提供了语法便利，但也降低了错误暴露率#

面试高频问题#

1. Go 一共有多少个关键字#

2. `int`、`string`、`nil`、`true` 是不是关键字#

3. Go 里标识符的导出规则是什么#

4. `_` 是什么，有什么作用#

5. `main` 和 `init` 是关键字吗#

6. 为什么说 Go 的大小写不只是风格问题#

一句话总结#

文章目录

音乐

3.Go 关键字与标识符

背景与动机#

核心原理拆解#

1. 关键字是什么：语法保留字，不参与命名#

2. 标识符是什么：给程序实体命名的名字#

3. 关键字、预声明标识符、普通标识符不是一回事#

4. 25 个关键字可以按职责理解，不必死背#

声明相关#

流程控制相关#

复合类型与并发相关#

5. 标识符的可见性：首字母大写不是风格问题，而是导出规则#

6. _ 是特殊标识符，但不是普通变量名#

7. init 和 main 很特殊，但它们不是关键字#

8. 命名不仅要合法，还要符合 Go 风格#

最小可运行代码示例#

常见陷阱与错误示例#

1. 把关键字当成变量名或函数名#

2. 把 int、string、nil 当成关键字理解#

3. 误以为首字母大写只是编码风格#

4. 滥用 _ 掩盖错误#

5. 使用不符合 Go 风格的命名#

性能影响或设计取舍#

1. 关键字数量少，是 Go 语法简化的一部分#

2. 用大小写控制导出性，减少额外访问控制语法#

3. 允许遮蔽预声明标识符，灵活但容易制造坑#

4. _ 提供了语法便利，但也降低了错误暴露率#

面试高频问题#

1. Go 一共有多少个关键字#

2. int、string、nil、true 是不是关键字#

3. Go 里标识符的导出规则是什么#

4. _ 是什么，有什么作用#

5. main 和 init 是关键字吗#

6. 为什么说 Go 的大小写不只是风格问题#

一句话总结#

文章目录

6. `_` 是特殊标识符，但不是普通变量名#

7. `init` 和 `main` 很特殊，但它们不是关键字#

2. 把 `int`、`string`、`nil` 当成关键字理解#

4. 滥用 `_` 掩盖错误#

4. `_` 提供了语法便利，但也降低了错误暴露率#

2. `int`、`string`、`nil`、`true` 是不是关键字#

4. `_` 是什么，有什么作用#

5. `main` 和 `init` 是关键字吗#