# 第二章：Go 基础语法 —— 变量、类型与流程控制

> **本章目标**：深入理解 Go 的变量声明机制、核心数据类型、运算符体系及流程控制结构，掌握 Go 独特的"零值"哲学和"类型推断"特性。

## 2.1 Go 的变量声明机制

Go 语言的变量声明方式灵活多样，理解其背后的机制是编写高效代码的基础。

### 2.1.1 四种声明方式

#### 1. `var` 声明（显式类型）

```go
var name string = "Alice"
var age int = 25
var isActive bool = true
```

**深度解析**：
- `var` 是 Go 中**最正式**的声明方式
- 可以省略初始化，此时变量会被赋予**零值**（见 2.2 节）
- 支持在函数内外声明（包级变量和局部变量）

#### 2. `var` 声明（类型推断）

```go
var name = "Bob"      // 编译器推断为 string
var count = 100       // 编译器推断为 int
var ratio = 3.14      // 编译器推断为 float64
```

**深度解析**：
- 当提供初始值时，Go 编译器会自动推断类型
- 这是**推荐**的声明方式，代码更简洁
- 类型一旦推断，不可更改（Go 是静态类型语言）

#### 3. 短变量声明 `:=`（最常用）

```go
name := "Charlie"
age := 30
isValid := true
```

**深度解析**：
- `:=` 是 `var` + 类型推断的**语法糖**
- **只能在函数内部使用**（不能在包级作用域使用）
- 如果变量已存在，会**重新赋值**而非声明新变量
- 可以混合新旧变量：`a, b := 1, 2`（即使 `a` 已存在）

```go
// 错误示例：包级作用域不能使用 :=
package main

// x := 10  // 编译错误！

func main() {
    y := 20  // 正确
}
```

#### 4. 多变量声明

```go
// 显式类型
var (
    name string = "David"
    age  int    = 28
)

// 类型推断
var (
    city  = "Beijing"
    score = 95.5
)

// 短声明
x, y, z := 1, 2, 3
```

**深度解析**：
- 使用 `var ()` 块可以批量声明变量，适合包级变量
- 短声明 `:=` 支持多个变量同时声明
- **注意**：`:=` 左侧至少有一个变量是新的，否则是赋值操作

```go
a, b := 1, 2      // 声明两个新变量
a, c := 3, 4      // a 已存在，c 是新变量（合法）
a, b := 5, 6      // a 和 b 都已存在，编译错误！
```

### 2.1.2 变量作用域

Go 的作用域规则非常清晰：

```go
package main

import "fmt"

// 包级变量（全局作用域）
var globalVar = "I am global"

func main() {
    // 函数级变量
    localVar := "I am local"
    
    if true {
        // 块级变量（if 块内）
        blockVar := "I am in if block"
        fmt.Println(blockVar)
    }
    
    // fmt.Println(blockVar)  // 编译错误！blockVar 在 if 块外不可见
    
    fmt.Println(localVar)
    fmt.Println(globalVar)
}
```

**深度解析**：
- **包级作用域**：在 `package` 声明后，任何函数外声明的变量
- **函数作用域**：在函数内部声明的变量
- **块级作用域**：在 `{}` 代码块内声明的变量（if、for、switch 等）
- 内层作用域可以**遮蔽**外层同名变量

```go
func shadowExample() {
    x := 10
    if true {
        x := 20  // 创建了新变量 x，遮蔽了外层的 x
        fmt.Println(x)  // 输出 20
    }
    fmt.Println(x)  // 输出 10（外层 x 未受影响）
}
```

## 2.2 Go 的"零值"哲学

Go 语言有一个非常优雅的设计：**未初始化的变量会自动获得零值**。

### 2.2.1 零值表

| 类型 | 零值 | 说明 |
|------|------|------|
| `int`, `int8`, `int16`, `int32`, `int64` | `0` | 整数类型 |
| `uint`, `uint8`, `uint16`, `uint32`, `uint64` | `0` | 无符号整数 |
| `float32`, `float64` | `0.0` | 浮点数 |
| `complex64`, `complex128` | `0 + 0i` | 复数 |
| `bool` | `false` | 布尔值 |
| `string` | `""` | 空字符串 |
| 指针、函数、接口、切片、映射、通道 | `nil` | 引用类型 |
| 数组 | 数组元素全为零值 | 值类型 |

### 2.2.2 零值的实际意义

