3. Go 基础语法：变量与常量、基本数据类型、零值机制、类型推断、短变量声明、格式化输出

本章是 Go 工程落地的语法基石。Go 语言在设计上追求简洁、明确与高效，其变量与常量的声明体系、严格的类型系统、自动初始化的零值机制以及便捷的类型推断，共同构成了编写可维护、高性能 Go 代码的基础。掌握这些核心语法细节，是后续理解内存布局、并发模型和工程化实践的前提。

3.1 变量声明与初始化

Go 是静态类型语言，变量声明必须明确类型或由编译器推断。Go 提供了多种声明方式以适应不同场景，从显式声明到极简的短变量声明，每种方式都有其明确的适用边界。

3.1.1 标准变量声明

使用 var 关键字声明变量，类型放在变量名之后，这是 Go 语法的一个显著特点。

var name string
var age int
var isActive bool

可以在声明时同时初始化：

var name string = "Go工程"
var count int = 100

也可以同时声明多个同类型变量：

var x, y int = 10, 20

3.1.2 短变量声明

在函数内部，可以使用 := 短变量声明语法，这是 Go 中最常用的声明方式。它同时完成声明和初始化，并由编译器自动推断类型。

func main() {
    name := "Go工程"
    count := 100
    x, y := 10, 20
}

3.2 基本数据类型

Go 提供了丰富的基本数据类型，分为四大类：布尔型、数值型、字符串型和派生类型。理解每种类型的字节大小和默认行为对内存优化至关重要。

3.3 零值机制

Go 语言的一个关键设计是零值机制：当变量被声明但没有显式初始化时，Go 会自动为其分配对应类型的零值。这一机制消除了许多其他语言中常见的“未初始化变量”错误，使代码更加安全。

var (
    a int       // 0
    b float64   // 0.0
    c bool      // false
    d string    // ""
    e [3]int    // [0, 0, 0]
    f *int      // nil
    g []int     // nil
    h map[int]string // nil
)

3.4 类型推断

Go 编译器能够根据赋值表达式右侧的值自动推断变量类型。这减少了冗余的类型声明，同时保持了静态类型的安全性。

var name = "Go工程"   // 推断为 string
var count = 100       // 推断为 int
var rate = 3.14       // 推断为 float64
var flag = true       // 推断为 bool

类型推断在短变量声明中最为常见：

name := "Go工程"   // string
count := 100       // int
rate := 3.14       // float64

3.5 常量与 iota

常量使用 const 关键字声明，其值在编译期确定，运行时不可修改。Go 的常量可以是无类型常量，在需要时自动隐式转换。

3.5.1 常量声明

const Pi = 3.14159
const AppName string = "Go工程"
const (
    StatusOK       = 200
    StatusNotFound = 404
)

3.5.2 iota 枚举器

iota 是 Go 中用于生成常量组的特殊预定义标识符。它在 const 块中从 0 开始逐行递增，常用于实现枚举语义。

const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

const (
    _  = iota             // 忽略 0
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB                    // 1 << 20 = 1048576
    GB                    // 1 << 30 = 1073741824
)

3.6 格式化输出

Go 的 fmt 包提供了丰富的格式化输出功能。掌握常用占位符是调试和日志输出的基础。

func main() {
    name := "Go工程"
    version := 3.0
    count := 100

    // 格式化输出示例
    fmt.Printf("项目: %s, 版本: %.1f, 代码行数: %d\n", name, version, count)
    fmt.Printf("类型: name=%T, version=%T, count=%T\n", name, version, count)
    fmt.Printf("十六进制: %x, 二进制: %b\n", count, count)
}

3.7 变量声明方式对比

为了帮助你在工程中选择最合适的声明方式，下表总结了不同声明方式的适用场景和限制。

3.8 变量作用域与生命周期

理解变量的作用域和生命周期对于编写正确的并发代码和避免内存泄漏至关重要。

• 包级别变量： 在函数外部声明，对整个包可见。生命周期为整个程序运行期间。
• 函数级别变量： 在函数内部声明，仅在该函数内可见。生命周期从声明开始到函数返回结束。
• 块级别变量： 在 if、for、switch 等代码块内声明，仅在该块内可见。块结束后变量被销毁。

var packageVar = "包级别" // 包作用域

func main() {
    funcVar := "函数级别" // 函数作用域
    if true {
        blockVar := "块级别" // 块作用域
        fmt.Println(blockVar)
    }
    // fmt.Println(blockVar) // 编译错误：未定义
    fmt.Println(funcVar)
    fmt.Println(packageVar)
}

3.9 本章知识结构图

下图展示了 Go 基础语法中变量与常量体系的完整结构，帮助你建立全局认知。

3.10 变量声明流程决策图

在实际工程中，如何选择正确的变量声明方式？下面的决策流程图可以帮助你快速做出判断。

3.11 工程最佳实践总结