几条必须记住的规则#

1. 局部变量声明了就必须使用，否则编译直接报错：

1
declared and not used: name

这一点和很多语言不一样，Go 编译器非常严格，不存在”先声明留着以后用”的说法。

2. 全局变量不能使用短声明。 函数外的变量必须用 var 或 const：

1
// 全局变量不能使用短声明
2
var age = 12

3. 常量声明时必须赋值。 我原来的注释写的是”常量声明后必须赋值”，这个表述不够准确——准确说是声明的同时就必须初始化，不能先声明再赋值，而且常量一旦定义就不能修改：

1
const Version = "2.2"

4. 多变量声明有两种方式：

1
// 方式1：一行声明多个
2
var a1, a2 = 1, 2
3

4
// 方式2：括号分组声明
5
var (
6
  a3 int = 1
7
  a4 int = 2
8
)

跨包访问：首字母大小写决定可见性#

这一点让我印象很深。我在 version 包里定义了两个常量：

1
package version
2

3
const Version = "2.3"
4
const mirai = "mirai"

在 main 包里：

1
fmt.Println(version.Version) // 正常输出 2.3
2
// fmt.Println(version.mirai) // 编译错误！

首字母大写的标识符才能被其他包访问（导出），小写开头的只能在包内部使用。 Go 没有 public/private 关键字，大小写本身就是访问控制规则。

Println、Printf、Sprintf 的区别#

1
// Println 自动换行，多个参数之间自动加空格
2
fmt.Println("hello", "你好") // 输出: hello 你好
3

4
// Printf 格式化输出，不自动换行，需要手动加 \n
5
fmt.Printf("%s hello \n", "mirai")
6

7
// Sprintf 不打印，返回格式化后的字符串
8
var f1 = fmt.Sprintf("%.2f\n", 3.14)

常用格式化动词#

这里要纠正我注释里的一个错误：我当时把格式化动词写成了 \s、\d、\f，这是错的。Go 的格式化动词以 % 开头，反斜杠 \ 是转义字符用的（比如 \n 换行）。代码里我写的是对的，注释记错了。

我注释里把 %v 比作 TypeScript 的 any，这个类比帮助我理解了”什么类型都能接收”。不过严格来说 %v 不是类型，而是”按默认格式输出任意值”的动词。

%v 和 %#v 的区别在空字符串上特别明显：

1
fmt.Printf("%v\n", "")  // 输出一行空白（什么都看不见）
2
fmt.Printf("%#v\n", "") // 输出: ""（能看到是个空字符串）

调试空字符串、带空格的字符串时，%#v 很有用。

fmt.Scan 读取输入#

1
var age int
2
n, err := fmt.Scan(&age)
3
fmt.Println(n, err, age)

注意传的是 &age（变量的地址），Scan 才能把值写进去。它返回两个值：n 是成功读取的参数个数，err 是错误信息。我输入 18 后输出：

1
1 <nil> 18

1 表示成功读到一个值，<nil> 表示没有错误（Go 里 nil 相当于其他语言的 null）。

整型#

1
var u8 uint = 255
2
var i8 int8 = 127

这里要纠正注释里的一个理解错误：我原来写的是”uint 无符号的int8”，这是不对的。

• uint 是平台相关大小的无符号整型：32 位平台是 32 位，64 位平台是 64 位。
• 范围 0 ~ 255 的是 uint8（8 位无符号整型），不是 uint。

int8 的范围是 -128 ~ 127，这个注释是对的。给 int8 赋 128 会直接编译溢出报错。

浮点型#

浮点型只有 float32 和 float64。用 := 或省略类型声明时，浮点数字面量默认推断为 float64。从上面 %T 的输出 float64 string 也能验证这一点。

字符：byte 和 rune#

Go 里字符分两种处理方式：

1
// 单字节字符：byte 处理 ASCII
2
var a byte = 'a'
3
fmt.Printf("%c %d\n", a, a) // 输出: a 97
4

5
// 多字节字符：rune 处理 Unicode
6
var z rune = '中'
7
fmt.Printf("%c %d\n", z, z) // 输出: 中 20013

（注释里的”ASCLL”是拼写错误，应为 ASCII。）

几个要点：

• 字符用单引号 ''，字符串用双引号 "" 或反引号（反引号原样输出，不解析转义字符）。
• %c 按字符打印，%d 打印对应的编码值。'a' 的 ASCII 码是 97，'中' 的 Unicode 码点是 20013。
• 有意思的是，即使声明为 int 类型，%c 也会按字符打印：

1
var a1 int = 97
2
fmt.Printf("%c %d\n", a1, a1) // 输出: a 97

说明 %c 看的是数值对应的码点，不限制具体整型。

布尔型与零值#

• 布尔型只有 true 和 false 两个值，零值（默认值）是 false。
• 不允许把整型强制转换为布尔型，也不能参与数值运算。这点和 C/JavaScript 很不一样，Go 里写 if 1 {} 是编译错误。

零值是个重要概念：变量只声明不赋值时，会自动得到对应类型的零值——数值类型是 0，字符串是 ""，布尔是 false。

切片排序#

标准库 sort 提供了现成的排序功能：

1
var list = []int{4, 1, 3, 2}
2

3
sort.Ints(list)
4
fmt.Println(list) // [1 2 3 4] 升序
5

6
sort.Sort(sort.Reverse(sort.IntSlice(list)))
7
fmt.Println(list) // [4 3 2 1] 降序

• sort.Ints 直接对 int 切片升序排序。
• 降序麻烦一点：sort.IntSlice(list) 把切片包装成可排序接口，sort.Reverse 反转排序方向，最后交给 sort.Sort 执行。
• 排序是原地修改的，不需要接收返回值。