常用函数

https://pkg.go.dev/builtin 如果访问不了 https://pkg.go.dev 可以使用国内镜像:

• 国内镜像
• 中文文档-许久没更新过比较老

函数	说明
append(slice, elems)	向切片末尾追加元素（可多个），返回新切片；若切片容量不足会自动扩容
cap(v)	返回容器的容量：切片/数组返回最大可容纳元素数，通道返回缓冲区容量
clear(t)	清空容器内容：切片置零长度（保留容量），map清空所有键值对，通道无操作
close(c)	关闭通道（仅发送方调用），关闭后无法发送数据，但可接收剩余数据
complex(r, i)	创建复数：r 为实部，i 为虚部，返回 complex128 类型复数
copy(dst, src)	将 src 切片数据复制到 dst 切片，返回实际复制的元素个数（取两者长度最小值）
delete(m, key)	删除 map 中指定 key 对应的键值对；若 key 不存在，无任何副作用
imag(c)	返回复数 c 的虚部，类型为 float64
len(v)	返回容器的长度：切片/数组返回元素个数，字符串返回字节数，通道返回待接收元素数
make(t, size)	创建并初始化切片、map、通道：切片需指定长度（可选容量），map 指定初始空间，通道指定缓冲区容量
max(x, y)	返回多个同类型参数中的最大值；参数需为可比较类型（如数值、字符串）
min(x, y)	返回多个同类型参数中的最小值；参数需为可比较类型（如数值、字符串）
new()	分配内存：创建指定类型的指针，指向零值初始化的该类型变量
panic(v)	触发运行时恐慌（异常），终止当前 goroutine 执行；可被 recover 捕获
print(args)	底层打印函数：输出参数内容，无换行，仅用于调试（不推荐生产环境使用）
println(args)	底层打印函数：输出参数内容并换行，仅用于调试（不推荐生产环境使用）
real(c)	返回复数 c 的实部，类型为 float64
recover()	捕获 panic 抛出的异常，恢复程序执行；仅在 defer 函数中调用有效

使用示例

package main

import "fmt"

