【Go语言基础【3】】变量、常量、值类型与引用类型

一、值（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. 声明方式

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. 声明方式

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（因共享数据）。