```go
package main

import "fmt"

func main() {
    var intVar int
    var floatVar float64
    var boolVar bool
    var stringVar string
    var ptrVar *int
    
    fmt.Printf("int: %d\n", intVar)       // 0
    fmt.Printf("float: %f\n", floatVar)   // 0.000000
    fmt.Printf("bool: %v\n", boolVar)     // false
    fmt.Printf("string: '%s'\n", stringVar) // ''
    fmt.Printf("ptr: %v\n", ptrVar)       // <nil>
    
    // 零值判断
    if stringVar == "" {
        fmt.Println("字符串为空")
    }
    
    if ptrVar == nil {
        fmt.Println("指针为空")
    }
}
```

**深度解析**：
- 零值机制避免了"未初始化变量"的运行时错误
- 在结构体中，未设置的字段自动为零值
- 这是 Go 语言**安全性**的重要体现

```go
type User struct {
    Name string
    Age  int
    Email string
}

func main() {
    u := User{}  // 所有字段为零值
    fmt.Printf("%+v\n", u)  // {Name: Age:0 Email:}
    
    // 零值判断
    if u.Name == "" {
        fmt.Println("用户未设置名称")
    }
}
```

## 2.3 核心数据类型详解

### 2.3.1 整型（Integer Types）

Go 提供了多种整型，适应不同场景：

```go
var (
    a int8      // 8 位有符号整数，范围：-128 ~ 127
    b int16     // 16 位有符号整数，范围：-32768 ~ 32767
    c int32     // 32 位有符号整数，范围：-2147483648 ~ 2147483647
    d int64     // 64 位有符号整数，范围：-9223372036854775808 ~ 9223372036854775807
    
    e uint8     // 8 位无符号整数，范围：0 ~ 255
    f uint16    // 16 位无符号整数，范围：0 ~ 65535
    g uint32    // 32 位无符号整数，范围：0 ~ 4294967295
    h uint64    // 64 位无符号整数，范围：0 ~ 18446744073709551615
    
    i int       // 平台相关：32 位系统为 int32，64 位系统为 int64
    j uint      // 平台相关：32 位系统为 uint32，64 位系统为 uint64
)
```

**深度解析**：
- `int` 和 `uint` 的大小取决于**平台架构**（32 位或 64 位）
- 优先使用 `int` 和 `int64`，除非有特殊内存优化需求
- `byte` 是 `uint8` 的别名，常用于处理二进制数据
- `rune` 是 `int32` 的别名，用于表示 Unicode 字符

```go
package main

import "fmt"

func main() {
    var b byte = 'A'      // byte 是 uint8 的别名
    var r rune = '中'     // rune 是 int32 的别名，可存储 Unicode 字符
    
    fmt.Printf("byte: %c, %d\n", b, b)  // A, 65
    fmt.Printf("rune: %c, %d\n", r, r)  // 中，20013
    
    // 字节数测试
    fmt.Printf("len('A'): %d\n", len("A"))    // 1
    fmt.Printf("len('中'): %d\n", len("中"))  // 3（UTF-8 编码占 3 字节）
}
```

### 2.3.2 浮点型（Floating-Point Types）

```go
var (
    a float32 = 3.14
    b float64 = 3.141592653589793
)
```

**深度解析**：
- `float64` 是**默认**浮点类型，精度更高
- `float32` 节省内存，适合对精度要求不高的场景（如图形处理）
- 浮点数比较时注意精度问题

```go
package main

import "fmt"
import "math"

func main() {
    a := 0.1 + 0.2
    b := 0.3
    
    fmt.Printf("a == b: %v\n", a == b)  // false（精度问题）
    fmt.Printf("a: %.20f\n", a)         // 0.30000000000000004441
    
    // 正确比较方式
    epsilon := 1e-9
    if math.Abs(a-b) < epsilon {
        fmt.Println("a 和 b 近似相等")
    }
}
```

### 2.3.3 复数类型（Complex Types）

```go
var (
    c1 complex64  = 1 + 2i
    c2 complex128 = 3.5 + 4.5i
)
```

**深度解析**：
- `i` 或 `j` 表示虚部
- 较少使用，主要用于科学计算和信号处理

### 2.3.4 布尔类型（Boolean Type）

```go
var (
    isTrue  bool = true
    isFalse bool = false
)
```

**深度解析**：
- 只有 `true` 和 `false` 两个值
- **不能**与整数互相转换（`0` 不等于 `false`）
- 逻辑运算符：`&&`（与）、`||`（或）、`!`（非）

