Go math/big.Int 怎样把整数追加到字节缓冲区

在 Go 里，如果手上已经有一个 []byte 缓冲区，只想把 *big.Int 的可读表示接在后面，直接使用 buf = n.Append(buf, base)。这个方法追加的是 n.Text(base) 产生的文本，不是整数的原始二进制编码；要写网络协议里的定长大端字节，应改用 Bytes 或 FillBytes。

官方文档：https://pkg.go.dev/math/big#Int.Append

把数字写进文本型字节缓冲区用 Append，把数字变成二进制字段用 Bytes 或 FillBytes。进制由第二个参数决定，十六进制的 0x 前缀需要自己追加。

先区分 Append 追加的到底是什么

(*big.Int).Append 的签名是 Append(buf []byte, base int) []byte。它接收已有缓冲区，按照指定进制生成整数的字符串表示，再返回扩展后的切片。接收者本身不会被改写，返回值才是后续应该继续使用的缓冲区。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 先放入协议字段或日志前缀，再追加大整数的十进制文本。
    n := big.NewInt(123456789)
    buf := []byte("id=")
    buf = n.Append(buf, 10)

    // Append 返回扩展后的切片，直接转换为 string 即可读取结果。
    fmt.Println(string(buf)) // id=123456789
}

这类写法适合拼接日志行、文本协议、缓存键或需要避免中间 string 的编码过程。它的结果仍然是文本字节，不能拿来当作大端整数的字节序列。

把前缀和数字一次追加到同一个缓冲区

实际编码时，前缀、分隔符和数字通常属于同一段文本。可以连续调用标准库的 append 与 Append，并始终接住返回值。这样既保留了已有内容，也允许切片在容量不足时自动扩容。

package main

import (
    "fmt"
    "math/big"
)

func appendPair(buf []byte, key string, value *big.Int) []byte {
    // 字段名和分隔符先写入，再让 Append 追加数字文本。
    buf = append(buf, key...)
    buf = append(buf, '=')
    return value.Append(buf, 10)
}

func main() {
    // 复用同一缓冲区拼出一行简单的文本字段。
    buf := appendPair(nil, "count", big.NewInt(42))
    fmt.Println(string(buf)) // count=42
}

如果这是循环中的编码函数，调用方应把返回的切片继续传回下一次循环，而不是只把它当作临时值。需要更少扩容时，可以先用 make([]byte, 0, capacity) 预留容量，但容量只是性能提示，不改变 Append 的语义。

选择合法进制，十六进制前缀要自己写

base 必须在 2 到 62 之间。2、8、10、16 最常见；大于 36 时，A 到 Z 还会作为更高位的数字字符使用。Append 不会自动添加 0x、0b 之类前缀。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    // 需要可识别的十六进制文本时，前缀必须由调用方明确写入。
    n := big.NewInt(255)
    buf := append([]byte("0x"), n.Append(nil, 16)...)
    fmt.Println(string(buf)) // 0xff

    // base=2 得到二进制字符，但仍然是文本而不是单个位流。
    binary := n.Append(nil, 2)
    fmt.Println(string(binary)) // 11111111
}

不要把 base=0 当成“自动识别进制”。那是某些解析 API 的约定，不是 Int.Append 的写法；对 Append 来说应明确传入 2 到 62 的进制值。

负数、零值和 nil 指针怎么判断

符号属于文本表示的一部分。负数会带上 -，零值会得到 0。官方文档对 Int.Text 说明了 nil 接收者返回 ；由于 Append 追加的就是这个文本表示，nil 指针也应被当作特殊输入，而不是普通的零。

package main

import (
    "fmt"
    "math/big"
)

func show(n *big.Int) string {
    // 通过 Append 统一获取十进制文本，不把 nil 偷换成零。
    return string(n.Append(nil, 10))
}

func main() {
    var zero big.Int
    negative := big.NewInt(-17)
    var missing *big.Int

    fmt.Println(show(&zero))    // 0
    fmt.Println(show(negative)) // -17
    fmt.Println(show(missing))  // 
}

如果业务协议不允许 ，应在调用 Append 前显式检查指针并返回错误。不要在入口处用 new(big.Int) 代替缺失值，除非业务语义确实把缺失值定义成数字零。

需要原始字节时改用 Bytes 或 FillBytes

Append 产生的是按进制排列的字符；Bytes 返回绝对值的大端字节切片，FillBytes 则把绝对值写进调用方提供的固定长度大端缓冲区。负号不会出现在这两个二进制结果里，因此协议还需要另外设计符号位或符号字段。

package main

import (
    "encoding/hex"
    "fmt"
    "math/big"
)

func main() {
    // 这个数的文本十六进制是 0x010203，但二进制内容是三个大端字节。
    n := new(big.Int).SetUint64(0x010203)
    text := n.Append(nil, 16)
    raw := n.Bytes()

    // FillBytes 要求目标长度足够，适合固定宽度字段。
    fixed := make([]byte, 4)
    n.FillBytes(fixed)

    fmt.Println(string(text))              // 10203
    fmt.Println(hex.EncodeToString(raw))   // 010203
    fmt.Println(hex.EncodeToString(fixed)) // 00010203
}

注意第一行没有 0x，而 Bytes 的结果是二进制字段；两者都表达同一个数，却服务于不同的协议层。固定长度编码时还要提前决定超长数字如何处理，因为 FillBytes 不会替调用方设计截断策略。

上线前的排查清单

当结果和预期不一致时，可以按下面的顺序检查：

• 结果是可读字符串还是协议字节？前者用 Append，后者用 Bytes 或 FillBytes。
• 传入的进制是否在 2 到 62 之间？是否误以为 base=0 会自动识别？
• 是否需要 0x、0b 等前缀？这些前缀必须由调用方追加。
• 是否接住了返回切片？连续拼接时每次都应写成 buf = n.Append(buf, base)。
• 输入是否可能为 nil 或负数？文本表示和二进制绝对值的处理方式不同。

把这五项写进编码函数的单元测试或代码审查清单，通常就能快速区分“进制写错”“返回值丢失”和“API 语义选错”三类问题。

相关问题

Append 会修改 big.Int 本身吗？

不会。它读取接收者的值，把文本追加到传入的字节缓冲区，并返回扩展后的切片。

Append 会自动写入十六进制前缀吗？

不会。需要前缀时先用 append 写入 0x，再调用 Append。

为什么 Bytes 得到的结果没有负号？

Bytes 表示的是绝对值的大端字节；如果协议需要表达负数，必须额外设计符号或编码规则。

结论很简单：文字缓冲区使用 Append，并明确传入进制且接住返回值；二进制字段则使用 Bytes 或 FillBytes，不要把两种表示混为一谈。