Go hex.NewDecoder 怎样读取十六进制输入

如果输入是一段十六进制字符，想像读取普通 io.Reader 一样得到原始字节，直接把输入交给 hex.NewDecoder 即可。它不会返回一份已经解码好的切片，而是返回一个包装后的读取器：每两个十六进制字符对应一个输出字节，读取过程中发现奇数长度或非法字符时，再通过 Read 的错误返回暴露问题。

这篇只解决一个任务：从字符串或其他输入流读取十六进制内容。完整读取可以用 io.ReadAll，大输入则使用固定缓冲区循环 Read。需要特别记住，输入字符数和输出字节数是二倍关系，不能把十六进制文本的长度直接当成解码后缓冲区长度。

先看清 hex.NewDecoder 的输入和输出

hex.NewDecoder 接收一个 io.Reader，返回的仍然是 io.Reader。源读取器提供的是 ASCII 范围内的十六进制字符，例如 48656c6c6f；包装器读出来的是对应的字节，也就是文本 Hello。

它适合输入还在流中的场景，例如文件、网络响应或其他自定义读取器。由于返回值是读取器，调用方不必先把完整十六进制文本拼成一个大字符串。

用 io.ReadAll 读取一段完整输入

输入规模不大、业务需要完整字节切片时，最短的写法是把 hex.NewDecoder 交给 io.ReadAll。错误必须检查，因为解码错误会沿着读取链返回。

package main

import (
    "encoding/hex"
    "fmt"
    "io"
    "log"
    "strings"
)

func main() {
    // 源读取器提供十六进制字符，NewDecoder 负责把它转换为字节流。
    encoded := strings.NewReader("48656c6c6f20476f")
    decoded, err := io.ReadAll(hex.NewDecoder(encoded))
    if err != nil {
        // 输入不完整或包含非法字符时，不能把部分结果当成完整结果使用。
        log.Fatal(err)
    }

    fmt.Printf("%s\n", decoded)
}

这段代码的预期输出是 Hello Go。io.ReadAll 会持续调用包装器的 Read，直到读完或遇到错误；因此它适合“必须拿到完整结果才能继续”的场景。若数据可能很大，不要为了使用 NewDecoder 而把所有结果积存在内存里。

较长数据用固定缓冲区分块读取

分块读取时，缓冲区保存的是解码后的字节，不是输入的十六进制字符。比如每次读 4 个输出字节，底层读取器可能需要提供 8 个十六进制字符；具体底层读取次数由包装器和源读取器共同决定，调用方只需要遵守 Read 的返回约定。

package main

import (
    "encoding/hex"
    "fmt"
    "io"
    "strings"
)

func printDecoded(src io.Reader) error {
    decoder := hex.NewDecoder(src)
    buf := make([]byte, 4) // 这里的 4 指每次接收最多 4 个解码后字节。

    for {
        n, err := decoder.Read(buf)
        if n > 0 {
            // 先处理本次已经成功解码的字节，再判断 err，避免丢掉前缀。
            fmt.Printf("%q\n", buf[:n])
        }
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
    }
}

func main() {
    // 输入字符数是输出字节数的两倍，但输出仍按固定缓冲区分块。
    err := printDecoded(strings.NewReader("476f20726561646572"))
    if err != nil {
        fmt.Println("读取失败:", err)
    }
}

这个循环有两个关键点。第一，先判断 n > 0，因为一次 Read 可能已经产生部分有效字节；第二，再处理 err，把 io.EOF 视为正常结束，其他错误向上返回。这样写可以直接替换成文件或网络响应，而不需要改变解码逻辑。

奇数长度和非法字符怎么定位

hex.NewDecoder 要求输入包含偶数个十六进制字符。若流在半个字节处结束，流式解码器返回的是 io.ErrUnexpectedEOF；若遇到不属于 0-9、a-f 或 A-F 的字符，则会返回描述该字符的 hex.InvalidByteError。

package main

import (
    "encoding/hex"
    "errors"
    "fmt"
    "io"
    "strings"
)

func inspect(input string) {
    // 通过 ReadAll 触发完整读取，方便把两类输入边界放在一起比较。
    _, err := io.ReadAll(hex.NewDecoder(strings.NewReader(input)))
    switch {
    case err == nil:
        fmt.Println("输入完整")
    case errors.Is(err, io.ErrUnexpectedEOF):
        fmt.Println("输入在半个字节处结束")
    default:
        var invalid hex.InvalidByteError
        if errors.As(err, &invalid) {
            fmt.Printf("发现非法十六进制字符: %q\n", byte(invalid))
            return
        }
        fmt.Println("其他读取错误:", err)
    }
}

func main() {
    inspect("48656") // 奇数个字符：最后的 6 没有配对字符。
    inspect("48656x") // x 不是十六进制字符。
}

排查时不要只写 if err != nil 然后丢弃错误文本。用 errors.Is 判断 io.ErrUnexpectedEOF，用 errors.As 提取 hex.InvalidByteError，后续才能分别提示“输入被截断”和“输入字符不合法”。分块读取时，也要保留本次 n > 0 对应的前缀，再根据错误决定是否终止。

什么时候换成 DecodeString

如果数据本来就是一个完整字符串，而且不需要流式读取，hex.DecodeString 会更直接；它一次返回解码后的切片和错误。NewDecoder 的价值在于把十六进制转换接到现有的 io.Reader 管道里，避免为了解码而先复制整份输入。

总结

使用 hex.NewDecoder 的核心就是把“十六进制字符输入”当作读取器包装起来：完整读取用 io.ReadAll，大数据用固定缓冲区循环 Read；输入必须是偶数个合法十六进制字符；出现奇数长度时识别 io.ErrUnexpectedEOF，出现非法字符时识别 hex.InvalidByteError。只要先处理已经返回的 n，再处理 err，流式解码就不会丢掉有效前缀。

常见问题

hex.NewDecoder 读出来为什么不是十六进制文本？

它的职责就是把十六进制文本解码成原始字节。如果需要保留文本形式，不要套 NewDecoder；直接读取原始输入即可。

输入是奇数长度时能不能自动补 0？

不能依赖它自动补齐。奇数长度通常意味着输入被截断或格式不完整，应先明确协议规则，再在业务层决定是否补齐。

Read 返回了 n 和错误时应该先处理谁？

先处理 n > 0 对应的有效字节，再根据错误决定结束或重试。这样可以保留错误发生前已经成功解码的内容。