```go
package main

import "fmt"

func main() {
    a, b := true, false
    
    fmt.Printf("a && b: %v\n", a && b)  // false
    fmt.Printf("a || b: %v\n", a || b)  // true
    fmt.Printf("!a: %v\n", !a)          // false
    
    // 短路求值
    if false && someExpensiveFunction() {
        // someExpensiveFunction() 不会被执行
    }
}
```

### 2.3.5 字符串类型（String Type）

```go
var s1 string = "Hello"
var s2 string = "世界"
var s3 string = `多行
字符串`
```

**深度解析**：
- 字符串是**不可变**的字节序列（UTF-8 编码）
- 使用双引号 `"` 或反引号 `` ` ``
- 反引号表示**原始字符串**，不转义任何字符
- 字符串长度使用 `len()`，但返回的是**字节数**而非字符数

```go
package main

import "fmt"

func main() {
    s := "Hello 世界"
    
    fmt.Printf("len(s): %d\n", len(s))  // 11（字节数）
    fmt.Printf("s[0]: %c\n", s[0])      // H
    // fmt.Printf("s[6]: %c\n", s[6])   // 可能乱码（中文字符占 3 字节）
    
    // 遍历字符串（按 rune）
    for i, r := range s {
        fmt.Printf("位置 %d: 字符 %c (Unicode: %d)\n", i, r, r)
    }
    
    // 字符串拼接
    s1 := "Hello"
    s2 := "World"
    s3 := s1 + " " + s2
    
    // 使用 strings.Builder（高性能拼接）
    var builder strings.Builder
    builder.WriteString("Hello")
    builder.WriteString(" ")
    builder.WriteString("World")
    fmt.Println(builder.String())
}
```

**注意**：需要导入 `strings` 包。

## 2.4 类型转换与类型推断

### 2.4.1 显式类型转换

Go **不支持**隐式类型转换，必须显式转换：

```go
package main

import "fmt"

func main() {
    var a int = 42
    var b float64 = float64(a)  // 显式转换
    var c int = int(b)          // 显式转换
    
    fmt.Printf("a: %d, type: %T\n", a, a)
    fmt.Printf("b: %f, type: %T\n", b, b)
    fmt.Printf("c: %d, type: %T\n", c, c)
    
    // 错误示例：隐式转换（编译错误）
    // var x int = 3.14  // 编译错误！
}
```

**深度解析**：
- 转换必须在**兼容类型**之间进行
- 转换可能导致**精度丢失**或**溢出**
- 使用 `int64(float64)` 转换时注意范围检查

```go
package main

import "fmt"
import "math"

func main() {
    var f float64 = 1.9
    var i int = int(f)  // 截断小数部分，结果为 1
    
    fmt.Printf("int(1.9): %d\n", i)  // 1
    
    // 四舍五入
    i = int(math.Round(f))
    fmt.Printf("round(1.9): %d\n", i)  // 2
    
    // 溢出检查
    var largeFloat float64 = 1e20
    var smallInt int = int(largeFloat)  // 可能溢出
    fmt.Printf("largeFloat -> int: %d\n", smallInt)
}
```

### 2.4.2 类型推断的边界

```go
package main

import "fmt"

func main() {
    // 类型推断
    a := 10           // int
    b := 3.14         // float64
    c := "hello"      // string
    d := true         // bool
    
    // 无法推断（需要显式类型）
    var e  // 编译错误！必须提供类型或初始值
    
    // 混合推断
    f, g, h := 1, 2.5, "test"
    fmt.Printf("f: %T, g: %T, h: %T\n", f, g, h)
}
```

## 2.5 运算符体系

### 2.5.1 算术运算符

```go
a, b := 10, 3

// 加法、减法、乘法、除法、取余
sum := a + b        // 13
diff := a - b       // 7
product := a * b    // 30
quotient := a / b   // 3（整数除法）
remainder := a % b  // 1

// 注意：整数除法会截断小数部分
fmt.Printf("10 / 3 = %d\n", 10/3)  // 3
fmt.Printf("10.0 / 3.0 = %f\n", 10.0/3.0)  // 3.333333
```

### 2.5.2 比较运算符

```go
a, b := 10, 20

