嗨，大家好！本文是系列文章 Go 小技巧第三篇，系列文章查看：Go 语言小技巧。

在 Go 语言中，切片拼接是一项常见的操作，但如果处理不当，可能会导致性能问题或意外的副作用。

本文将详细介绍几种高效的切片拼接方法，包括它们的优缺点以及适用场景。

切片拼接的必要性

在 Go 中，切片是一种动态数组，常用于存储和处理一系列相同类型的数据。

在实际应用中，我们经常需要将两个或多个切片合并为一个新的切片，例如在处理字符串、整数列表或自定义结构体数组时。

这种需求促使我们探索更高效的切片拼接方法。

基本拼接方法及其局限性

使用 append 函数

最直接的方法是使用 append 函数，它可以将一个切片的元素追加到另一个切片的末尾。

1
2
3

slice1 := []int{1, 2}
slice2 := []int{3, 4}
result := append(slice1, slice2...)

虽然这种方法简单快捷，但它有一个局限性：当 slice1 的容量不足以容纳所有元素时，Go 会分配一个新的底层数组。这可能导致性能问题，特别是在处理大型切片时。

高效拼接的策略

为了克服基本方法的局限性，我们可以采取以下策略：

控制容量和避免副作用

为了避免不必要的内存分配和潜在的副作用，我们可以先检查第一个切片的容量是否足够。如果不够，可以先创建一个新的切片，确保足够的容量。

1
2
3
4
5

a := []int{1, 2}
b := []int{3, 4, 5, 6}
c := make([]int, len(a), len(a)+len(b))
copy(c, a)
c = append(c, b...)

这种方法虽然代码稍长，但可以有效避免不必要的内存分配和对原始切片的影响。

利用 Go 1.22 的新特性

将要发布的 1.22 版本开始，将提供了一个新的 Concat 函数，它提供了一种更简洁的方式来拼接多个切片。

1
2
3

a := []int{1, 2, 3}
b := []int{4, 5, 6}
c := slices.Concat(nil, a, b)

slices 包中 Concat 的实现源码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func Concat[S ~[]E, E any](slices ...S) S {
	size := 0
	for _, s := range slices {
		size += len(s)
		if size < 0 {
			panic("len out of range")
		}
	}
	newslice := Grow[S](nil, size)
	for _, s := range slices {
		newslice = append(newslice, s...)
	}
	return newslice
}

这种方法不仅代码更简洁，而且内部优化了内存分配和复制操作，适用于需要高性能处理的场景。

切片动态扩容的深入理解

我们来深入理解下切片的动态扩容机制吧。这对于优化切片拼接至关重要。

元素追加的逻辑过程

首先，当我们不断向切片追加元素时，如果每次追加都超出了当前的容量，Go 语言的运行时环境会自动进行内存重新分配。

这个过程涉及到创建一个新的、更大的内存空间，并将现有元素从旧空间复制到新空间，然后追加新元素。虽然这个机制保证了切片的灵活性和动态增长能力，但在处理大量数据时，频繁的内存分配和数据复制可能会成为性能瓶颈。

内存重新分配与数据迁移

当切片的容量不足以容纳新元素时，Go 会执行以下步骤：

1. 分配新的内存空间：创建一个更大的内存空间来容纳扩展后的切片。新空间的容量通常是原来容量的两倍。
2. 拷贝现有元素：将原切片中的元素拷贝到新的内存空间中。
3. 追加新元素：在新的内存空间中追加新元素。

预估容量减少不必要扩容

故而，为了减少内存重新分配和数据迁移的性能开销，可采取以下策略：

• 预估容量：在创建切片时，如果能预估到需要存储的元素数量，应该指定一个足够大的容量。

  1	elements := make([]int, 0, expectedSize)

• 批量追加：尽量一次追加多个元素，减少触发扩容的次数。

• 避免不必要的扩容：在可能的情况下，先将数据收集到一个临时容器中，然后一次性追加到目标切片。

• 使用缓冲区：对于频繁变化的切片，使用一个足够大的缓冲区可以有效避免频繁的内存重新分配。

结论

通过深入理解 Go 切片的内存管理机制和动态扩容行为，可以更加高效地进行切片拼接操作。合理的容量规划、批量操作和缓冲区使用，不仅提高了代码的效率，还保证了程序的稳定性和可维护性。