golang3变量常量

最新推荐文章于 2026-02-02 10:19:50 发布

原创最新推荐文章于 2026-02-02 10:19:50 发布 · 806 阅读

14 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

《GO基础语法-完结》

在 Go 语言中，变量（Variable）和常量（Constant）是程序存储和操作数据的基本单元。Go 对变量和常量的声明、使用有严格的语法规范，同时提供了灵活的特性以适应不同场景。下面深入讲解 Go 中变量和常量的定义、特性、使用规则及最佳实践。

一、变量（Variable）

变量是程序运行过程中可以修改的存储单元，用于存储临时数据。Go 语言的变量声明方式灵活，且强调 “显式声明、类型安全”。

1. 变量的声明与初始化

Go 提供了多种变量声明方式，核心原则是 “声明即需使用”（未使用的变量会导致编译错误）。

（1）标准声明（显式类型）

语法：

var 变量名 类型

声明后可单独初始化，也可在声明时初始化：

package main

import "fmt"

func main() {
    // 声明变量（默认零值）
    var age int       // 整数类型默认值：0
    var name string   // 字符串默认值：""（空字符串）
    var isStudent bool// 布尔类型默认值：false

    // 声明并初始化
    var score float64 = 95.5
    var address string = "Beijing"

    fmt.Println(age, name, isStudent, score, address)
    // 输出：0  false 95.5 Beijing
}

零值规则：未初始化的变量会被赋予默认 “零值”，不同类型的零值不同：

数值类型（int、float 等）：0
布尔类型：false
字符串：""（空字符串）
指针、切片、map 等引用类型：nil

（2）类型推断（省略类型）

声明变量时若直接初始化，可省略类型，Go 会根据初始值自动推断类型：

func main() {
    var a = 10      // 推断为 int 类型
    var b = 3.14    // 推断为 float64 类型
    var c = "hello" // 推断为 string 类型
    var d = true    // 推断为 bool 类型

    fmt.Printf("a: %T, b: %T, c: %T, d: %T\n", a, b, c, d)
    // 输出：a: int, b: float64, c: string, d: bool
}

（3）短变量声明（`:=` 操作符）

在函数内部，可使用 := 进行更简洁的声明（只能在函数内使用，不能用于包级变量）：

func main() {
    // 短声明：变量名 := 初始值
    name := "Alice"  // 等价于 var name string = "Alice"
    age := 20        // 等价于 var age int = 20
    height, weight := 1.75, 65.5 // 同时声明多个变量

    fmt.Println(name, age, height, weight)
}

特点：

必须至少声明一个新变量（否则编译错误）：

a := 10
a := 20 // 错误：no new variables on left side of :=
a, b := 20, 30 // 正确：b是新变量

可用于变量重新赋值（但至少有一个新变量）：

x, y := 1, 2
x, z := 3, 4 // 正确：x重新赋值，z是新变量

（4）批量声明

使用 var 块批量声明变量，适合声明多个同类型或不同类型的变量：

// 包级批量声明（可在函数外）
var (
    version string = "1.0.0"
    port    int    = 8080
    debug   bool   = false
)

func main() {
    // 函数内批量声明
    var (
        name string
        age  int
    )
    name = "Bob"
    age = 25
    fmt.Println(name, age, version, port)
}

2. 变量的作用域

变量的作用域指其可被访问的代码范围，Go 中变量作用域分为：

（1）包级变量（Package-level）

声明在函数外，整个包内可见（跨文件，只要在同一包中）
首字母大写的包级变量可被其他包访问（导出变量）

运行

package main

import "fmt"

// 包级变量（整个包可见）
var globalVar = "I'm global"

func printGlobal() {
	fmt.Println(globalVar) // 可访问包级变量
}

func main() {
	printGlobal() // 输出：I'm global
}

（2）函数级变量（Function-level）

声明在函数内，仅在该函数内可见
包括函数参数和函数内声明的变量

运行

func add(a, b int) int { // a、b是函数参数，作用域为add函数内
	sum := a + b // sum是函数内变量，作用域为add函数内
	return sum
}

func main() {
	// fmt.Println(sum) // 错误：sum未定义（超出作用域）
}

（3）块级变量（Block-level）

声明在代码块内（如 if、for、switch 的 {} 中）
仅在当前代码块内可见

运行

func main() {
	if flag := true; flag { // flag的作用域仅限if块内
		fmt.Println("flag is true")
	}
	// fmt.Println(flag) // 错误：flag未定义
}

3. 变量的类型

Go 是强类型语言，变量类型一旦确定（或被推断），就不能存储其他类型的值：

运行

func main() {
	var a int = 10
	// a = "hello" // 错误：cannot assign string to type int

	var b interface{} = 10 // 空接口可存储任意类型
	b = "hello" // 正确：空接口类型可变
}

二、常量（Constant）

常量是程序运行过程中不可修改的固定值，用于存储编译期即可确定的不变数据（如配置参数、数学常数等）。

1. 常量的声明与初始化

常量声明使用 const 关键字，必须在声明时初始化（且初始值必须是编译期可计算的表达式）。

