容器
数组和切片
在Go语言中，数组和切片是两个基本的数据结构，用于存储和操作一组元素。它们有一些相似之处，但也有许多不同之处。下面我们详细介绍数组和切片的特点、用法以及它们之间的区别。
数组
数组是固定长度的序列，存储相同类型的元素。数组的长度在定义时就固定下来，不能改变。
package main import "fmt" func main() { // 定义一个长度为5的整型数组 var arr [5]int fmt.Println(arr) // 输出: [0 0 0 0 0] // 定义并初始化一个长度为5的整型数组 arr2 := [5]int{1, 2, 3, 4, 5} fmt.Println(arr2) // 输出: [1 2 3 4 5] // 让编译器推断数组长度 arr3 := [...]int{1, 2, 3} fmt.Println(arr3) // 输出: [1 2 3] } 可以使用索引来访问和修改数组中的元素：
package main import "fmt" func main() { arr := [3]int{1, 2, 3} fmt.Println(arr[0]) // 输出: 1 arr[1] = 10 fmt.Println(arr) // 输出: [1 10 3] } 可以使用for循环来遍历数组：
package main import "fmt" func main() { arr := [3]int{1, 2, 3} for i, v := range arr { fmt.Println(i, v) } } 切片
切片是动态数组，可以按需增长。切片由三个部分组成：指针、长度和容量。指针指向数组中切片的起始位置，长度是切片中的元素个数，容量是从切片起始位置到数组末尾的元素个数。
package main import "fmt" func main() { // 创建一个长度和容量为3的整型切片 slice := make([]int, 3) fmt.Println(slice) // 输出: [0 0 0] // 定义并初始化一个切片 slice2 := []int{1, 2, 3, 4, 5} fmt.Println(slice2) // 输出: [1 2 3 4 5] } 切片可以通过数组或另一个切片生成：
package main import "fmt" func main() { arr := [5]int{1, 2, 3, 4, 5} slice := arr[1:4] fmt.Println(slice) // 输出: [2 3 4] } 可以使用内置的append函数向切片追加元素：
package main import "fmt" func main() { slice := []int{1, 2, 3} slice = append(slice, 4, 5) fmt.Println(slice) // 输出: [1 2 3 4 5] } 其他操作和数组基本一样，下面再说下数组和切片的区别：
- 长度：
- 数组的长度是固定的，定义后不能改变。
- 切片的长度是动态的，可以通过append函数增加元素。
- 灵活性：
- 数组在使用上较为僵化，因为长度固定，适用于元素数量已知且固定的场景。
- 切片更加灵活，适用于需要动态添加或删除元素的场景。
- 性能：
- 数组的访问速度通常比切片快，因为它们是固定大小的，编译器可以进行更多的优化。
- 切片在性能上稍逊，但由于其灵活性，使用更加广泛。
container包
在Go语言的标准库中，container包提供了三种常见的数据结构：堆（heap）、双向链表（list）和环形队列（ring）。这些数据结构为开发者提供了高效的插入、删除和访问操作。下面我们详细介绍这三个数据结构及其用法。
head
heap 包实现了堆数据结构。堆是一种特殊的树状结构，可以用于实现优先队列。
要使用 container/heap 包，必须定义一个实现 heap.Interface 接口的类型。该接口包含以下方法：
- Len() int：返回元素数量。
- Less(i, j int) bool：报告索引 i 处的元素是否小于索引 j 处的元素。
- Swap(i, j int)：交换索引 i 和 j 处的元素。
- Push(x interface{})：将元素 x 添加到堆中。
- Pop() interface{}：移除并返回堆中的最小元素。
这些方法要求用户明确实现堆的各种操作，增加了使用的复杂度。
package main import ( "container/heap" "fmt" ) // 定义一个实现 heap.Interface 的类型 type IntHeap []int func (h IntHeap) Len() int { return len(h) } func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } func (h *IntHeap) Push(x interface{}) { *h = append(*h, x.(int)) } func (h *IntHeap) Pop() interface{} { old := *h n := len(old) x := old[n-1] *h = old[0 : n-1] return x } func main() { h := &IntHeap{2, 1, 5} heap.Init(h) heap.Push(h, 3) fmt.Printf("最小元素: %dn", (*h)[0]) for h.Len() > 0 { fmt.Printf("%d ", heap.Pop(h)) } // 输出: 最小元素: 1 // 1 2 3 5 } list
list 包实现了双向链表（doubly linked list）。双向链表允许高效的插入和删除操作。
package main import ( "container/list" "fmt" ) func main() { l := list.New() // 在链表前插入元素 l.PushFront(1) l.PushFront(2) // 在链表后插入元素 l.PushBack(3) // 遍历链表 for e := l.Front(); e != nil; e = e.Next() { fmt.Println(e.Value) } // 输出: // 2 // 1 // 3 } ring
ring 包实现了环形队列（circular list）。环形队列是一种首尾相连的队列结构。
package main import ( "container/ring" "fmt" ) func main() { // 创建一个长度为3的环 r := ring.New(3) // 初始化环中的值 for i := 0; i < r.Len(); i++ { r.Value = i r = r.Next() } // 遍历环中的元素 r.Do(func(p interface{}) { fmt.Println(p.(int)) }) // 输出: // 0 // 1 // 2 } Channel
什么是Channel
在Go语言中，channel是用于在不同的goroutine之间进行通信的机制。它可以让一个goroutine将值发送到一个通道中，另一个goroutine从通道中接收值。channel的设计使得goroutine之间的通信和同步变得简洁而高效。
创建Channel
创建一个channel使用make函数，指定其传递的值的类型：
ch := make(chan int) 可以创建带缓冲的channel，缓冲大小在make时指定：
ch := make(chan int, 100) 发送和接收
发送和接收操作使用箭头符号<-：
ch <- 1 // 发送值1到channel value := <-ch // 从channel接收值并赋值给变量value 关闭Channel
channel可以被主动关闭，关闭channel使用close函数：
close(ch) 一旦一个channel被关闭，再往该channel发送值会导致panic，从已关闭的channel接收值将立即返回该类型的零值并且不会阻塞（如果通道里还存在未被接收的元素，这些元素也会正常返回，直到所有元素都被接收，才会开始返回零值）。
其他操作
无缓冲通道（缓冲大小为0）
- 发送操作会阻塞直到有goroutine来接收这个值。
- 接收操作会阻塞直到有值被发送到channel。
缓冲通道
- 发送操作会在缓冲区满时阻塞。
- 接收操作会在缓冲区为空时阻塞。
Select语句
select语句可以用于处理多个channel操作。它会阻塞直到其中一个channel可以进行操作。select语句中的各个分支是随机选择的：
select { case val := <-ch1: fmt.Println("Received", val) case ch2 <- 1: fmt.Println("Sent 1") default: fmt.Println("No communication") } 示例
基于channel，实现一个简单的生产者-消费者模型：
package main import ( "fmt" "time" ) func producer(ch chan int) { //循环往通道发送5个元素，间隔1秒 for i := 0; i < 5; i++ { fmt.Println("Producing", i) ch <- i time.Sleep(time.Second) } //发送完所有消息后关闭通道 close(ch) } func consumer(ch chan int) { //可以通过range遍历通道的元素 //因为生产者已经关闭了通道，所以遍历完所有元素后，循环会自己退出 for val := range ch { fmt.Println("Consuming", val) time.Sleep(time.Second) } } func main() { ch := make(chan int, 2) go producer(ch) consumer(ch) } 常见问题
- 避免在接收端关闭通道：通常由发送方负责关闭channel。
- 避免重复关闭通道：多次关闭同一个channel会导致panic。
- 避免从未使用的通道发送和接收：未使用的channel操作会导致死锁。比如只接收，没发送，程序会一直阻塞在接收处。
函数
在Go语言中，函数是一等公民（first-class citizen），这意味着函数可以像其他类型（例如整数、字符串等）一样使用和操作。这一特性使得函数的使用非常灵活和强大。具体来说，函数作为一等公民具有以下特点：
函数可以赋值给变量
你可以将一个函数赋值给一个变量，这样就可以通过这个变量来调用函数：
package main import "fmt" func main() { add := func(a, b int) int { return a + b } fmt.Println(add(3, 4)) // 输出: 7 } 函数可以作为参数传递给另一个函数
函数可以作为参数传递给其他函数，这使得可以实现高阶函数：
package main import "fmt" func applyOperation(a, b int, op func(int, int) int) int { return op(a, b) } func main() { add := func(a, b int) int { return a + b } result := applyOperation(5, 3, add) fmt.Println(result) // 输出: 8 } 函数可以作为返回值从另一个函数返回
函数可以从另一个函数返回，这使得可以动态生成函数：
package main import "fmt" func createMultiplier(factor int) func(int) int { return func(x int) int { return x * factor } } func main() { double := createMultiplier(2) triple := createMultiplier(3) fmt.Println(double(4)) // 输出: 8 fmt.Println(triple(4)) // 输出: 12 } 函数可以嵌套定义
在Go语言中，可以在函数内部定义另一个函数：
package main import "fmt" func main() { outer := func() { fmt.Println("This is the outer function.") inner := func() { fmt.Println("This is the inner function.") } inner() } outer() } 函数可以作为匿名函数
匿名函数是一种无需命名的函数，可以直接使用：
package main import "fmt" func main() { result := func(a, b int) int { return a + b }(3, 5) fmt.Println(result) // 输出: 8 } 闭包（Closures）
Go语言支持闭包，闭包是一个函数，这个函数可以捕获并记住其所在环境的变量：
package main import "fmt" func main() { x := 10 // 定义一个修改外部变量x的闭包 closure := func() int { x += 1 return x } fmt.Println(closure()) // 输出: 11 fmt.Println(x) // 输出: 11 } package main import "fmt" func main() { counter := func() func() int { count := 0 return func() int { count++ return count } }() fmt.Println(counter()) // 输出: 1 fmt.Println(counter()) // 输出: 2 fmt.Println(counter()) // 输出: 3 } 错误处理
Go语言中的错误处理方式不同于传统的异常处理机制。它采用了明确的、基于值的错误处理方法。每个函数可以返回一个错误值来表示是否出现了问题。
基本错误处理
Go语言中使用内置的error接口类型来表示错误。error接口定义如下：
type error interface { Error() string } 函数通常返回一个error类型的值来表示操作是否成功。如果没有错误，返回nil。
package main import ( "errors" "fmt" ) // 定义一个函数，返回错误 func divide(a, b int) (int, error) { if b == 0 { //如果有问题，通过New方法新建一个错误信息 return 0, errors.New("division by zero") } //如果没有错误返回nil return a / b, nil } func main() { result, err := divide(4, 2) if err != nil { fmt.Println("Error:", err) } else { fmt.Println("Result:", result) } result, err = divide(4, 0) if err != nil { fmt.Println("Error:", err) } else { fmt.Println("Result:", result) } } 自定义错误类型
除了使用errors.New创建简单错误外，Go语言允许我们定义自己的错误类型，实现更丰富的错误信息。
package main import ( "fmt" ) // 自定义错误类型 type MyError struct { Code int Message string } // 实现error接口的Error方法 func (e *MyError) Error() string { return fmt.Sprintf("Code: %d, Message: %s", e.Code, e.Message) } // 定义一个函数，返回自定义错误(只要实现了Error()方法，就可以直接返回error类型) func doSomething(flag bool) error { if !flag { return &MyError{Code: 123, Message: "something went wrong"} } return nil } func main() { err := doSomething(false) if err != nil { fmt.Println("Error:", err) // 类型断言，获取具体的错误类型 if myErr, ok := err.(*MyError); ok { fmt.Println("Custom Error Code:", myErr.Code) } } } 异常处理机制
Go语言也有类似异常的处理机制，即defer、panic和recover，但它们主要用于处理程序中不可恢复的错误。
- defer：用于延迟执行一个函数，在函数返回前执行。如果一个函数里面有多个defer语句，写在最后面的defer最先执行。
- panic：意料之外的错误，也可以手动调用。如果panic没有处理，程序会终止。
- recover：恢复panic，并停止程序终止的过程。
package main import "fmt" func main() { defer func() { //使用defer执行一个匿名函数，确保recover一定能执行 if r := recover(); r != nil { //恢复panic，此处可以进行异常处理，比如打印日志 fmt.Println("Recovered from panic:", r) } }() fmt.Println("Starting the program") //手动触发一个panic panic("Something went wrong!") fmt.Println("This line will not be executed") } 
