变量与常量

变量和常量是编程语言的基础概念。本章将详细介绍 Go 语言中变量和常量的声明、使用和注意事项。

什么是变量？

变量是程序中存储数据的"容器"。你可以把变量想象成一个盒子，盒子有名字（变量名），里面可以放东西（值）。

┌─────────────┐
│   age = 25  │  ← 变量名：age，值：25
└─────────────┘

变量声明

Go 是静态类型语言，变量必须有明确的类型。

方式一：var 声明

使用 var 关键字声明变量：

var name string
var age int
var salary float64
var isActive bool

语法格式：

var 变量名 类型

方式二：var 声明并赋值

声明的同时赋初值：

var name string = "张三"
var age int = 25
var salary float64 = 10000.50
var isActive bool = true

方式三：类型推断

如果声明时赋值，可以省略类型，Go 会自动推断：

var name = "张三"
var age = 25
var salary = 10000.50
var isActive = true

方式四：短变量声明（推荐）

在函数内部，可以使用 := 短变量声明：

name := "张三"
age := 25
salary := 10000.50
isActive := true

注意：短变量声明只能在函数内部使用。

方式五：批量声明

一次声明多个变量：

var (
    name    string
    age     int
    salary  float64
    isActive bool
)

批量声明并赋值：

var (
    name    string  = "张三"
    age     int     = 25
    salary  float64 = 10000.50
    isActive bool   = true
)

变量使用示例

package main

import "fmt"

func main() {
    var name string
    name = "张三"
    fmt.Println(name)

    var age int = 25
    fmt.Println(age)

    city := "北京"
    fmt.Println(city)

    x, y := 10, 20
    fmt.Println(x, y)
}

输出：

张三
25
北京
10 20

零值

Go 语言中，声明但未赋值的变量会自动初始化为"零值"：

示例：

package main

import "fmt"

func main() {
    var i int
    var f float64
    var s string
    var b bool

    fmt.Printf("int: %d\n", i)
    fmt.Printf("float: %f\n", f)
    fmt.Printf("string: %q\n", s)
    fmt.Printf("bool: %t\n", b)
}

输出：

int: 0
float: 0.000000
string: ""
bool: false

变量命名规则

命名规范

命名风格

命名建议

• 变量名要有意义，避免 a, b, c 这种无意义名称
• 布尔类型建议用 is, has, can 开头，如 isActive, hasPermission
• 简短名称可用于局部变量，如 i, j 用于循环

常量

常量是程序运行期间不会改变的值。使用 const 关键字声明。

常量声明

const Pi = 3.14159
const AppName = "MyApp"
const MaxSize = 100

批量声明

const (
    StatusOK    = 200
    StatusNotFound = 404
    StatusError = 500
)

常量特点

1. 必须在声明时赋值，不能后续修改
2. 类型不是必须的，可以是"无类型常量"
3. 编译时确定，运行时不可修改

package main

import "fmt"

func main() {
    const Pi = 3.14159
    fmt.Println(Pi)

    Pi = 3.14
}

iota 常量生成器

iota 是 Go 语言的常量计数器，只能在常量声明中使用。

基本用法

const (
    a = iota
    b = iota
    c = iota
)

fmt.Println(a, b, c)

输出：

0 1 2

简写形式

在 const 块中，如果某一行没有写表达式，会复用上一行的表达式：

const (
    a = iota
    b
    c
)

fmt.Println(a, b, c)

输出：

0 1 2

实际应用：枚举

const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

fmt.Println(Sunday, Monday, Saturday)

输出：

0 1 6

实际应用：位运算

const (
    Read = 1 << iota
    Write
    Execute
)

fmt.Println(Read, Write, Execute)

输出：

1 2 4

解释：

可以组合使用：

permission := Read | Write
fmt.Println(permission)

输出：

3

跳过值

使用 _ 跳过某个值：

const (
    a = iota
    _
    b
    _
    c
)

fmt.Println(a, b, c)

输出：

0 2 4

变量 vs 常量

作用域

变量的作用域是指变量可以被访问的范围。

局部变量

在函数内部声明的变量，只能在函数内使用：

func main() {
    name := "张三"
    fmt.Println(name)
}

func other() {
    fmt.Println(name)
}

全局变量

在函数外部声明的变量，可以在整个包内使用：

package main

import "fmt"

var globalVar = "我是全局变量"

func main() {
    fmt.Println(globalVar)
}

func other() {
    fmt.Println(globalVar)
}

块作用域

在代码块（如 if、for）内声明的变量，只能在块内使用：

func main() {
    if true {
        x := 10
        fmt.Println(x)
    }
    fmt.Println(x)
}

常见错误

错误 1：变量未使用

func main() {
    name := "张三"
    age := 25
    fmt.Println(name)
}

错误信息：

age declared but not used

解决方法：使用变量或删除未使用的变量。

错误 2：短变量声明在函数外

package main

name := "张三"

func main() {
    fmt.Println(name)
}

错误信息：

syntax error: non-declaration statement outside function body

解决方法：使用 var 声明：

var name = "张三"

错误 3：重复声明

func main() {
    name := "张三"
    name := "李四"
}

错误信息：

no new variables on left side of :=

解决方法：使用 = 赋值：

name := "张三"
name = "李四"

总结

本章学习了 Go 语言的变量和常量：