切片函数文档索引

函数	说明
All	返回切片的(key-value)迭代器
Chunk	将切片分割成指定大小的块,返回块的迭代器
Clip	修剪切片的容量,使其等于长度(释放多余底层数组内存)
Clone	创建切片的浅拷贝(新分配内存并复制元素)
Collect	从迭代器收集元素到一个新的切片中
Compact	移除切片中连续重复的元素,返回压缩后的切片
CompactFunc	使用自定义比较函数移除连续重复元素
Compare	按字典序比较两个切片,返回 -1, 0, 或 1
CompareFunc	使用自定义比较函数比较两个切片
Concat	连接多个切片,返回一个新切片
Contains	检查切片是否包含指定值
ContainsFunc	使用自定义函数检查切片是否包含匹配元素
Delete	删除指定索引范围的元素,返回修改后的切片
DeleteFunc	删除所有满足指定条件的元素
Equal	判断两个切片是否相等(长度相同且对应元素相等)
EqualFunc	使用自定义比较函数判断两个切片是否相等
Grow	增加切片的容量以预留空间,避免后续追加时重新分配
Index	返回值在切片中第一次出现的索引,不存在则返回 -1
Values	返回切片的值迭代器(忽略索引)
IndexFunc	返回第一个满足条件元素的索引,不存在则返回 -1
Insert	在指定位置插入元素,返回新切片
Max	返回切片中的最大值
MaxFunc	使用自定义比较函数返回最大值
Min	返回切片中的最小值
MinFunc	使用自定义比较函数返回最小值
Repeat	将切片内容重复 n 次,返回新切片
Replace	替换指定范围的元素为新元素
Reverse	原地反转切片中的元素顺序
Sort	原地对切片进行排序(要求元素可比较)
SortFunc	使用自定义比较函数原地排序
Sorted	返回排序后的新切片(不修改原切片)
SortedFunc	使用自定义比较函数返回排序后的新切片
IsSorted	检查切片是否已排序
IsSortedFunc	使用自定义比较函数检查切片是否已排序

---

示例代码

package main

import (
	"fmt"
	"slices"
)

func main() {
	nums := []int{11, 33, 55}

	// ===== 1. slices.All 方法 =====
	// 输出如下: 说明返回的是一个迭代器指针
	// iter.Seq2[int,int] 	 0x5a14460
	iter := slices.All(nums)
	fmt.Printf("%T \t %v \n", iter, iter)

	// 迭代器是可以被遍历的
	// 0 : 11
	// 1 : 33
	// 2 : 55
	for i, v := range iter {
		fmt.Printf("%v : %v \n", i, v)
	}

	// ===== 2. slices.Chunk 方法 =====
	// 将切片分割成大小为 2 的块
	data := []int{1, 2, 3, 4, 5}
	fmt.Println("\n=== Chunk ===")
	for chunk := range slices.Chunk(data, 2) {
		fmt.Printf("块: %v\n", chunk)
	}
	// 输出:
	// 块: [1 2]
	// 块: [3 4]
	// 块: [5]

	// ===== 3. slices.Clip 方法 =====
	// 修剪容量,使其等于长度
	sliceWithCap := make([]int, 3, 10)
	fmt.Printf("\n=== Clip ===\nBefore: len=%d, cap=%d\n", len(sliceWithCap), cap(sliceWithCap))
	clipped := slices.Clip(sliceWithCap)
	fmt.Printf("After:  len=%d, cap=%d\n", len(clipped), cap(clipped))

	// ===== 4. slices.Clone 方法 =====
	// 创建副本
	original := []int{1, 2, 3}
	clone := slices.Clone(original)
	clone[0] = 99
	fmt.Printf("\n=== Clone ===\nOriginal: %v\nClone:    %v\n", original, clone)

	// ===== 5. slices.Compact 方法 =====
	// 移除连续重复元素
	dup := []int{1, 1, 2, 2, 2, 3, 1}
	compact := slices.Compact(dup)
	fmt.Printf("\n=== Compact ===\nBefore: %v\nAfter:  %v\n", dup, compact)

	// ===== 6. slices.Concat 方法 =====
	// 连接切片
	s1 := []int{1, 2}
	s2 := []int{3, 4}
	concat := slices.Concat(s1, s2)
	fmt.Printf("\n=== Concat ===\nResult: %v\n", concat)

	// ===== 7. slices.Contains 方法 =====
	// 检查是否存在
	has33 := slices.Contains(nums, 33)
	has99 := slices.Contains(nums, 99)
	fmt.Printf("\n=== Contains ===\nHas 33: %v, Has 99: %v\n", has33, has99)

	// ===== 8. slices.Delete 方法 =====
	// 删除索引 1 到 2 (不含2) 的元素,即删除索引1的元素
	delSlice := []int{10, 20, 30, 40}
	deleted := slices.Delete(delSlice, 1, 2)
	fmt.Printf("\n=== Delete ===\nBefore: %v\nAfter:  %v\n", delSlice, deleted)

	// ===== 9. slices.Equal 方法 =====
	// 比较相等
	eq := slices.Equal([]int{1, 2}, []int{1, 2})
	fmt.Printf("\n=== Equal ===\n[1,2] == [1,2]: %v\n", eq)

	// ===== 10. slices.Grow 方法 =====
	// 预分配容量
	growSlice := []int{1}
	grown := slices.Grow(growSlice, 100)
	fmt.Printf("\n=== Grow ===\nNew Cap >= 100: %v\n", cap(grown) >= 100)

	// ===== 11. slices.Index 方法 =====
	// 查找索引
	idx := slices.Index(nums, 55)
	notFound := slices.Index(nums, 100)
	fmt.Printf("\n=== Index ===\nIndex of 55: %v, Index of 100: %v\n", idx, notFound)

	// ===== 12. slices.Insert 方法 =====
	// 插入元素
	insertSlice := []int{1, 2, 4}
	inserted := slices.Insert(insertSlice, 2, 3) // 在索引2处插入3
	fmt.Printf("\n=== Insert ===\nResult: %v\n", inserted)

	// ===== 13. slices.Max / Min 方法 =====
	maxVal := slices.Max(nums)
	minVal := slices.Min(nums)
	fmt.Printf("\n=== Max/Min ===\nMax: %v, Min: %v\n", maxVal, minVal)

	// ===== 14. slices.Reverse 方法 =====
	// 反转 (原地)
	revSlice := []int{1, 2, 3}
	slices.Reverse(revSlice)
	fmt.Printf("\n=== Reverse ===\nResult: %v\n", revSlice)

	// ===== 15. slices.Sort / Sorted 方法 =====
	// Sort 是原地排序
	sortSlice := []int{3, 1, 2}
	slices.Sort(sortSlice)
	fmt.Printf("\n=== Sort (In-place) ===\nResult: %v\n", sortSlice)

	// Sorted 返回新切片
	unsorted := []int{5, 3, 9}
	sortedNew := slices.Sorted(unsorted)
	fmt.Printf("=== Sorted (New) ===\nOriginal: %v, New: %v\n", unsorted, sortedNew)

	// ===== 16. slices.IsSorted 方法 =====
	isSorted := slices.IsSorted(sortedNew)
	fmt.Printf("=== IsSorted ===\nIs [3,5,9] sorted? %v\n", isSorted)
}