当前位置：首页 > news >正文

golang学习笔记：标准库slices

news 2025/10/24 8:25:42

slices 是 Go 1.21 版本新增的官方实验性包，提供了切片操作的泛型函数，主要用于简化常见切片操作。

常用方法

切片比较和查找

比较操作

// 比较切片是否相等
s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
s3 := []int{1, 2, 4}slices.Equal(s1, s2)                // true
slices.Equal(s1, s3)                // false// 使用比较函数
slices.EqualFunc(s1, s2, func(a, b int) bool {return a == b
})                                   // true// 比较结果（类似 strings.Compare）
slices.Compare(s1, s2)              // 0 (相等)
slices.Compare(s1, s3)              // -1 (s1 < s3)
slices.Compare(s3, s1)              // 1 (s3 > s1)

查找元素

nums := []int{1, 2, 3, 4, 5}// 查找元素
slices.Contains(nums, 3)            // true
slices.Contains(nums, 6)            // false// 查找索引
index := slices.Index(nums, 3)      // 2
index = slices.Index(nums, 6)       // -1 (未找到)// 从后往前查找
lastIndex := slices.LastIndex(nums, 3) // 2// 使用自定义函数查找
index = slices.IndexFunc(nums, func(n int) bool {return n > 3
})                                   // 3 (第一个大于3的元素)

切片修改操作

插入和删除


nums := []int{1, 2, 3, 4, 5}// 插入元素
nums = slices.Insert(nums, 2, 9, 10) // [1, 2, 9, 10, 3, 4, 5]// 删除元素
nums = slices.Delete(nums, 1, 3)    // [1, 10, 3, 4, 5] (删除索引1-2)// 删除指定元素
nums = slices.DeleteFunc(nums, func(n int) bool {return n%2 == 0
})                                   // [1, 3, 5] (删除所有偶数)

替换元素

nums := []int{1, 2, 3, 4, 5}// 替换元素
nums = slices.Replace(nums, 1, 3, 9, 10) // [1, 9, 10, 4, 5]// 清空切片
nums = slices.Clip(nums)             // 释放未使用的容量

切片排序和操作

排序操作

nums := []int{3, 1, 4, 1, 5, 9, 2}// 排序
slices.Sort(nums)                    // [1, 1, 2, 3, 4, 5, 9]
slices.SortFunc(nums, func(a, b int) int {return b - a  // 降序排序
})                                   // [9, 5, 4, 3, 2, 1, 1]// 检查是否已排序
slices.IsSorted(nums)                // false (因为现在是降序)
slices.IsSortedFunc(nums, func(a, b int) int {return b - a
})                                   // true// 稳定排序
type Person struct {Name stringAge  int
}
people := []Person{{"Alice", 25},{"Bob", 25},{"Charlie", 30},
}
slices.SortStableFunc(people, func(a, b Person) int {return a.Age - b.Age
})

二分查找

nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}// 二分查找（切片必须已排序）
index, found := slices.BinarySearch(nums, 5) // 4, true
index, found = slices.BinarySearch(nums, 10) // 9, false// 使用比较函数的二分查找
index, found = slices.BinarySearchFunc(nums, 5, func(a, b int) int {return a - b
}) // 4, true

切片操作工具

克隆和紧凑

// 克隆切片
original := []int{1, 2, 3}
cloned := slices.Clone(original)     // [1, 2, 3] (新切片)// 紧凑操作（去除连续重复元素）
nums := []int{1, 1, 2, 2, 3, 3, 3}
compact := slices.Compact(nums)      // [1, 2, 3]// 使用自定义比较函数的紧凑
words := []string{"a", "A", "b", "B"}
compactWords := slices.CompactFunc(words, strings.EqualFold) // ["a", "b"]

增长和容量管理

// 增加切片容量
nums := make([]int, 3, 5)           // 长度3，容量5
nums = slices.Grow(nums, 10)        // 容量至少增加10// 获取切片容量信息
fmt.Println(cap(nums))              // 至少15

工具函数

package sliceutilimport "slices"// 反转切片
func Reverse[T any](slice []T) []T {result := slices.Clone(slice)for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 {result[i], result[j] = result[j], result[i]}return result
}// 分组
func GroupBy[T any, K comparable](slice []T, keyFunc func(T) K) map[K][]T {groups := make(map[K][]T)for _, item := range slice {key := keyFunc(item)groups[key] = append(groups[key], item)}return groups
}// 检查所有元素满足条件
func All[T any](slice []T, predicate func(T) bool) bool {return !slices.ContainsFunc(slice, func(elem T) bool {return !predicate(elem)})
}// 检查任一元素满足条件
func Any[T any](slice []T, predicate func(T) bool) bool {return slices.ContainsFunc(slice, predicate)
}// 求交集
func Intersection[T comparable](a, b []T) []T {var result []Tfor _, item := range a {if slices.Contains(b, item) && !slices.Contains(result, item) {result = append(result, item)}}return result
}// 求差集
func Difference[T comparable](a, b []T) []T {return slices.DeleteFunc(slices.Clone(a), func(elem T) bool {return slices.Contains(b, elem)})
}