文章目录
- 一、值（Value）与字面量（Literal）
- 1. 值
- 2. 字面量
- 二、变量（Variable）
- 1. 声明方式
- 2. 赋值方式
- 3. 变量默认值
- 4. 类型与值的匹配
- 三、常量（Constant）
- 1. 声明方式
- 2. 常量的特性
- 3. 枚举与 `iota`
- 四、值类型与引用类型
- 1. 值类型（Value Type）
- 2. 引用类型（Reference Type）
- 五、内存结构与变量赋值
- 1. 进程内存结构
- 2. 赋值操作的本质
| 概念 | 定义 | 核心特点 |
|---|---|---|
| 值 | 数据的具体表示，如 10、"hello"。 | 分为基础类型值和复合类型值，通过字面量书写。 |
| 变量 | 命名的内存空间，存储值或指针。 | 强类型、可修改，声明后有零值，支持类型推断和简短声明（:=）。 |
| 常量 | 编译时确定且不可修改的值，用 const 声明。 | 支持 iota 自动生成枚举值，表达式在编译期计算，可用于定义配置和枚举。 |
| 值类型 | 直接存储值，赋值时复制数据（如 int、string、struct）。 | 栈中存储，性能高，变量独立。 |
| 引用类型 | 存储数据地址，赋值时复制指针（如 slice、map、chan）。 | 堆中存储，多个变量共享数据，修改会相互影响。 |
一、值（Value）与字面量（Literal）
先看个例子
var age = 18 // 这里的 `18` 是字面量，它代表的值是“年龄 18 岁”
age = 19 // 现在值变成了“年龄 19 岁”，但写法还是字面量 `19`
核心作用：
- 字面量是代码中 “写死” 的数据，用于初始化变量或常量。
- 值是程序运行时实际存储的数据，可能会变化（变量）或固定不变（常量）。
1. 值
值是程序中数据的具体表示，分为：
- 基础类型值：如
123（整型）、3.14（浮点型）、true（布尔）、'a'（字符）、"hello"（字符串）。- 复合类型值：如数组
[3]int{1,2,3}、切片[]string{"a","b"}、结构体struct{Name string}{"Tom"}。
2. 字面量
字面量是值的直接书写形式，用于初始化变量或常量：
- 基础字面量：
42 // 整型 3.1415 // 浮点型 true // 布尔型 '中' // 字符型（rune） "Go语言" // 字符串 - 复合字面量：构造复合类型的值（如数组、切片、映射）：
[3]int{1, 2, 3} // 数组 []string{"a", "b"} // 切片 map[string]int{"a": 1} // 映射
二、变量（Variable）
变量是存储值的内存空间的命名引用，特点：
- 强类型语言：变量必须先声明后使用，且类型固定。
- 值可修改：运行时可重新赋值。
1. 声明方式
| 方式 | 语法示例 | 说明 |
|---|---|---|
| 单个声明 | var name string | 声明变量 name，类型为 string，初始值为 ""（零值）。 |
| 批量声明 | var a, b int | 声明多个同类型变量。 |
| 批量声明（块形式） | var ( x int y string ) | 适用于声明多个不同类型的变量，代码更整洁。 |
2. 赋值方式
- 先声明后赋值：
var age int // 声明变量，初始值为 0（整型零值） age = 18 // 赋值 - 声明并初始化：
var name string = "Tom" // 显式指定类型 var score = 95 // 类型推断（根据值 `95` 推断为 int） - 简短声明（仅用于函数内）：
count := 0 // 等价于 `var count int = 0`，仅用于函数内部，简洁高效。
3. 变量默认值
变量未显式赋值时，自动赋予对应类型的零值：
- 数值类型（如
int、float32）：0 - 布尔类型（
bool）：false - 字符串（
string）：""（空字符串） - 引用类型（如切片、映射、通道）：
nil
4. 类型与值的匹配
赋值时需保证类型一致，否则编译报错：
var num int = "100" // 错误：字符串无法赋值给整型
三、常量（Constant）
常量是编译时确定且运行时不可修改的值，用于定义程序中固定不变的数据（如配置项、枚举值）。
1. 声明方式
| 方式 | 语法示例 | 说明 |
|---|---|---|
| 显式类型声明 | const PI float64 = 3.14159 | 明确指定类型和值。 |
| 隐式类型推断 | const E = 2.718 | 类型由值自动推断（float64）。 |
| 批量声明 | const ( <br> A = 1 <br> B = 2 <br> ) | 声明多个常量，可混合类型。 |
2. 常量的特性
- 不可修改：声明后无法重新赋值，否则编译报错：
const a = 10 a = 20 // 错误：cannot assign to a (constant 10) - 编译期计算：常量表达式在编译时求值，支持算术运算、类型转换等：
const ( KB = 1024 MB = KB * 1024 // 编译时计算为 1048576 )
3. 枚举与 iota
iota 是常量声明块中的自动递增计数器，用于生成枚举值：
const (
Sunday = iota // 0（iota 初始为 0）
Monday // 1（iota 自增 1）
Tuesday // 2
)
其他语法
- 跳过值：用
_跳过某个枚举值：const ( A = iota // 0 _ // 1（跳过） C // 2 ) - 复杂表达式：结合运算符生成规律值（如位掩码）：
const ( Read = 1 << iota // 1 << 0 = 1（0b0001） Write // 1 << 1 = 2（0b0010） Exec // 1 << 2 = 4（0b0100） )
四、值类型与引用类型
1. 值类型（Value Type）
- 存储方式：直接存储值本身，位于栈内存或堆内存中的数据区域。
- 常见类型：整型、浮点型、布尔型、字符型、字符串、数组、结构体（非指针结构体）。
- 特点：变量赋值时复制值，修改一个变量不影响另一个：
a := 10 b := a // b 复制 a 的值（10） b = 20 // a 仍为 10，b 变为 20
2. 引用类型（Reference Type）
- 存储方式：存储值的内存地址（指针），指向堆内存中的数据。
- 常见类型：切片（
slice）、映射（map）、通道（chan）、指针（*T）、接口（interface）。 - 特点：变量赋值时复制指针，多个变量指向同一数据，修改会互相影响：
slice1 := []int{1, 2, 3} slice2 := slice1 // slice2 与 slice1 指向同一底层数组 slice2[0] = 100 // slice1[0] 也变为 100（因共享数据）
五、内存结构与变量赋值
1. 进程内存结构
- 栈（Stack）：存放值类型变量和引用类型的指针，特点是自动分配和释放，速度快。
- 堆（Heap）：存放引用类型的数据（如切片、映射的底层数据），需手动管理（Go 通过 GC 自动回收）。
2. 赋值操作的本质
- 值类型赋值：在栈中复制值，新旧变量互不影响。
var x int = 5 var y int = x // y 复制 x 的值（5），x 和 y 是独立的栈变量。 - 引用类型赋值：复制指针（地址），新旧变量指向堆中的同一数据。
m := map[string]int{"a": 1} n := m // n 复制 m 的指针，指向同一 map 数据。 n["a"] = 100 // m["a"] 也变为 100（因共享数据）。
