Go语言基础：变量与类型

1. 变量声明基础

Go语言的变量声明需要显式指定类型或通过初始化值推断类型，支持多种声明方式：

示例：基本变量声明

package main

import "fmt"

func main() {
    // 标准声明方式
    var a int = 10
    var b string = "hello"

    // 类型推断声明
    var c = 3.14  // 推断为float64
    d := true     // 短变量声明（仅在函数内使用）

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

关键点说明：

`var`关键字用于包级或函数内变量声明
短变量声明`:=`仅能在函数内部使用
未初始化的变量会赋予零值（int:0, string:"", bool:false）

2. 复合类型变量

Go支持数组、切片、映射等复合类型，以下是切片（Slice）的声明示例：

示例：切片变量声明

func main() {
    // 声明并初始化切片
    var nums []int = []int{1, 2, 3}
    fruits := []string{"apple", "banana", "orange"}

    // 动态创建切片（长度3，容量5）
    scores := make([]int, 3, 5)

    // 切片操作
    subNums := nums[1:3]  // 取索引1到2（不包含3）的元素

    fmt.Println(nums, fruits, scores, subNums)
}

注意事项：

切片是引用类型，修改子切片会影响原切片
`make`函数用于创建带初始空间的切片
切片长度（len）和容量（cap）是不同的概念

3. 变量作用域

Go的变量作用域由大括号`{}`界定，包级变量在整个包内可见，函数内变量仅在函数内可见：

示例：作用域演示

var packageVar = "包级变量"

func main() {
    var funcVar = "函数内变量"
    fmt.Println(packageVar, funcVar)

    if true {
        var blockVar = "代码块变量"
        fmt.Println(blockVar)
    }
    // fmt.Println(blockVar)  // 错误：blockVar在此作用域不可见
}

作用域规则：

包级变量首字母大写可被其他包访问
内层作用域可覆盖外层同名变量（不推荐）
代码块（if/for/switch）内声明的变量仅在块内有效

4. 指针类型

指针存储变量的内存地址，使用`&`获取地址，`*`解引用地址。指针在传递大结构体时可避免拷贝开销：

示例：指针使用

package main

import "fmt"

func main() {
    var a int = 10
    var p *int = &a  // 声明指针变量p，指向a的地址

    fmt.Printf("a的值：%d，a的地址：%p\n", a, &a)
    fmt.Printf("p的值（a的地址）：%p，p指向的值：%d\n", p, *p)

    *p = 20  // 通过指针修改a的值
    fmt.Println("修改后a的值：", a)
}

关键特性：

Go不支持指针运算（如p++），避免内存安全问题
空指针值为`nil`，使用前需检查
函数参数使用指针可实现引用传递（修改形参会影响实参）

5. 类型别名与自定义类型

类型别名（`type Alias = Original`）用于简化复杂类型声明，自定义类型（`type NewType Original`）创建新类型并可添加方法：

示例：类型别名与自定义类型

package main

import "fmt"

// 类型别名（本质是原类型）
type IntList = []int

// 自定义类型（新类型）
type UserID int

// 为自定义类型添加方法
func (id UserID) String() string {
    return fmt.Sprintf("UID-%d", id)
}

func main() {
    var list IntList = []int{1, 2, 3}  // 等价于[]int
    var uid UserID = 1001

    fmt.Println("列表：", list)
    fmt.Println("用户ID：", uid.String())  // 调用自定义方法
}

核心区别：

类型别名与原类型完全等价，可相互赋值
自定义类型是新类型，需显式转换才能与原类型赋值
自定义类型可绑定方法，实现面向对象编程

6. 常量与枚举

常量使用`const`声明，枚举通过`iota`实现自增常量组。常量值在编译时确定，支持数值、字符串、布尔类型：

示例：常量与枚举

package main

import "fmt"

// 常量组（无类型常量）
const (
    Pi = 3.1415926
    MaxConnections = 1000
    AppName = "Go学习工具"
)

// 枚举（使用iota）
const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

func main() {
    fmt.Printf("圆周率：%.4f，最大连接数：%d，应用名：%s\n", Pi, MaxConnections, AppName)
    fmt.Printf("星期三对应的枚举值：%d\n", Wednesday)
}

进阶用法：

`iota`在常量组中从0开始递增，每行自增1
支持表达式：`const (A = iota*2; B; C)`则A=0, B=2, C=4
类型化常量（如`const a int = 10`）需显式转换类型

7. 类型转换与断言

Go语言强类型，不同类型需显式转换；接口类型需通过类型断言判断具体类型：

示例：类型转换与断言

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 数值类型转换
    var i int = 10
    var j int32 = int32(i)

    // 字符串转整数
    str := "123"
    num, _ := strconv.Atoi(str)

    // 接口类型断言
    var x interface{} = "hello"
    if s, ok := x.(string); ok {
        fmt.Printf("x是字符串类型：%s\n", s)
    }

    fmt.Printf("i=%d, j=%d, num=%d\n", i, j, num)
}

注意事项：

转换可能导致精度丢失（如float64转int）
字符串与数值转换需使用`strconv`包
类型断言失败时`ok`为false，避免运行时panic