3. Go 基本语法：变量、常量、数据类型

Go 语言是一门 静态强类型（Static Typing）、自动垃圾回收（GC）、高并发支持 的编程语言。本篇文章将深入剖析 Go 语言的 变量、常量、数据类型，并通过源码解析其底层实现。

1. 变量（Variable）

1.1 变量声明方式

Go 语言提供了 三种方式 来声明变量：

package main

import "fmt"

func main() {
    // 方式 1：使用 var 显式声明变量（全局 & 局部变量均可用）
    var name string = "Go语言"
    var age int = 10

    // 方式 2：类型推导（可以省略变量类型）
    var version = 1.21

    // 方式 3：短变量声明（仅限于函数内部）
    language := "Go"

    fmt.Println(name, age, version, language)
}

✅ 关键点：
• var 方式可用于 全局变量 或 局部变量
• := 只能用于函数内部，Go 不支持 var 和 := 同时使用
• Go 语言的变量必须初始化，否则默认赋值为零值

1.2 变量的零值（Zero Value）
Go 语言的变量如果未初始化，则会被赋予 默认零值：

package main

import "fmt"

func main() {
    var a int     // 默认 0
    var b float64 // 默认 0.0
    var c string  // 默认 ""
    var d bool    // 默认 false

    fmt.Println(a, b, c, d)
}

✅ Go 语言没有 “undefined” 概念，每个变量都有一个默认值！

1.3 多变量声明

var x, y int = 10, 20
var a, b, c = "hello", 3.14, true

// 省略 var 的多变量声明（仅限函数内部）
m, n := 5, "golang"

2. 常量（Constant）

常量（const）是 不可修改 的变量，一旦定义后值不能改变。

2.1 基本常量

package main

import "fmt"

func main() {
    const Pi float64 = 3.14159
    const Language = "Go"

    fmt.Println(Pi, Language)
}

✅ const 不能使用 := 赋值！

2.2 多个常量声明

const (
    StatusOK    = 200
    StatusError = 500
)

2.3 iota 枚举
iota 是 Go 语言独有的枚举类型，用于 自增整数：

const (
    A = iota // 0
    B        // 1
    C        // 2
)

✅ iota 可以进行位运算，用于权限控制：

const (
    Read    = 1 << iota // 1  (1 << 0)
    Write              // 2  (1 << 1)
    Execute            // 4  (1 << 2)
)

💡 iota 是 const 作用域内的，新 const 作用域 iota 重新计数。

3. 数据类型（Data Types）

Go 语言是 静态强类型语言，每个变量的类型在编译时就已经确定。
3.1 基本数据类型

3.2 数值类型示例

package main

import "fmt"

func main() {
    var a int = 100
    var b float64 = 3.14
    var c bool = true
    var d string = "Hello"

    fmt.Println(a, b, c, d)
}

3.3 类型转换
Go 不支持 隐式类型转换，必须手动转换：

package main

import "fmt"

func main() {
    var a int = 10
    var b float64 = float64(a) // int 转 float64
    var c string = fmt.Sprintf("%d", a) // int 转 string

    fmt.Println(b, c)
}

4. 复合数据类型

Go 还支持 数组、切片、映射（Map）、结构体（Struct） 等数据结构。
4.1 数组（Array）
数组长度 固定：

var arr = [3]int{1, 2, 3}
fmt.Println(arr)

4.2 切片（Slice）
切片长度 可变：

var slice = []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice)

4.3 Map（键值对）

var person = map[string]int{
    "Alice": 25,
    "Bob":   30,
}
fmt.Println(person["Alice"])

5. 指针（Pointer）

Go 语言支持 指针，但 不支持指针运算：

package main

import "fmt"

func main() {
    var x int = 10
    var p *int = &x // 指针指向 x 的地址

    fmt.Println("x =", x)   // 10
    fmt.Println("p =", p)   // x 的内存地址
    fmt.Println("*p =", *p) // 10（解引用）
}

✅ Go 语言没有 NULL，指针的零值是 nil。

6. 练习题

📝 思考题

1. 试着定义一个 const 变量，并尝试修改它，观察错误信息。
2. 使用 iota 定义一个枚举类型，例如表示 星期几。
3. 编写一个程序，使用 := 声明变量并计算两个整数相加的结果。

7. 总结

✅ 变量用 var 声明，函数内可用 := 省略 var
✅ 变量有默认零值，未初始化时会自动赋值
✅ 常量用 const，且值不可修改
✅ iota 可用于枚举自增常量
✅ 数据类型分为 基本类型（int、float、string、bool） 和 复合类型（数组、切片、Map）
✅ Go 不支持隐式类型转换，需要手动转换