// 等于、不等于、大于、小于、大于等于、小于等于
fmt.Println(a == b)  // false
fmt.Println(a != b)  // true
fmt.Println(a > b)   // false
fmt.Println(a < b)   // true
fmt.Println(a >= b)  // false
fmt.Println(a <= b)  // true
```

**注意**：字符串也可以比较（按字典序）：
```go
fmt.Println("apple" < "banana")  // true
```

### 2.5.3 逻辑运算符

```go
a, b := true, false

fmt.Println(a && b)  // false（与）
fmt.Println(a || b)  // true（或）
fmt.Println(!a)      // false（非）
```

**短路求值**：
```go
func expensive() bool {
    fmt.Println("expensive function called")
    return true
}

if false && expensive() {
    // expensive() 不会被调用
}
```

### 2.5.4 位运算符

```go
a, b := 6, 3  // 6 = 110, 3 = 011

fmt.Printf("a & b: %d\n", a & b)    // 2 (010)
fmt.Printf("a | b: %d\n", a | b)    // 7 (111)
fmt.Printf("a ^ b: %d\n", a ^ b)    // 5 (101)
fmt.Printf("a &^ b: %d\n", a &^ b)  // 4 (100) 位清除
fmt.Printf("a << 1: %d\n", a << 1)  // 12 (1100)
fmt.Printf("a >> 1: %d\n", a >> 1)  // 3 (011)
```

### 2.5.5 赋值运算符

```go
a := 10

a += 5   // a = a + 5
a -= 3   // a = a - 3
a *= 2   // a = a * 2
a /= 4   // a = a / 4
a %= 3   // a = a % 3

a &= 1   // a = a & 1
a |= 2   // a = a | 2
a ^= 4   // a = a ^ 4
a <<= 1  // a = a << 1
a >>= 1  // a = a >> 1
```

## 2.6 流程控制

### 2.6.1 if-else 语句

```go
score := 85

if score >= 90 {
    fmt.Println("优秀")
} else if score >= 80 {
    fmt.Println("良好")
} else if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}
```

**深度解析**：
- `if` 条件前可以有一个**简短语句**
- 简短语句的作用域仅限于 `if-else` 块

```go
if x := computeValue(); x > 0 {
    fmt.Println("x 为正数:", x)
} else {
    fmt.Println("x 为非正数:", x)
}
// fmt.Println(x)  // 编译错误！x 在 if 块外不可见
```

### 2.6.2 switch 语句

```go
day := 3

switch day {
case 1:
    fmt.Println("星期一")
case 2:
    fmt.Println("星期二")
case 3, 4, 5:
    fmt.Println("工作日")
case 6, 7:
    fmt.Println("周末")
default:
    fmt.Println("无效日期")
}
```

**深度解析**：
- `switch` 默认包含 `break`，不需要手动写
- 可以使用 `fallthrough` 继续执行下一个 case
- 支持**无表达式**的 switch（类似 if-else 链）

```go
// 多值 case
switch day {
case 1, 2, 3, 4, 5:
    fmt.Println("工作日")
case 6, 7:
    fmt.Println("周末")
}

// fallthrough
switch day {
case 1:
    fmt.Println("星期一")
    fallthrough  // 继续执行 case 2
case 2:
    fmt.Println("星期二（包含星期一）")
}

// 无表达式 switch
switch {
case score >= 90:
    fmt.Println("优秀")
case score >= 80:
    fmt.Println("良好")
default:
    fmt.Println("其他")
}
```

### 2.6.3 for 循环

Go 只有 `for` 一种循环结构，但功能强大：

```go
// 1. 传统 for 循环
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 2. while 风格（省略初始化）
i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

// 3. 无限循环
for {
    // ...
    break  // 必须退出
}

// 4. range 遍历
slice := []int{1, 2, 3, 4, 5}
for index, value := range slice {
    fmt.Printf("索引 %d: 值 %d\n", index, value)
}

// 5. 只遍历索引
for i := range slice {
    fmt.Println(i)
}

// 6. 只遍历值（使用 _ 忽略索引）
for _, v := range slice {
    fmt.Println(v)
}
```

**深度解析**：
- `range` 遍历字符串时，返回的是 **rune（Unicode 字符）** 而非字节
- `for` 循环的初始化语句中的变量，作用域仅限于循环

```go
// 字符串遍历
s := "Hello"
for i, r := range s {
    fmt.Printf("位置 %d: 字符 %c\n", i, r)
}

