常用 Go 库函数汇总

常用 Go 库函数汇总

1. sort.Sort / sort.Stable

• 说明：对切片进行排序，sort.Stable 保证排序时相等元素的相对顺序不变。

• 示例：

  import "sort"
  
  // 使用 sort.Sort 进行排序
  arr := []int{5, 3, 8, 1}
  sort.Sort(sort.IntSlice(arr))  // 对整数切片进行排序
  fmt.Println(arr)  // 输出: [1 3 5 8]
  
  // 使用 sort.Stable 进行稳定排序
  sort.Stable(sort.IntSlice(arr))
  fmt.Println(arr)  // 输出: [1 3 5 8]
  
  // 排序字符串切片
  strArr := []string{"banana", "apple", "cherry"}
  sort.Sort(sort.StringSlice(strArr))
  fmt.Println(strArr)  // 输出: [apple banana cherry]
  

2. sort.Slice

• 说明：sort.Slice 允许你根据自定义的排序规则对切片进行排序。

• 示例：

  import "sort"
  
  arr := []string{"banana", "apple", "cherry"}
  sort.Slice(arr, func(i, j int) bool {
      return len(arr[i]) < len(arr[j])  // 按照字符串长度排序
  })
  fmt.Println(arr)  // 输出: [apple banana cherry]
  

3. sort.Search

• 说明：在有序切片中查找满足条件的最小索引。如果没有找到匹配的元素，返回插入位置。

• 示例：

  import "sort"
  
  arr := []int{1, 3, 5, 7, 9}
  idx := sort.Search(len(arr), func(i int) bool {
      return arr[i] >= 5
  })
  fmt.Println(idx)  // 输出: 2
  

4. sort.SearchInts

• 说明：在有序整数切片中查找满足条件的最小索引。如果没有找到匹配的元素，返回插入位置。

• 示例：

  import "sort"
  
  arr := []int{1, 3, 5, 7, 9}
  idx := sort.SearchInts(arr, 5)
  fmt.Println(idx)  // 输出: 2
  

5. sort.SearchStrings

• 说明：在有序字符串切片中查找满足条件的最小索引。如果没有找到匹配的元素，返回插入位置。

• 示例：

  import "sort"
  
  arr := []string{"apple", "banana", "cherry"}
  idx := sort.SearchStrings(arr, "banana")
  fmt.Println(idx)  // 输出: 1
  

6. copy

• 说明：复制切片的内容到另一个切片。

• 示例：

  a := []int{1, 2, 3}
  b := make([]int, len(a))
  copy(b, a)
  fmt.Println(b)  // 输出: [1 2 3]
  

7. append

• 说明：向切片添加元素。

• 示例：

  arr := []int{1, 2, 3}
  arr = append(arr, 4)
  fmt.Println(arr)  // 输出: [1 2 3 4]
  

8. strings.Index / strings.IndexRune

• 说明：查找子字符串或字符第一次出现的位置，未找到时返回 -1。

• 示例：

  import "strings"
  
  s := "hello"
  idx := strings.Index(s, "l")
  fmt.Println(idx)  // 输出: 2
  

9. strings.Contains

• 说明：检查一个字符串是否包含另一个子字符串。返回true或者false

• 示例：

  import "strings"
  
  s := "hello"
  contains := strings.Contains(s, "ell")
  fmt.Println(contains)  // 输出: true
  

10. strings.Split

• 说明：将字符串按指定分隔符拆分为多个子字符串，返回一个切片。

• 示例：

  import "strings"
  
  s := "apple,banana,cherry"
  parts := strings.Split(s, ",")
  fmt.Println(parts)  // 输出: [apple banana cherry]
  

11. strings.Replace

• 说明：替换字符串中的指定部分。

• 示例：

  import "strings"
  
  s := "apple banana apple"
  result := strings.Replace(s, "apple", "orange", 2)
  fmt.Println(result)  // 输出: orange banana orange
  

strings.Replace 函数用于替换字符串中的指定子字符串。你可以指定替换的次数，或者替换所有出现的子字符串。

语法：

func Replace(s, old, new string, n int) string

• s：要进行替换操作的原始字符串。

• old：要被替换的子字符串。

• new：替换成的子字符串。

• n：指定替换的次数。如果 n 为负数，则表示替换所有出现的子字符串；如果 n 为 0，则不会做任何替换。

12. math.Min / math.Max/math.Abs/math.Pow/math.Sqrt

• 说明：返回两个数中的最小值或最大值绝对值、幂、开方。

• 示例：

  import "math"
  
  min := math.Min(3.14, 2.71)
  max := math.Max(3.14, 2.71)
  fmt.Println(min, max)  // 输出: 2.71 3.14
  fmt.Println("Min:", min, "Max:", max)  // 输出: Min: 2.71 Max: 3.14
  
  // math.Abs - 取绝对值
  absValue := math.Abs(-5.67)
  fmt.Println("Abs:", absValue)  // 输出: Abs: 5.67
  
  // math.Pow - 计算 x^y
  power := math.Pow(2, 3)
  fmt.Println("Pow(2, 3):", power)  // 输出: Pow(2, 3): 8
  
  // math.Sqrt - 计算平方根
  sqrtValue := math.Sqrt(16)
  fmt.Println("Sqrt(16):", sqrtValue)  // 输出: Sqrt(16): 4
  
  

• math.Max(x, y)：返回两个 float64 类型数中的较大值。
• math.Min(x, y)：返回两个 float64 类型数中的较小值。
• math.Abs(x)：取绝对值。
• math.Pow(x, y)：计算 x^y。
• math.Sqrt(x)：计算平方根。

