一、Go入门学习 - 变量、常量的定义

Go语言对变量、常量的定义有严格且简洁的语法规范，同时存在声明即使用、作用域、跨包访问等特性，本文将从变量、常量两部分详细讲解基础定义语法与核心规则。

一、变量

变量是程序运行过程中可以修改的存储单元，Go语言中变量声明有多种方式，且有明确的使用和作用域规则，同时支持多类型的变量定义。

1. Go语言常用变量类型

Go是静态类型语言，变量声明时会确定类型且不可隐式转换，常用基础类型如下：

类型分类

具体类型

说明

整型

int/int8/int16/int32/int64
uint/uint8/uint16/uint32/uint64

int随系统位数变化（32位系统4字节，64位8字节）；uint为无符号整型

浮点型

float32/float64

浮点数默认float64，精度更高

字符串

string

原生字符串类型，默认UTF-8编码

布尔型

bool

只有true/false两个值，无0/1替代

字符型

byte/rune

byte对应uint8（ASCII），rune对应int32（Unicode）

2. 变量声明的多种方式

（1）全局变量声明

全局变量定义在函数外部，支持单个声明和批量声明，即使声明后未使用也不会报编译错误（局部变量会报错）。

package main

import "fmt"

// 单个全局变量声明
var age = 18 // 省略类型，编译器自动推导为int
var name string = "李四" // 显式指定类型

// 批量全局变量声明（推荐，简洁）
var (
 s1 string = "s1"
 s2 string = "s2"
 num1, num2 int = 10, 20 // 批量声明同类型变量
)

（2）局部变量声明

局部变量定义在函数/代码块内部，声明后必须使用，否则编译报错，有4种常用声明方式：

func main() {
 // 方式1：先声明，后赋值（适合先确定类型，后续赋值的场景）
 var address string
 address = "北京市"
 fmt.Println(address)

 // 方式2：声明并直接赋值（显式指定类型，可读性强）
 var phone string = "13800138000"
 fmt.Println(phone)

 // 方式3：声明赋值，省略类型（编译器自动推导，最常用）
 var email = "test@163.com"
 fmt.Println(email)

 // 方式4：短声明 := （函数内专属，最简洁）
 score := 98.5 // 自动推导为float64
 fmt.Println(score)

 // 批量声明局部变量
 var a1, a2 = 1, 2 // 不同类型也可批量声明：var a, b = 1, "hello"
 fmt.Println(a1, a2)
}

3. 变量的核心规则

  1. 短声明限制：:= 短声明只能在函数内部使用，全局变量不可用；

  2. 声明即使用：局部变量声明后必须调用，全局变量无此限制；

  3. 作用域：全局变量可在整个包的所有函数中访问，局部变量仅在所在函数/代码块内有效；

  4. 跨包访问：若需让其他包访问当前包的变量，变量名首字母必须大写（Go的访问控制规则），如var AppName = "Go学习"。

二、常量

常量是程序运行过程中值不可修改的存储单元，常用于定义固定值（如PI、版本号、状态码），定义语法与变量类似，但有专属关键字和特性。

1. 常量声明的基本方式

使用const关键字声明常量，支持单个声明、批量声明，显式指定类型或编译器自动推导，语法如下：

package main

import "fmt"

// 单个常量声明：显式指定类型
const version string = "2.0.1" // 版本号，字符串常量
const PI float64 = 3.1415926   // 圆周率，浮点型常量

// 批量常量声明
const (
 STATUS_SUCCESS = 200 // 自动推导为int
 STATUS_ERROR   = 500
 MSG            = "success" // 自动推导为string
)

func main() {
 // 函数内也可声明常量（局部常量）
 const maxNum = 100 // 自动推导为int
 fmt.Println(maxNum, PI, version)
}

2. 常量的核心规则

  1. 值不可修改：常量声明时必须赋值，且赋值后无法在程序中修改，否则编译报错；

  2. 类型规则：常量可显式指定类型，也可让编译器自动推导，未指定类型的常量为无类型常量，可隐式转换为兼容类型；

  3. 作用域与跨包访问：与变量一致，全局常量可包内访问，首字母大写可跨包访问（如const PI = 3.14，其他包可通过包名.PI调用）；

  4. 声明后使用规则：与变量一致，局部常量声明后必须使用，全局常量可声明不使用；

  5. 专属特性：常量支持iota常量生成器（批量声明连续常量时使用，Go常量高级特性，基础入门暂不展开）。

3. 变量与常量的核心区别

特性

变量

常量

关键字

var

const

值可修改

是

否（声明时赋值，后续不可改）

声明时赋值

可先声明后赋值

必须声明时直接赋值

高级特性

无

支持iota生成器

适用场景

运行过程中需动态修改的值

运行过程中固定不变的值（如PI、版本号）

完整可运行代码

package main

import "fmt"

// 全局变量：单个/批量声明
var age = 18
var (
 s1 string = "s1"
 s2 string = "s2"
)

// 常量：单个/批量声明，跨包访问首字母大写
const version string = "2.0.1"
const PI float64 = 3.1415926
const (
 STATUS_SUCCESS = 200
 MSG            = "success"
)

// 自定义函数
func hello() {
 fmt.Println("你好")
}

func main() {
 // 局部变量：先声明后赋值
 var name string
 name = "张三"
 fmt.Println(name)

 // 声明并赋值（显式类型/省略类型）
 var name1 string = "张三"
 var name2 = "张三"
 fmt.Println(name1, name2)

 // 函数内短声明 :=
 name3 := "张三"
 fmt.Println(name3)

 // 调用函数
 hello()

 // 批量声明变量
 var a1, a2 = 1, 2
 fmt.Println(a1, a2)

 // 调用常量
 fmt.Println("版本号：", version, "圆周率：", PI, "状态码：", STATUS_SUCCESS)
}

运行结果：

张三
张三 张三
张三
你好
1 2
版本号： 2.0.1 圆周率： 3.1415926 状态码： 200