在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]
}
其他操作和数组基本一样，下面再说下数组和切片的区别：
在Go语言的标准库中，container包提供了三种常见的数据结构：堆（heap）、双向链表（list）和环形队列（ring）。这些数据结构为开发者提供了高效的插入、删除和访问操作。下面我们详细介绍这三个数据结构及其用法。
heap 包实现了堆数据结构。堆是一种特殊的树状结构，可以用于实现优先队列。
要使用 container/heap 包，必须定义一个实现 heap.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("最小元素: %d\n", (*h)[0])
for h.Len() > 0 {
fmt.Printf("%d ", heap.Pop(h))
}
// 输出: 最小元素: 1
// 1 2 3 5
}
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 包实现了环形队列（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
}
在Go语言中，channel是用于在不同的goroutine之间进行通信的机制。它可以让一个goroutine将值发送到一个通道中，另一个goroutine从通道中接收值。channel的设计使得goroutine之间的通信和同步变得简洁而高效。
创建一个channel使用make函数，指定其传递的值的类型：
ch := make(chan int)
可以创建带缓冲的channel，缓冲大小在make时指定：
ch := make(chan int, 100)
发送和接收操作使用箭头符号<-：
ch <- 1 // 发送值1到channel
value := <-ch // 从channel接收值并赋值给变量value
channel可以被主动关闭，关闭channel使用close函数：
close(ch)
一旦一个channel被关闭，再往该channel发送值会导致panic，从已关闭的channel接收值将立即返回该类型的零值并且不会阻塞（如果通道里还存在未被接收的元素，这些元素也会正常返回，直到所有元素都被接收，才会开始返回零值）。
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)
}
在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
}
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，但它们主要用于处理程序中不可恢复的错误。
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")
}
突然之间各行各业从业者开始担忧被 ChatGPT 替代……「初看以为是热点，再看已成经典…」于是我决定好好研究它一番，并力争把它写得全面而通俗易懂一点，最终就有了这篇万字长文报告，建议收藏、慢慢阅读。