func main() {
    // ===== append: 向切片末尾追加元素 =====
    slice := []int{1, 2, 3}
    slice = append(slice, 4, 5)          // 追加多个元素
    slice = append(slice, []int{6, 7}...) // 追加另一个切片
    fmt.Printf("append示例: %v\n", slice)

    // 特殊情况：追加字符串到字节切片
    bytes := []byte("hello ")
    bytes = append(bytes, "world"...)
    fmt.Printf("追加字符串: %s\n", string(bytes))

    // ===== cap: 返回容器的容量 =====
    arr := [5]int{1, 2, 3}
    slice2 := arr[0:3]
    fmt.Printf("\ncap示例:\n")
    fmt.Printf("数组容量: %d\n", cap(arr))
    fmt.Printf("切片容量: %d\n", cap(slice2))

    // 创建带初始容量的切片
    slice3 := make([]int, 3, 10) // 长度3，容量10
    fmt.Printf("自定义容量切片 - 长度: %d, 容量: %d\n", len(slice3), cap(slice3))

    // ===== clear: 清空容器内容 =====
    // 切片示例
    numbers := []int{1, 2, 3, 4, 5}
    clear(numbers) // 将所有元素置为零值
    fmt.Printf("\nclear切片示例: %v (长度: %d, 容量: %d)\n", numbers, len(numbers), cap(numbers))

    // map示例
    scores := map[string]int{"Alice": 95, "Bob": 88, "Charlie": 92}
    clear(scores) // 删除所有键值对
    fmt.Printf("clear map示例: %v (长度: %d)\n", scores, len(scores))

    // ===== close: 关闭通道 =====
    fmt.Println("\nclose通道示例:")
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
    close(ch) // 关闭通道

    // 从已关闭通道接收数据
    for val := range ch {
        fmt.Printf("接收值: %d\n", val)
    }

    // 尝试从已关闭通道接收
    val, ok := <-ch
    fmt.Printf("通道已关闭，再次接收: 值=%d, 成功=%t\n", val, ok)

    // ===== complex: 创建复数 =====
    c1 := complex(3, 4)     // 创建complex128
    c2 := complex(1.5, 2.5) // 另一个复数
    fmt.Printf("\ncomplex示例:\n")
    fmt.Printf("复数 c1 = %v\n", c1)
    fmt.Printf("复数 c2 = %v\n", c2)
    fmt.Printf("c1 + c2 = %v\n", c1+c2)

    // ===== copy: 复制切片内容 =====
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, 3) // 目标切片长度为3
    n := copy(dst, src)   // 复制3个元素
    fmt.Printf("\ncopy示例:\n")
    fmt.Printf("源切片: %v\n", src)
    fmt.Printf("目标切片: %v\n", dst)
    fmt.Printf("复制元素数量: %d\n", n)

    // 重叠复制
    data := []int{1, 2, 3, 4, 5}
    copy(data[2:], data[1:]) // 重叠复制
    fmt.Printf("重叠复制结果: %v\n", data)

    // ===== delete: 从map中删除键值对 =====
    inventory := map[string]int{
        "apple":  10,
        "banana": 20,
        "orange": 15,
    }
    fmt.Printf("\ndelete示例 (删除前): %v\n", inventory)
    delete(inventory, "banana") // 删除指定键
    fmt.Printf("删除后: %v\n", inventory)

    // 尝试删除不存在的键
    delete(inventory, "grape") // 无副作用
    fmt.Printf("删除不存在的键后: %v\n", inventory)

    // ===== imag: 获取复数的虚部 =====
    c := complex(5, 12)
    imaginaryPart := imag(c)
    fmt.Printf("\nimag示例:\n")
    fmt.Printf("复数: %v\n", c)
    fmt.Printf("虚部: %v\n", imaginaryPart)
    fmt.Printf("类型: %T\n", imaginaryPart)

    // ===== len: 返回容器的长度 =====
    str := "Hello, 世界" // 包含中文字符
    fmt.Printf("\nlen示例:\n")
    fmt.Printf("字符串 \"%s\" 的字节数: %d\n", str, len(str)) // 注意：返回字节数而非字符数

    arr2 := [4]int{1, 2, 3, 4}
    fmt.Printf("数组长度: %d\n", len(arr2))

    slice4 := []string{"a", "b", "c"}
    fmt.Printf("切片长度: %d\n", len(slice4))

    m := map[string]int{"x": 1, "y": 2, "z": 3}
    fmt.Printf("map长度: %d\n", len(m))

    ch2 := make(chan int, 5)
    ch2 <- 1
    ch2 <- 2
    fmt.Printf("通道待接收元素数: %d\n", len(ch2))

    // ===== make: 创建并初始化容器 =====
    // 创建切片
    s1 := make([]int, 3, 5) // 长度3，容量5
    fmt.Printf("\nmake切片示例: %v (长度: %d, 容量: %d)\n", s1, len(s1), cap(s1))

    // 创建map
    m1 := make(map[string]int, 10) // 初始容量10
    m1["key"] = 42
    fmt.Printf("make map示例: %v\n", m1)

    // 创建通道
    ch3 := make(chan string, 2) // 缓冲区大小为2
    ch3 <- "hello"
    ch3 <- "world"
    fmt.Printf("make通道示例: 可发送2条消息而不阻塞\n")
    fmt.Printf("接收到: %s, %s\n", <-ch3, <-ch3)

    // ===== max/min: 返回最大/最小值 =====
    fmt.Printf("\nmax/min示例:\n")
    fmt.Printf("max(10, 20, 15) = %d\n", max(10, 20, 15))
    fmt.Printf("min(10.5, 20.3, 5.7) = %.1f\n", min(10.5, 20.3, 5.7))
    fmt.Printf("max(\"apple\", \"banana\", \"cherry\") = %s\n", max("apple", "banana", "cherry"))
    fmt.Printf("min(\"apple\", \"banana\", \"cherry\") = %s\n", min("apple", "banana", "cherry"))

    // ===== new: 分配内存 =====
    p := new(int)    // 分配一个int的内存，返回*int
    *p = 42
    fmt.Printf("\nnew示例:\n")
    fmt.Printf("指针: %p, 值: %d\n", p, *p)

    type Person struct {
        Name string
        Age  int
    }
    p2 := new(Person) // 分配结构体内存
    p2.Name = "Alice"
    p2.Age = 30
    fmt.Printf("结构体指针: %+v\n", p2)

    // ===== panic/recover: 异常处理 =====
    fmt.Println("\npanic/recover示例:")
    fmt.Println("开始执行函数")

    // 正常使用 recover 需要在 defer 中
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("捕获到panic: %v\n", r)
            fmt.Println("程序从panic中恢复，继续执行")
        }
    }()

    fmt.Println("即将触发panic")
    panic("这是一个测试panic")
    fmt.Println("这行代码不会执行") // 不会执行

    // ===== print/println: 底层打印函数 =====
    // 注意：这些函数主要用于引导和调试，不推荐在生产代码中使用
    fmt.Println("\nprint/println示例 (输出到stderr，格式不保证):")
    print("这是print输出，")
    println("这是println输出 (会自动换行)")
    println("可以输出多个值:", 42, true, "文本")

    // ===== real: 获取复数的实部 =====
    c3 := complex(7, 24)
    realPart := real(c3)
    fmt.Printf("\nreal示例:\n")
    fmt.Printf("复数: %v\n", c3)
    fmt.Printf("实部: %v\n", realPart)
    fmt.Printf("类型: %T\n", realPart)

    // 复数运算示例
    magnitude := math.Sqrt(real(c3)*real(c3) + imag(c3)*imag(c3))
    fmt.Printf("复数的模: %.1f\n", magnitude)
}