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

文章目录

• • 一、值（Value）与字面量（Literal）
  • • [1. 值](#1. 值)
    • [2. 字面量](#2. 字面量)
  • 二、变量（Variable）
  • • [1. 声明方式](#1. 声明方式)
    • [2. 赋值方式](#2. 赋值方式)
    • [3. 变量默认值](#3. 变量默认值)
    • [4. 类型与值的匹配](#4. 类型与值的匹配)
  • 三、常量（Constant）
  • • [1. 声明方式](#1. 声明方式)
    • [2. 常量的特性](#2. 常量的特性)
    • [3. 枚举与 `iota`](#3. 枚举与 iota)
  • 四、值类型与引用类型
  • • [1. 值类型（Value Type）](#1. 值类型（Value Type）)
    • [2. 引用类型（Reference Type）](#2. 引用类型（Reference Type）)
  • 五、内存结构与变量赋值
  • • [1. 进程内存结构](#1. 进程内存结构)
    • [2. 赋值操作的本质](#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（因共享数据）。