Go 语言基础语法：变量、常量与数据类型详解

文章目录

[Go 语言基础语法：变量、常量与数据类型详解](#Go 语言基础语法：变量、常量与数据类型详解)
- 一、前置说明
- [二、Go 语言变量（Variable）](#二、Go 语言变量（Variable）)
- - [1. 什么是变量？](#1. 什么是变量？)
  - [2. 变量的声明方式](#2. 变量的声明方式)
  - - [方式 1：标准声明（指定类型，不赋值）](#方式 1：标准声明（指定类型，不赋值）)
    - [方式 2：声明变量并赋值（指定类型）](#方式 2：声明变量并赋值（指定类型）)
    - [方式 3：类型推导（省略类型，自动识别）](#方式 3：类型推导（省略类型，自动识别）)
    - [方式 4：短变量声明（最常用，推荐）](#方式 4：短变量声明（最常用，推荐）)
  - [3. 一次性声明多个变量](#3. 一次性声明多个变量)
  - [4. 变量命名规则（必须遵守）](#4. 变量命名规则（必须遵守）)
- [三、Go 语言常量（Constant）](#三、Go 语言常量（Constant）)
- - [1. 什么是常量？](#1. 什么是常量？)
  - [2. 常量声明方式](#2. 常量声明方式)
  - - 基础常量声明
    - 批量声明常量
    - [iota：常量生成器（Go 特色）](#iota：常量生成器（Go 特色）)
    - [iota 使用注意点（含示例说明）](#iota 使用注意点（含示例说明）)
    - - [注意点1：iota 仅在 const 代码块中有效，且从 0 开始自动递增](#注意点1：iota 仅在 const 代码块中有效，且从 0 开始自动递增)
      - [注意点2：iota 可跳过某个值（用下划线 \_ 占位）](#注意点2：iota 可跳过某个值（用下划线 _ 占位）)
      - [注意点3：iota 可结合表达式，实现复杂常量生成](#注意点3：iota 可结合表达式，实现复杂常量生成)
      - [注意点4：const 块内若手动赋值，会中断 iota 的递增逻辑](#注意点4：const 块内若手动赋值，会中断 iota 的递增逻辑)
- [四、Go 语言基本数据类型](#四、Go 语言基本数据类型)
- - [1. 整型（int）：存储整数](#1. 整型（int）：存储整数)
  - [2. 浮点型（float）：存储小数](#2. 浮点型（float）：存储小数)
  - [3. 字符串类型（string）：存储文本](#3. 字符串类型（string）：存储文本)
  - [4. 布尔类型（bool）：存储真假](#4. 布尔类型（bool）：存储真假)
- 五、数据类型查看与转换
- - [1. 查看变量类型](#1. 查看变量类型)
  - [2. 数据类型转换](#2. 数据类型转换)
- 六、常见错误总结（新手必看）
- 七、本篇总结

Go 语言基础语法：变量、常量与数据类型详解

大家好～上一篇博客我们成功编写并运行了 Go 语言的 Hello World 程序，验证了开发环境的正确性。从这一篇开始，我们正式学习 Go 语言的基础语法 ，今天的核心内容是：变量、常量、数据类型，这是所有编程逻辑的基石，零基础也能轻松掌握，每个知识点都搭配可直接运行的代码示例，跟着敲一遍就能学会！

一、前置说明

学习本篇内容前，你可以继续使用上一篇创建的 GoStudy 项目，新建一个 basic 文件夹，创建 main\.go 文件，所有示例代码都可以写在这个文件中运行。

本篇所有代码都遵循 Go 程序基础结构：

go 复制代码

package main

import "fmt"

func main() {
    // 这里写测试代码
}

二、Go 语言变量（Variable）

1. 什么是变量？

变量就是存储数据的容器，可以把它理解成一个带名字的盒子，用来存放数字、文本、真假值等数据，程序运行过程中，变量的值可以被修改。

2. 变量的声明方式

Go 语言提供了4 种常用的变量声明方式，适用不同场景，我们逐个学习。

方式 1：标准声明（指定类型，不赋值）

语法：

go 复制代码

var 变量名 数据类型

特点：声明变量时指定数据类型，变量会自动赋予默认零值（数字为 0，字符串为空，布尔为 false）。

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	// 声明一个整型变量
	var age int
	// 声明一个字符串变量
	var name string
	// 声明一个布尔变量
	var isStudent bool

	// 打印变量默认值
	fmt.Println("age默认值：", age)
	fmt.Println("name默认值：", name)
	fmt.Println("isStudent默认值：", isStudent)
}

运行结果：

Plain 复制代码

age默认值： 0
name默认值： 
isStudent默认值： false

方式 2：声明变量并赋值（指定类型）

语法：

go 复制代码

var 变量名 数据类型 = 初始值

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	// 声明整型变量并赋值
	var score int = 95
	// 声明字符串变量并赋值
	var username string = "Go学习者"
	// 声明布尔变量并赋值
	var isOk bool = true

	fmt.Println("分数：", score)
	fmt.Println("用户名：", username)
	fmt.Println("状态：", isOk)
}

方式 3：类型推导（省略类型，自动识别）

Go 可以根据赋值自动判断变量类型，无需手动写数据类型。

语法：

go 复制代码

var 变量名 = 初始值

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	var height = 175.5 // 自动推导为浮点型
	var city = "北京"   // 自动推导为字符串型
	var isWork = true  // 自动推导为布尔型

	fmt.Printf("height类型：%T，值：%f\n", height, height)
	fmt.Printf("city类型：%T，值：%s\n", city, city)
	fmt.Printf("isWork类型：%T，值：%t\n", isWork, isWork)
}

运行结果：

Plain 复制代码

height类型：float64，值：175.500000
city类型：string，值：北京
isWork类型：bool，值：true

方式 4：短变量声明（最常用，推荐）

在函数内部，我们可以使用 := 快速声明变量，省略 var 和类型 ，开发中 90% 场景都用这种方式。

语法：

go 复制代码

变量名 := 初始值

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	// 短变量声明，最简单常用
	num := 100
	content := "短变量声明"
	flag := false

	fmt.Println(num, content, flag)
}

3. 一次性声明多个变量

Go 支持批量声明变量，代码更简洁。
示例代码：

go 复制代码

package main

import "fmt"

func main() {
	// 方式1：批量标准声明
	var (
		a int
		b string
		c bool
	)

	// 方式2：批量短变量声明
	name, age, score := "张三", 20, 90.5

	fmt.Println(a, b, c)
	fmt.Println(name, age, score)
}

4. 变量命名规则（必须遵守）

变量名由字母、数字、下划线组成
不能以数字开头
区分大小写（Name 和 name 是两个不同变量）
不能使用 Go 关键字（如 var、func、package 等）
建议见名知意（如 age 代表年龄，username 代表用户名）

三、Go 语言常量（Constant）

1. 什么是常量？

常量是运行过程中值不能被修改的量，一旦定义，值就固定不变，通常用来存储固定数据（如圆周率、税率、固定配置）。

2. 常量声明方式

使用 const 关键字声明，语法和变量类似。

基础常量声明

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	// 声明常量
	const PI = 3.1415926
	const MAX_COUNT = 100

	fmt.Println("圆周率：", PI)
	fmt.Println("最大值：", MAX_COUNT)

	// 错误：常量不能修改
	// PI = 3.14  // 编译报错
}

批量声明常量

go 复制代码

package main

import "fmt"

func main() {
	const (
		STATUS_OK  = 200
		STATUS_ERR = 500
		NAME       = "Go语言"
	)
	fmt.Println(STATUS_OK, STATUS_ERR, NAME)
}

iota：常量生成器（Go 特色）

iota 是 Go 提供的常量计数器，从 0 开始自动递增，批量定义常量时非常实用。

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	const (
		ONE = iota   // 0
		TWO          // 1
		THREE        // 2
	)
	fmt.Println(ONE, TWO, THREE)
}

iota 使用注意点（含示例说明）

iota 作为 Go 特有的常量生成器，使用时需注意4个核心要点，每个要点均搭配示例，帮你避开新手常见坑：

注意点1：iota 仅在 const 代码块中有效，且从 0 开始自动递增

iota 的递增作用范围仅限于当前的 const 括号内，超出该 const 块后，iota 会重新从 0 开始计数；若 const 块内未使用 iota，它也会默认递增（不使用则无实际意义）。

go 复制代码

package main

import "fmt"

func main() {
	// 第一个const块，iota从0开始
	const (
		A = iota // 0
		B        // 1（自动递增）
		C        // 2
	)
	// 第二个const块，iota重新从0开始
	const (
		D = iota // 0（重新计数）
		E        // 1
	)
	fmt.Println(A, B, C) // 输出：0 1 2
	fmt.Println(D, E)    // 输出：0 1
}

注意点2：iota 可跳过某个值（用下划线 _ 占位）

若批量声明常量时，某个位置不需要使用 iota 生成的默认值，可使用下划线 _ 占位，跳过该值，后续 iota 继续递增。

go 复制代码

package main

import "fmt"

func main() {
	const (
		Mon = iota // 0（周一）
		Tue        // 1（周二）
		_          // 2（跳过周三，不使用该值）
		Thu        // 3（周四，iota 继续递增）
		Fri        // 4（周五）
	)
	fmt.Println(Mon, Tue, Thu, Fri) // 输出：0 1 3 4
}

注意点3：iota 可结合表达式，实现复杂常量生成

iota 不仅能直接赋值，还能搭配算术运算、位运算等表达式，生成符合需求的常量（如2的幂、状态码等），灵活度极高。

go 复制代码

package main

import "fmt"

func main() {
	// 示例1：生成2的幂（常用场景：权限控制、二进制标识）
	const (
		Power1 = 1 << iota // 1 << 0 = 1（2^0）
		Power2              // 1 << 1 = 2（2^1）
		Power3              // 1 << 2 = 4（2^2）
		Power4              // 1 << 3 = 8（2^3）
	)
	// 示例2：生成步长为10的状态码
	const (
		Code100 = 100 + iota*10 // 100 + 0*10 = 100
		Code110                  // 100 + 1*10 = 110
		Code120                  // 100 + 2*10 = 120
	)
	fmt.Println(Power1, Power2, Power3, Power4) // 输出：1 2 4 8
	fmt.Println(Code100, Code110, Code120)      // 输出：100 110 120
}

注意点4：const 块内若手动赋值，会中断 iota 的递增逻辑

若在 const 块中，某一行常量手动赋值（不使用 iota），则后续未赋值的常量会沿用该手动值，不再跟随 iota 递增（新手最容易踩的坑）。

go 复制代码

package main

import "fmt"

func main() {
	const (
		X = iota // 0
		Y        // 1（正常递增）
		Z = 100  // 手动赋值，中断iota递增
		W        // 100（沿用Z的手动值，不再递增）
		V = iota // 3（重新使用iota，此时iota计数到3）
	)
	fmt.Println(X, Y, Z, W, V) // 输出：0 1 100 100 3
}

小贴士：iota 的核心作用是简化批量常量声明，避免重复写固定值，实际开发中，常用于状态码、枚举值、权限标识等场景，记住以上4个注意点，就能灵活使用啦。

四、Go 语言基本数据类型

Go 语言是静态强类型语言，变量必须有固定类型，我们先学习最常用的 4 种基本类型。

1. 整型（int）：存储整数

存储没有小数点的数字，正数、负数、0。

常用类型：

int：通用整型（默认有符号，根据操作系统自动适配长度，32位系统为int32，64位系统为int64）
int8、int16、int32、int64：不同范围的有符号整型（可存储正数、负数、0）
uint、uint8、uint16、uint32、uint64：不同范围的无符号整型（仅能存储非负数，0和正数）

补充说明：有符号与无符号的核心区别的是是否能存储负数，无符号整型的取值范围从0开始，有符号整型的取值范围正负对称（以int8为例：取值范围是-128~127，uint8取值范围是0~255）。

补充1：有符号与无符号整型示例：

go 复制代码

package main

import "fmt"

func main() {
	// 有符号整型（可存负数）
	var a int8 = -50   // int8：有符号，范围-128~127
	var b int32 = 1000 // int32：有符号，范围-2147483648~2147483647

	// 无符号整型（仅存非负数）
	var c uint8 = 200  // uint8：无符号，范围0~255
	var d uint32 = 5000// uint32：无符号，范围0~4294967295

	fmt.Println("有符号int8：", a)
	fmt.Println("有符号int32：", b)
	fmt.Println("无符号uint8：", c)
	fmt.Println("无符号uint32：", d)

	// 错误示例：无符号整型不能存储负数
	// var e uint8 = -10 // 编译报错：constant -10 underflow in uint8
}

补充2：字符字面量（单引号包裹，本质是整型）：

你说的「比如一个'a'，打印它的类型是整型」，指的是 字符字面量 ------ Go 语言中，用 **单引号 ''**包裹的单个字符（如 'a'、'0'、'+'），本质是 int32 类型（对应 Unicode 码值），属于整型的一种，打印时会显示其对应的 Unicode 编码值，查看类型会显示 int32（或 rune，rune 是 int32 的别名，专门用来表示字符）。

核心区别：字符串用 双引号 "" （如 "a"），是 string 类型；单个字符用 单引号 ''（如 'a'），是 int32（rune）类型，本质是整型，存储的是字符对应的 Unicode 码值。

go 复制代码

package main

import "fmt"

func main() {
	// 单引号包裹单个字符，是字符字面量，本质是int32（rune）类型
	var char1 = 'a'
	var char2 = '0'
	var char3 = '+'
	var char4 = '中' // 中文单个字符也属于字符字面量，存储其Unicode码值

	// 打印字符本身（用%c）、对应的整型值（用%d）、类型（用%T）
	fmt.Printf("字符'a'：本身=%c，对应的整型值=%d，类型=%T\n", char1, char1, char1)
	fmt.Printf("字符'0'：本身=%c，对应的整型值=%d，类型=%T\n", char2, char2, char2)
	fmt.Printf("字符'+'：本身=%c，对应的整型值=%d，类型=%T\n", char3, char3, char3)
	fmt.Printf("字符'中'：本身=%c，对应的整型值=%d，类型=%T\n", char4, char4, char4)

	// 验证：字符字面量可当作整型运算（因为本质是int32）
	fmt.Println("'a' + 1 =", char1 + 1) // 97 + 1 = 98，对应字符'b'
	fmt.Println("'0'的整型值 + 5 =", char2 + 5) // 48 + 5 = 53，对应字符'5'
}

运行结果：

Plain 复制代码

字符'a'：本身=a，对应的整型值=97，类型=int32
字符'0'：本身=0，对应的整型值=48，类型=int32
字符'+'：本身=+，对应的整型值=43，类型=int32
字符'中'：本身=中，对应的整型值=20013，类型=int32
'a' + 1 = 98
'0'的整型值 + 5 = 53

小贴士：重点区分两个易混点：① 双引号 "" → 字符串（string 类型）；② 单引号 '' → 字符字面量（int32/rune 类型，本质是整型）。你说的「打印'a'类型是整型」，就是这个原因，它存储的是字符对应的 Unicode 码值，属于整型范畴。

小贴士：新手开发中，优先使用 int（通用有符号整型）即可，无需刻意指定int8、uint等类型；只有在需要严格控制内存大小（如嵌入式开发）时，再根据需求选择具体的有符号/无符号整型。

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	var a int = 10
	var b int = -20
	fmt.Println("整型：", a, b)
}

2. 浮点型（float）：存储小数

存储带小数点的数字。

float32：单精度
float64：双精度（默认，推荐使用）

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	var price float64 = 19.99
	var pi float64 = 3.14
	fmt.Println("价格：", price)
	fmt.Println("圆周率：", pi)
}

3. 字符串类型（string）：存储文本

必须用双引号 "" 包裹，存储文字、符号等。

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	var str1 string = "Hello Go"
	var str2 string = "你好，世界"
	fmt.Println(str1)
	fmt.Println(str2)
}

4. 布尔类型（bool）：存储真假

只有两个值：true（真）、false（假）。

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	var isTrue bool = true
	var isFalse bool = false
	fmt.Println(isTrue, isFalse)
}

五、数据类型查看与转换

1. 查看变量类型

使用 fmt\.Printf\(\&\#34;%T\&\#34;, 变量\) 查看变量类型。

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	name := "测试"
	age := 20
	price := 9.9
	flag := true

	fmt.Printf("name类型：%T\n", name)
	fmt.Printf("age类型：%T\n", age)
	fmt.Printf("price类型：%T\n", price)
	fmt.Printf("flag类型：%T\n", flag)
}

2. 数据类型转换

Go 语言不支持自动类型转换，必须手动转换。

语法：

go 复制代码

目标类型(变量)

示例代码：

go 复制代码

package main

import "fmt"

func main() {
	// int 转 float64
	var a int = 100
	var b float64 = float64(a)
	fmt.Println("转换后：", b)

	// float64 转 int
	var c float64 = 99.99
	var d int = int(c)
	fmt.Println("转换后：", d)
}

六、常见错误总结（新手必看）

变量未使用：Go 中声明的变量必须使用，否则编译报错
常量修改：常量定义后不能修改，修改会直接报错
类型错误：不同类型变量不能直接运算（如int和uint、int和float64，需手动转换后再运算）
字符串用单引号：Go 字符串必须用双引号，单引号会报错

七、本篇总结

变量：存储可变数据，4 种声明方式，短变量 := 最常用
常量：存储不可变数据，用 const 声明，iota 可批量生成
基本数据类型 ：int（整型，含无符号/有符号）、float64（浮点型）、string（字符串）、bool（布尔型），补充：① 整型分有符号（int、int8等）和无符号（uint、uint8等）；② 字符字面量（单引号包裹，如'a'）本质是int32（rune）类型，属于整型，存储字符对应的Unicode码值；③ 整型字面量（如10、20）为无类型常量，可自动适配变量类型
类型查看用 %T，类型转换用 目标类型\(变量\)

本篇内容是 Go 语法的核心基础，建议把所有示例代码手动敲一遍并运行，彻底掌握变量、常量、数据类型。

下一篇我们将学习 Go 语言运算符与控制台输入输出，继续稳步进阶！

（注：文档部分内容可能由 AI 生成）