变量 - Variables

理解 Go 中变量的声明方式是编写代码的基础。

变量声明

三种声明方式

package main

import "fmt"

func main() {
    // 方式1：标准声明（var 变量名 类型）
    var name string = "Go"
    var age int = 10

    // 方式2：类型推断（var 变量名 = 值）
    var language = "Go"  // 自动推断为 string
    var version = 1.26   // 自动推断为 float64

    // 方式3：简短声明（:= 只能在函数内使用）
    year := 2026         // 自动推断为 int
    isActive := true     // 自动推断为 bool

    fmt.Println(name, age, language, version, year, isActive)
}

风格推荐

对于需要赋初值的场景，推荐方式 3。对于不需要初值的场景，推荐方式 1。

声明方式选择

零值机制

默认零值

Go 中每个类型都有默认的"零值"：

package main

import "fmt"

func main() {
    var (
        name      string   // ""  (空字符串)
        age       int      // 0
        price     float64  // 0
        isActive  bool     // false
        numbers   []int    // nil
        userInfo  map[string]string  // nil
    )

    fmt.Printf("string: '%s'\\n", name)
    fmt.Printf("int: %d\\n", age)
    fmt.Printf("float64: %f\\n", price)
    fmt.Printf("bool: %t\\n", isActive)
    fmt.Printf("slice: %v\\n", numbers)
    fmt.Printf("map: %v\\n", userInfo)
}

零值速查表：

类型	零值	说明
`int`, `int8`...`int64`	`0`	数值零
`uint`, `uint8`...`uint64`	`0`	数值零
`float32`, `float64`	`0`	数值零
`string`	`""`	空字符串（不是 nil）
`bool`	`false`	布尔假
指针	`nil`	空指针
slice	`nil`	空切片
map	`nil`	空映射
channel	`nil`	空通道
interface	`nil`	空接口
function	`nil`	空函数

重要 Go 没有未初始化的变量，声明后自动获得零值，避免了"未定义行为"。

批量声明

var 批量声明

package main

import "fmt"

func main() {
    // 方式1：因式分解（函数内不推荐，建议用方式2）
    var (
        name     string = "Go"
        age      int    = 10
        isActive bool   = true
    )

    // 方式2：多变量短声明（函数内推荐）
    x, y := 10, 20
    firstName, lastName := "John", "Doe"

    fmt.Println(name, age, isActive)
    fmt.Println(x, y, firstName, lastName)
}

风格建议 var () 因式分解语法仅用于包级变量，函数内局部变量应使用简短声明 :=。

函数多返回值

package main

import "fmt"

// 返回多个值
func divide(a, b int) (int, int) {
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}

func main() {
    q, r := divide(10, 3)
    fmt.Printf("10 / 3 = %d ... %d\\n", q, r)

    // 使用 _ 忽略不需要的返回值
    q2, _ := divide(10, 3)
    fmt.Printf("10 / 3 = %d\\n", q2)
}

变量作用域

作用域示例

package main

import "fmt"

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

func main() {
    // 函数级变量
    localVar := "I am local"

    fmt.Println(globalVar)  // ✅ 可访问
    fmt.Println(localVar)   // ✅ 可访问

    // 块级作用域
    if true {
        blockVar := "I am in a block"
        fmt.Println(localVar)   // ✅ 可访问外层
        fmt.Println(blockVar)   // ✅ 可访问
    }

    // fmt.Println(blockVar)  // ❌ 超出作用域
}

func anotherFunction() {
    fmt.Println(globalVar)  // ✅ 可访问
    // fmt.Println(localVar)  // ❌ 超出作用域
}

变量遮蔽

package main

import "fmt"

var x = "global x"

func main() {
    fmt.Println(x)  // "global x"

    x := "local x"  // 遮蔽全局变量
    fmt.Println(x)  // "local x"

    {
        x := "block x"  // 再次遮蔽
        fmt.Println(x)  // "block x"
    }

    fmt.Println(x)  // "local x" (回到函数级)
}

警告 变量遮蔽可能导致难以发现的 bug，建议使用不同的变量名避免遮蔽。

快速参考

声明类型	语法	使用场景
标准声明	`var name Type`	包级变量、需要明确类型
类型推断	`var name = value`	包级变量、类型不明显
简短声明	`name := value`	函数内局部变量（推荐）

练习

声明一个表示用户的变量，包含姓名、年龄和邮箱
编写函数返回两数之和与积
演示变量遮蔽的效果

← 返回基础概念 | 命名规则 | 常量 →

#变量 - Variables

#变量声明

#三种声明方式

#声明方式选择

#零值机制

#默认零值

#批量声明

#var 批量声明

#函数多返回值

#变量作用域

#作用域示例

#变量遮蔽

#快速参考

#练习