2. 变量、常量与作用域

Go语言的变量初始化方式有哪些？

Go语言的变量初始化机制设计得非常合理，每种类型都有其默认的零值，这保证了变量的可预测性。

零值机制

Go语言为每种类型都定义了零值，当变量被声明但未显式初始化时，会自动获得零值。数值类型（如int、float等）的零值是0，布尔类型的零值是false，字符串类型的零值是空字符串""，而指针、接口、切片、映射、通道等引用类型的零值是nil。

func zeroValues() {
    var i int        // 0
    var f float64    // 0.0
    var b bool       // false
    var s string     // ""
    var p *int       // nil
    var slice []int  // nil
    var m map[string]int // nil
    var ch chan int  // nil
}

初始化时机

变量的初始化时机取决于其声明位置：

• 包级变量：在程序启动时初始化，在main函数执行前完成
• 局部变量：在函数执行时初始化，每次函数调用都会重新初始化

// 包级变量在程序启动时初始化
var globalVar = getCurrentTime()

func main() {
    // 局部变量在函数执行时初始化
    localVar := getCurrentTime()
}

Go的常量有什么特点？

Go语言的常量具有不可变性、编译时计算、类型安全等特点，是程序中不可变值的重要表示方式。

常量特点

Go语言的常量具有不可变性，一旦定义就不能修改，如const PI = 3.14159。常量在编译时计算确定值，如const MAX = 100 * 2。常量具有类型安全特性，可以有明确的类型，如const name string = "Go"。此外，常量可以是无类型的，根据上下文确定类型，如const value = 42。

常量声明

// 基本常量声明
const PI = 3.14159
const MAX_SIZE = 100
const APP_NAME = "MyApp"

// 类型化常量
const version string = "1.0.0"
const timeout time.Duration = 30 * time.Second

// 批量常量声明
const (
    StatusOK = 200
    StatusNotFound = 404
    StatusError = 500
)

无类型常量

无类型常量是Go语言的特色，它们可以根据使用上下文自动转换为合适的类型：

const value = 42  // 无类型常量

func example() {
    var i int = value      // 转换为int
    var f float64 = value  // 转换为float64
    var b byte = value     // 转换为byte
}

iota的工作原理是什么？

iota是Go语言中的常量计数器，用于生成连续的常量值，特别适合定义枚举类型和位掩码。它具有以下特点：

递增生成规则使iota成为创建连续枚举值的理想工具。iota在每个const声明块中都是独立的，从0开始逐行递增。这种设计保证了枚举值的连续性和可预测性，同时支持在同一行中重复使用相同的iota值来创建多个相关常量。

表达式组合能力让iota不仅仅是简单的计数器，还可以参与复杂的数学运算。通过与位运算、算术运算等结合，可以生成位掩码、2的幂次序列、跳跃序列等多种模式。这种灵活性使得iota能够适应各种枚举需求。

重置与隔离机制确保不同const块之间的iota是相互独立的，避免了全局状态的污染。每个const块都有自己的iota作用域，这种设计提高了代码的可读性和可维护性。

iota基本用法

iota从0开始，在每个const块中递增，遇到新的const关键字时重置为0：

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

iota高级用法

// 跳过值
const (
    _ = iota         // 0，忽略
    Read             // 1
    Write            // 2
    Execute          // 3
)

// 位掩码
const (
    Flag1 = 1 << iota  // 1 << 0 = 1
    Flag2              // 1 << 1 = 2
    Flag3              // 1 << 2 = 4
    Flag4              // 1 << 3 = 8
)

// 表达式
const (
    KB = 1 << (10 * iota)  // 1 << (10 * 0) = 1
    MB                      // 1 << (10 * 1) = 1024
    GB                      // 1 << (10 * 2) = 1048576
)

Go的变量作用域规则是什么？

Go语言的作用域规则遵循词法作用域，变量的可见性由其声明位置决定。

作用域层次

Go语言的作用域分为三个层次：包级作用域、函数级作用域和块级作用域。包级作用域的变量在包级别声明，在整个包内可见，生命周期为程序运行期间。函数级作用域的变量在函数内部声明，仅在函数内部可见，生命周期为函数执行期间。块级作用域的变量在代码块内声明，仅在代码块内可见，生命周期为代码块执行期间。

包级作用域

包级变量在整个包内可见，包括包内的所有函数：

package main

var globalVar = "全局变量"  // 包级作用域

func function1() {
    fmt.Println(globalVar)  // 可以访问
}

func function2() {
    fmt.Println(globalVar)  // 可以访问
}

函数级作用域

函数内声明的变量只在函数内部可见：

