Go encoding/hex 怎样复用目标缓冲区编码

我在处理批量标识符时，最容易先写出的代码是 hex.EncodeToString：简单、直观，但在循环里会不断得到新的字符串和底层字节存储。如果调用方已经有一块可以长期复用的目标缓冲区，encoding/hex 还提供了更贴近这个场景的写法。

固定长度输入可以用 hex.Encode 直接写入预先切好的目标切片；输入长度会变化，或者一次要拼接多段十六进制内容时，可以用 Go 1.22 引入的 hex.AppendEncode，把 dst[:0] 作为空长度但保留容量的缓冲区传进去。核心原则只有一句：长度决定当前可见数据，容量决定后续是否有机会复用底层数组。

先把目标缓冲区的长度和容量分开

十六进制编码会把每个源字节表示成两个 ASCII 字节，所以 hex.EncodedLen(n) 返回的就是 n * 2。这让我们可以在分配或切片之前算出目标空间，不必靠经验写一个“看起来够大”的数字。

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    src := []byte("Go")

    // EncodedLen 返回编码后需要的字节数，目标切片长度必须覆盖这块空间。
    encodedLen := hex.EncodedLen(len(src))
    dst := make([]byte, encodedLen)

    // Encode 只写入 dst 的现有长度范围，n 是实际写入的字节数。
    n := hex.Encode(dst, src)
    fmt.Printf("%d %s\\n", n, dst[:n])
}

这里的 len(dst) 是当前可写的长度，cap(dst) 是切片背后的存储上限。hex.Encode 不会替你扩容；如果目标切片长度不足，调用就不满足 API 的写入前提。对固定长度输入而言，提前创建一次 dst，后面只要把新数据写回同一块区域即可。

固定输入长度时直接复用 hex.Encode

当每次输入长度相同，最小的复用方式是让目标缓冲区保持正确长度，然后重复调用 hex.Encode。下面把“创建缓冲区”和“填充缓冲区”分开，调用方可以在处理下一条记录前继续使用同一个底层数组。

package main

import (
    "encoding/hex"
    "fmt"
)

func encodeFixed(dst []byte, src []byte) []byte {
    // 这个函数约定 dst 的长度已经等于本次编码所需空间。
    if len(dst) != hex.EncodedLen(len(src)) {
        return nil
    }

    // Encode 没有返回 error，长度契约由调用方在进入函数前保证。
    hex.Encode(dst, src)
    return dst
}

func main() {
    src := []byte("item-01")
    dst := make([]byte, hex.EncodedLen(len(src)))
    encoded := encodeFixed(dst, src)
    fmt.Println(string(encoded))
}

这个版本适合协议字段或批处理记录长度已知的场景。函数返回的切片仍然指向调用方的 dst；如果返回值被保存到下一轮之后，下一轮写入就会覆盖它，因此不要把同一块缓冲区同时当成多条记录的独立结果。

在循环里用 AppendEncode 复用容量

输入长度变化时，不必每次手动把目标切到精确长度。可以先创建一个有容量、长度为零的切片，每一轮用 dst[:0] 清除“当前有效长度”，但保留底层数组，再让 AppendEncode 根据需要扩展结果。

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    // 容量按预期的最大源数据准备，长度从零开始表示当前没有结果。
    dst := make([]byte, 0, hex.EncodedLen(32))
    inputs := [][]byte{[]byte("A"), []byte("longer-id"), []byte("end")}

    for _, src := range inputs {
        // [:0] 丢弃上一轮的可见长度，但保留底层数组和 cap。
        dst = dst[:0]
        dst = hex.AppendEncode(dst, src)
        fmt.Println(string(dst))
    }
}

AppendEncode 返回扩展后的切片，所以必须接住返回值。若原有容量足够，新的结果通常可以继续使用原底层数组；若容量不够，切片会按 Go 的规则获得新的底层存储。也就是说，“复用容量”是一个可利用的结果，不是要求 API 永远不分配。

需要拼接多段内容时，让追加语义保持清楚

AppendEncode 的另一个好处是可以把多个源片段编码到同一结果中。这里的 dst 不在每个片段前清零，而是保留已经追加的编码内容。

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    parts := [][]byte{[]byte("user"), []byte(":"), []byte("42")}
    // 先按总量给一个初始容量，容量不足时 AppendEncode 仍会安全扩展。
    dst := make([]byte, 0, hex.EncodedLen(7))

    for _, part := range parts {
        // 这里故意不写 dst[:0]，因为每段结果都要保留在同一输出中。
        dst = hex.AppendEncode(dst, part)
    }
    fmt.Println(string(dst))
}

要区分两种意图：一条输入一条输出时使用 dst[:0] 重置长度；多段输入合成一条输出时直接在已有 dst 上追加。把这两个写法混用，最常见的后果就是输出被意外清空，或者把上一条记录残留在下一条结果前面。

输入长度变化和缓冲区生命周期怎么取舍

我通常把复用缓冲区留在单个请求、单个批处理 worker 或单次函数调用内部；如果要跨 goroutine 传递，就先明确所有权。即使代码没有数据竞争，接收方看到的内容也可能在下一轮被覆盖，这属于生命周期问题。

最后的选择可以很简单

固定目标空间就用 hex.Encode，需要追加或输入长度变化就用 hex.AppendEncode。两者都建立在同一个长度公式上：源数据有多少字节，十六进制结果就需要多少的两倍。循环复用时记住 dst[:0] 只清除长度、不清除容量；多段拼接时则不要清零。

相关问题：

• 为什么不直接使用 EncodeToString？它更适合结果本来就需要字符串的场景；如果后续仍以字节发送，目标缓冲区 API 更容易控制存储。
• AppendEncode 会不会永远零分配？不会。只有现有容量足够时才能复用，容量不足仍可能扩容。
• 复用后的 dst 能不能长期保存？可以，但保存前要保证后续不会写入同一底层数组；否则应复制结果。