GoLang学习笔记

1.变量声明

go语言的变量类型大致可以分为string（字符串类型），bool（布尔类型），int（整型），float（浮点型），complex（复数类型），array（数组类型），slice（切片类型），map（映射类型），struct（结构体），pointer（指针），channel（通道），function（函数），interface（接口）。下面是一些变量声明的例子。当然也可以不给变量赋予类型，这个时候go会根据变量的值自动推算出类型

// 常规声明
var a string = "123" 
var b int = 123
var c float32 = 123.456
var d bool = true
var e []int = []int{1, 2, 3}
var f []string = []string{"a", "b", "c"}
var g map[string]int = map[string]int{"a": 1, "b": 2, "c": 3}
var h map[string]string = map[string]string{"a": "a", "b": "b", "c": "c"}

// 简短声明
i := "123"
j := 123
k := 123.456
l := true
m := []int{1, 2, 3}
n := []string{"a", "b", "c"}
o := map[string]int{"a": 1, "b": 2, "c": 3}
p := map[string]string{"a": "a", "b": "b", "c": "c"}

2.条件判断

可以条件判断的{}前给变量赋值，这个变量只在这个条件判断中有用

if test := 3; test == 123 {
	fmt.Println("test是3")
}

switch test := 3; test {
    case 1:
        fmt.Println("test是1")
    case 2:
        fmt.Println("test是2")
    case 3:
        fmt.Println("test是3")
    default:
        fmt.Println("test是其他值")
}

3.循环遍历

Go 语言提供了多种循环遍历方式，适用于不同的数据结构（如数组、切片、映射、字符串等），核心是 for 循环（Go 中没有 while 或 do-while，统一用 for 实现）。以下是常见的遍历方式：

// for循环
nums := []int{10, 20, 30, 40}
for i := 0; i < len(nums); i++ {
    fmt.Printf("索引 %d: %d\n", i, nums[i])
}

// for range 循环（最常用，迭代元素）
// 遍历数组/切片（额外注意的是for range循环遍历的是副本，因此改变其v的值并不会影响原数组或切片）
fruits := []string{"苹果", "香蕉", "橙子"}
for i, v := range fruits {
    fmt.Printf("索引 %d: %s\n", i, v)
}

//遍历map
scores := map[string]int{"数学": 90, "语文": 85, "英语": 95}
for subject, score := range scores {
    fmt.Printf("%s: %d分\n", subject, score)
}

 4.内置常用方法

// 1.len（获取集合类型的长度，支持字符串、数组、切片、映射（map）、通道（channel））
s := "hello"
fmt.Println(len(s)) // 输出：5（字符串字节数）

// 2.cap（返回容量，仅适用于数组、切片、通道）
nums := make([]int, 3, 5) // 长度3，容量5
fmt.Println(cap(nums)) // 输出：5

// 3.数值类型转换（go语言没有隐式的类型转换，所以需要显式的调用）
// int(x)、int8(x)、int16(x)、int32(x)、int64(x)
// uint(x)、uint8(x)、uint16(x)
// float32(x)、float64(x)
// complex64(x)、complex128(x)
a := 10
b := float64(a) // int 转 float64
fmt.Println(b) // 输出：10.0

// 4.complex创建复数
c := complex(3, 4) // 等价于 3+4i
fmt.Println(c) // 输出：(3+4i)

// 5.real(c) 和 imag(c)(分别获取复数的实部和虚部)
c := 3 + 4i
fmt.Println(real(c)) // 输出：3
fmt.Println(imag(c)) // 输出：4

// 6.new(Type)(为类型 Type 分配内存，返回指向该类型零值的指针（*Type）)
p := new(int) // 分配 int 类型内存，p 是 *int，指向 0
fmt.Println(*p) // 输出：0

// 7.make(Type, size) 和 make(Type, size, cap)(初始化引用类型（切片、映射、通道），返回类型本身（非指针）)
s := make([]int, 3) // 切片：长度3，容量3
m := make(map[string]int) // 映射：初始化空 map
ch := make(chan int, 5) // 通道：带缓冲，容量5

// 8.panic(v interface{})(触发运行时恐慌（异常），中断程序正常流程，跳转到最近的 recover 处理)
func test() {
    panic("发生错误") // 触发恐慌
}

// 9.recover()(捕获 panic 抛出的异常，恢复程序执行（仅在 defer 语句中有效）)
defer func() {
    if err := recover(); err != nil {
        fmt.Println("捕获错误:", err) // 输出：捕获错误: 发生错误
    }
}()
panic("发生错误")

// 10.append(slice []Type, elems ...Type) []Type（向切片追加元素，返回新切片（原切片可能因扩容指向新数组））
s := []int{1, 2}
s = append(s, 3, 4)
fmt.Println(s) // 输出：[1 2 3 4]

// 11.copy(dst, src []Type) int(将源切片 src 的元素复制到目标切片 dst，返回实际复制的元素数（取两者长度的最小值）)
src := []int{1, 2, 3}
dst := make([]int, 2)
n := copy(dst, src)
fmt.Println(dst, n) // 输出：[1 2] 2

// 12.delete(m map[Type]Type1, key Type)(从映射 m 中删除键 key 对应的键值对（若键不存在，无效果）)
m := map[string]int{"a": 1, "b": 2}
delete(m, "a")
fmt.Println(m) // 输出：map[b:2]