（1）基本声明

运行

func main() {
	// 显式类型
	const Pi float64 = 3.1415926
	// 类型推断
	const Version = "1.0.0"
	// 布尔常量
	const Debug = false

	fmt.Println(Pi, Version, Debug)
}

（2）批量声明

与变量类似，常量也支持批量声明：

运行

const (
	MaxSize = 1024
	MinSize = 1
	DefaultTimeout = 30 // 单位：秒
)

2. 常量的特性

不可修改：常量声明后不能重新赋值（编译错误）：

go

运行
```
const Pi = 3.14
// Pi = 3.1415 // 错误：cannot assign to Pi
```

编译期确定：常量的值必须在编译时可计算，不能依赖运行时数据：

运行

// 错误：rand.Int() 是运行时函数，不能用于常量初始化
// const Random = rand.Int()

隐式类型转换：常量之间支持隐式类型转换（变量不支持）：

运行

const a int = 10
const b float64 = a // 正确：常量隐式转换
// var c float64 = a // 错误：变量需要显式转换（float64(a)）

3. iota：常量计数器

iota 是 Go 的特殊常量，用于生成自增序列，仅在 const 声明块中有效，每次 const 声明块中 iota 从 0 开始，每新增一行常量声明，iota 自动加 1。

（1）基本用法

运行

func main() {
	const (
		c0 = iota // c0 = 0
		c1        // c1 = 1（默认使用上一行的表达式 iota）
		c2        // c2 = 2
	)
	fmt.Println(c0, c1, c2) // 输出：0 1 2
}

（2）进阶用法

iota 可结合表达式生成复杂序列：

运行

const (
	_  = iota // 忽略第一个值（从0开始）
	KB = 1 << (10 * iota) // 1 << 10（1024），iota=1
	MB = 1 << (10 * iota) // 1 << 20（1048576），iota=2
	GB = 1 << (10 * iota) // 1 << 30，iota=3
)

const (
	North = iota // 0
	East         // 1
	South        // 2
	West         // 3
)

func main() {
	fmt.Println(KB, MB, GB) // 输出：1024 1048576 1073741824
	fmt.Println(North, East, South, West) // 输出：0 1 2 3
}

（3）重置计数器

每次进入新的 const 块，iota 都会重置为 0：

运行

const (
	a = iota // 0
	b        // 1
)

const (
	c = iota // 0（新块，重置）
	d        // 1
)

三、变量与常量的核心区别

特性	变量（Variable）	常量（Constant）
关键字	`var` 或 `:=`（函数内）	`const`
可修改性	运行时可修改	不可修改（编译期确定）
初始化要求	可声明后初始化（默认零值）	必须声明时初始化
类型推断	支持（声明时初始化可省略类型）	支持
作用域	包级、函数级、块级	包级、函数级、块级
初始化值来源	可来自运行时计算（如函数返回值）	必须是编译期可计算的表达式
隐式转换	不支持（需显式转换）	支持（同类型系列的常量间）

四、最佳实践与常见错误

1. 变量使用的最佳实践

优先使用短声明（:=）：函数内变量推荐用 := 简化代码，但避免过度使用导致可读性下降。

最小作用域原则

：变量声明在使用的最近位置（如循环内的变量声明在循环内），减少命名冲突。

运行

// 推荐
for i := 0; i < 10; i++ { ... } // i的作用域仅限循环内

// 不推荐（扩大了作用域）
var i int
for i = 0; i < 10; i++ { ... }

避免未使用的变量：Go 编译器会报错，需删除或用 _ 替换（但 _ 不能单独作为变量使用）。

2. 常量使用的最佳实践

用常量存储固定值：如配置参数（端口号、超时时间）、数学常数等，增强代码可维护性。

枚举场景用 iota

：替代魔法数字，使代码更清晰（如状态码、方向枚举）。

运行

// 推荐：用iota定义枚举
const (
    StatusSuccess = iota // 0
    StatusError          // 1
    StatusTimeout        // 2
)

// 不推荐：魔法数字
// if code == 0 { ... } // 0代表什么？

3. 常见错误

函数外使用 :=：:= 只能在函数内使用，包级变量必须用 var 声明：

go

运行
```
// 错误：函数外不能用 :=
// name := "global"

// 正确
var name = "global"
```

常量使用运行时数据初始化：

运行

import "time"

// 错误：time.Now() 是运行时函数
// const StartTime = time.Now()

变量类型不匹配：Go 是强类型，不同类型变量赋值需显式转换：

运行

var a int = 10
var b float64 = float64(a) // 正确：显式转换
// var b float64 = a // 错误：类型不匹配

总结

变量和常量是 Go 语言的基础构建块：

变量：用于存储可变数据，支持多种声明方式（var、:= 等），有明确的作用域和类型，需显式转换。
常量：用于存储不可变数据，必须在声明时初始化，值在编译期确定，iota 简化了枚举序列的生成。

理解两者的特性和使用规则，能帮助你编写更规范、高效的 Go 代码，尤其是 iota 的灵活运用和变量作用域的合理控制，是写出高质量 Go 程序的关键。

标签

#go