func example() {
    localVar := "局部变量"  // 函数级作用域
    
    if true {
        blockVar := "块级变量"  // 块级作用域
        fmt.Println(localVar)   // 可以访问
        fmt.Println(blockVar)   // 可以访问
    }
    
    // fmt.Println(blockVar)  // 编译错误，超出作用域
}

变量遮蔽是怎么回事？

变量遮蔽是指内层作用域中的变量覆盖了外层作用域中同名的变量，这是词法作用域的自然结果。遮蔽的常见场景包括函数参数遮蔽包级别变量、局部变量遮蔽函数参数、代码块变量遮蔽外层变量等。在这些场景中，开发者可能意外地使用了不同的变量，导致程序行为与预期不符。

遮蔽机制

当内层作用域声明了与外层作用域同名的变量时，内层的变量会遮蔽外层的变量：

var global = "全局变量"

func shadowExample() {
    fmt.Println(global)  // 输出：全局变量
    
    global := "局部变量"  // 遮蔽了包级变量
    fmt.Println(global)  // 输出：局部变量
    
    {
        global := "块级变量"  // 遮蔽了函数级变量
        fmt.Println(global)  // 输出：块级变量
    }
    
    fmt.Println(global)  // 输出：局部变量
}

避免遮蔽

为了避免意外的变量遮蔽，可以：

1. 使用不同的变量名
2. 显式引用外层变量
3. 使用包名限定符

var config = "配置"

func avoidShadow() {
    // 使用不同的名称
    localConfig := "本地配置"
    
    // 或者显式引用外层变量
    fmt.Println("外层配置:", config)
    
    // 在块中重新赋值外层变量（如果外层变量可修改）
    // config = "新配置"  // 如果config是包级变量且可修改
}

零值机制是什么？

零值机制是Go语言的一个重要特性，每种类型都有其默认的零值，当变量被声明但未显式初始化时，会自动获得零值。

零值类型

Go语言中不同类型的零值各不相同。数值类型（如int、float等）的零值是0，布尔类型的零值是false，字符串类型的零值是空字符串""，而指针、接口、切片、映射、通道等引用类型的零值是nil。

零值的作用

零值机制确保了变量的可预测性，避免了未初始化变量带来的不确定行为。这使得Go程序更加安全，减少了因变量未初始化而导致的bug。

func zeroValueExample() {
    var i int        // 0
    var f float64    // 0.0
    var b bool       // false
    var s string     // ""
    var p *int       // nil
    var slice []int  // nil
    var m map[string]int // nil
    var ch chan int  // nil
    
    // 零值可以直接使用
    if !b {
        fmt.Println("布尔值为false")
    }
    
    if len(s) == 0 {
        fmt.Println("字符串为空")
    }
}

nil有哪些使用场景？

nil是Go语言中的零值，表示"空"或"无效"，主要用于指针、接口、切片、映射、通道等引用类型。

nil的使用场景

nil在Go语言中表示"空"或"无效"，主要用于引用类型。对于指针类型，nil表示空指针，用于表示未初始化的指针。对于接口类型，nil表示空接口，表示接口值为空。对于切片类型，nil表示空切片，表示长度为0的切片。对于映射类型，nil表示空映射，表示未初始化的映射。对于通道类型，nil表示空通道，表示未初始化的通道。

指针的nil

func pointerNil() {
    var ptr *int = nil  // 空指针
    
    if ptr == nil {
        fmt.Println("指针为空")
    }
    
    // 解引用空指针会导致panic
    // *ptr = 10  // panic: runtime error: invalid memory address
}

接口的nil

func interfaceNil() {
    var i interface{} = nil
    
    if i == nil {
        fmt.Println("接口为空")
    }
    
    // 注意：接口的nil判断
    var s *string = nil
    var i2 interface{} = s
    
    if i2 == nil {
        fmt.Println("接口为空")  // 不会执行
    }
    // 因为接口包含类型信息，即使值为nil，接口也不为nil
}

切片和映射的nil

func sliceMapNil() {
    var slice []int = nil
    var m map[string]int = nil
    
    // nil切片可以安全操作
    fmt.Println(len(slice))  // 0
    fmt.Println(cap(slice))  // 0
    
    // nil映射不能写入，但可以读取
    // m["key"] = 1  // panic: assignment to entry in nil map
    value := m["key"]  // 返回零值，不会panic
    fmt.Println(value)  // 0
}

nil检查的最佳实践

func nilCheck() {
    var ptr *int = nil
    var slice []int = nil
    var m map[string]int = nil
    
    // 安全的nil检查
    if ptr != nil {
        fmt.Println(*ptr)
    }
    
    if slice != nil {
        fmt.Println(slice[0])
    }
    
    if m != nil {
        m["key"] = 1
    }
}

Go语言的变量生命周期是怎样的？