13. container/heap

• 说明：提供堆数据结构，可用于实现优先队列。

• 示例：

  import (
      "container/heap"
      "fmt"
  )
  
  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.Println(heap.Pop(h))  // 输出: 1
  }
  

14. math/bits

• 说明：提供关于位操作的函数，处理二进制数据。

• 示例：

  import "math/bits"
  
  count := bits.OnesCount(7)  // 7 的二进制是 111，返回 3
  fmt.Println(count)  // 输出: 3
  

14. strings.ToUpper / strings.ToLower

• 说明：将字符串转换为大写或小写。

• 示例：

  import "strings"
  
  s := "hello"
  upper := strings.ToUpper(s)
  lower := strings.ToLower(s)
  fmt.Println(upper)  // 输出: HELLO
  fmt.Println(lower)  // 输出: hello
  

15. time.Now

• 说明：获取当前的时间。

• 示例：

  import "time"
  
  currentTime := time.Now()
  fmt.Println(currentTime)  // 输出: 当前时间
  

16. time.Sleep

• 说明：使当前 goroutine 暂停执行指定时间。

• 示例：

  import "time"
  
  fmt.Println("Start")
  time.Sleep(2 * time.Second)  // 暂停 2 秒
  fmt.Println("End")
  

17. time.Parse

• 说明：将字符串解析为时间类型。

• 示例：

  import (
      "fmt"
      "time"
  )
  
  layout := "2006-01-02 15:04:05"
  str := "2025-04-02 13:45:00"
  t, err := time.Parse(layout, str)
  if err != nil {
      fmt.Println("Error:", err)
  } else {
      fmt.Println("Parsed time:", t)  // 输出: Parsed time: 2025-04-02 13:45:00 +0000 UTC
  }
  

18.slices提供了一系列用于切片操作的高效函数。

对于 字符串切片（[]string），slices 包同样适用

📌 1. 查找相关函数

✅ 示例

package main

import (
	"fmt"
	"slices"
)

func main() {
	arr := []int{1, 3, 5, 7, 9}

	fmt.Println("最大值:", slices.Max(arr)) // 9
	fmt.Println("最小值:", slices.Min(arr)) // 1
	fmt.Println("索引:", slices.Index(arr, 5)) // 2
	fmt.Println("是否包含 3:", slices.Contains(arr, 3)) // true

	// 二分查找（前提：arr 必须是有序的）
	idx, found := slices.BinarySearch(arr, 5)
	fmt.Println("BinarySearch 结果:", idx, found) // 2 true
}

📌 2. 复制 & 截取

✅ 示例

package main

import (
	"fmt"
	"slices"
)

func main() {
	arr := []int{1, 2, 3, 4, 5}
	cloneArr := slices.Clone(arr) 
	fmt.Println("克隆切片:", cloneArr) // [1 2 3 4 5]

	// 删除索引 1 到 3 (即元素 2 和 3)
	newArr := slices.Delete(arr, 1, 3)
	fmt.Println("删除后:", newArr) // [1 4 5]
}

📌 3. 排序 & 反转

✅ 示例

package main

import (
	"fmt"
	"slices"
)

func main() {
	arr := []int{5, 2, 9, 1, 6}
	slices.Sort(arr)
	fmt.Println("排序后:", arr) // [1 2 5 6 9]

	slices.Reverse(arr)
	fmt.Println("反转后:", arr) // [9 6 5 2 1]

	fmt.Println("是否有序:", slices.IsSorted(arr)) // false
}

📌 4. 合并 & 追加

✅ 示例

package main

import (
	"fmt"
	"slices"
)

func main() {
	s1 := []int{1, 2}
	s2 := []int{3, 4}

	// 连接切片
	merged := slices.Concat(s1, s2, []int{5, 6})
	fmt.Println("合并:", merged) // [1 2 3 4 5 6]

	// 插入元素
	inserted := slices.Insert(s1, 1, 99, 100)
	fmt.Println("插入后:", inserted) // [1 99 100 2]
}

📌 5. 比较

✅ 示例

package main

import (
	"fmt"
	"slices"
)

func main() {
	s1 := []int{1, 2, 3}
	s2 := []int{1, 2, 3}
	s3 := []int{1, 2, 4}

	fmt.Println("是否相等:", slices.Equal(s1, s2)) // true
	fmt.Println("比较 s1 和 s3:", slices.Compare(s1, s3)) // -1 (s1 < s3)
}

📌 6. 去重

✅ 示例

package main

import (
	"fmt"
	"slices"
)

func main() {
	arr := []int{1, 1, 2, 3, 3, 3, 4, 5, 5}

	uniqueArr := slices.Compact(arr)
	fmt.Println("去重后:", uniqueArr) // [1 2 3 4 5]
}

总结

如果你的 Go 版本 >=1.21，可以放心使用 slices，让代码更简洁高效！🚀

常用标准库函数：最大值、最小值

• math.MaxInt8: 127

• math.MinInt8: -128

• math.MaxInt16: 32,767

• math.MinInt16: -32,768

• math.MaxInt32: 2,147,483,647

• math.MinInt32: -2,147,483,648

• math.MaxInt64: 9,223,372,036,854,775,807

• math.MinInt64: -9,223,372,036,854,775,808

• math.MaxFloat32: ≈ 3.4028235e+38

• math.MaxFloat64: ≈ 1.7976931348623157e+308

这样整合后，包括了你提到的所有功能。如果有进一步的修改需求或问题，请随时告诉我！