// 作用域测试
for i := 0; i < 3; i++ {
    fmt.Println(i)
}
// fmt.Println(i)  // 编译错误！i 在循环外不可见
```

### 2.6.4 break 和 continue

```go
// break：跳出当前循环
for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)  // 输出 0-4
}

// continue：跳过本次循环
for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue
    }
    fmt.Println(i)  // 输出 1, 3, 5, 7, 9
}

// 带标签的 break/continue（跳出多层循环）
outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i == 1 && j == 1 {
            break outer  // 跳出外层循环
        }
        fmt.Printf("i=%d, j=%d\n", i, j)
    }
}
```

## 2.7 深度实践：综合案例

### 2.7.1 简易计算器

```go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num1, num2 float64
    var operator string
    
    fmt.Print("请输入第一个数字：")
    fmt.Scan(&num1)
    
    fmt.Print("请输入运算符 (+, -, *, /)：")
    fmt.Scan(&operator)
    
    fmt.Print("请输入第二个数字：")
    fmt.Scan(&num2)
    
    var result float64
    var valid bool
    
    switch operator {
    case "+":
        result = num1 + num2
        valid = true
    case "-":
        result = num1 - num2
        valid = true
    case "*":
        result = num1 * num2
        valid = true
    case "/":
        if num2 == 0 {
            fmt.Println("错误：除数不能为零")
            valid = false
        } else {
            result = num1 / num2
            valid = true
        }
    default:
        fmt.Println("错误：无效的运算符")
        valid = false
    }
    
    if valid {
        fmt.Printf("结果：%.2f %s %.2f = %.2f\n", num1, operator, num2, result)
    }
}
```

### 2.7.2 素数判断

```go
package main

import "fmt"

func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    if n == 2 {
        return true
    }
    if n%2 == 0 {
        return false
    }
    
    // 只需检查到 sqrt(n)
    for i := 3; i*i <= n; i += 2 {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    fmt.Println("1 到 100 之间的素数：")
    count := 0
    for i := 1; i <= 100; i++ {
        if isPrime(i) {
            fmt.Printf("%d ", i)
            count++
            if count%10 == 0 {
                fmt.Println()
            }
        }
    }
    fmt.Printf("\n共 %d 个素数\n", count)
}
```

## 2.8 常见陷阱与最佳实践

### 2.8.1 变量遮蔽陷阱

```go
func shadowBug() {
    x := 10
    if true {
        x := 20  // 创建了新变量，遮蔽了外层 x
        fmt.Println(x)  // 20
    }
    fmt.Println(x)  // 10（外层 x 未变）
    
    // 正确做法：使用 = 赋值
    if true {
        x = 30  // 修改外层 x
        fmt.Println(x)  // 30
    }
    fmt.Println(x)  // 30
}
```

### 2.8.2 整数除法陷阱

```go
// 错误：整数除法
result := 5 / 2  // 结果为 2，而非 2.5

// 正确：使用浮点数
result := 5.0 / 2.0  // 结果为 2.5
// 或
result := float64(5) / float64(2)
```

### 2.8.3 字符串长度陷阱

```go
s := "你好"
fmt.Println(len(s))  // 6（字节数，不是字符数）

// 正确获取字符数
runeCount := len([]rune(s))  // 2
fmt.Println(runeCount)
```

### 2.8.4 最佳实践

1. **优先使用短声明 `:=`**，代码更简洁
2. **利用零值**，减少不必要的初始化
3. **避免变量遮蔽**，保持代码清晰
4. **显式类型转换**，避免精度丢失
5. **使用 `range` 遍历**，避免手动索引
6. **注意字符串编码**，使用 `rune` 处理 Unicode

## 2.9 课后练习

1. **变量声明**：用四种方式声明变量，体会它们的区别
2. **零值测试**：创建各种类型的未初始化变量，观察它们的零值
3. **类型转换**：编写程序测试整数到浮点数的转换，观察精度变化
4. **字符串遍历**：遍历包含中文的字符串，输出每个字符及其 Unicode 码点
5. **素数统计**：统计 1 到 1000 之间的素数个数
6. **综合练习**：编写一个温度转换器（摄氏度 ↔ 华氏度）

## 2.10 下一步

完成本章后，你将进入第三章：**数据结构详解**，深入学习数组、切片、映射和结构体，这是 Go 语言最核心的数据组织方式。

---

**代码仓库位置**：https://giter.top/openclaw/test/tree/main/chapters/chapter-2

**下一章预告**：数组与切片的区别、映射的底层原理、结构体嵌入与组合