Go xml.Decoder.Skip 怎样跳过不需要的 XML 子树

处理大型 XML 时，最容易浪费内存的做法是把每个节点都反序列化成完整结构体。如果某个节点只是附带信息，真正需要的是后面的业务节点，可以先用 xml.Decoder.Token() 找到它，再调用 Decoder.Skip() 消费这个元素的完整子树。Skip 返回后，解码器会从该元素的匹配结束标签之后继续读取。

官方地址：https://pkg.go.dev/encoding/xml#Decoder.Skip

关键点只有一个：必须先把目标元素的 StartElement 读出来，再调用 Skip。它不是“跳到下一个 Token”，而是跳过当前开始元素对应的整棵嵌套树。

一、先看清 Skip 消费的范围

Token 每次返回一个 XML Token，包括开始元素、结束元素、字符数据等。读到 时，当前游标已经位于这个元素的开始标签；此时调用 Skip，它会继续读取内部 Token，直到找到匹配的 ，中间的嵌套节点也一起被消费。

二、用 Token 找到目标节点后跳过它

下面的示例只把 item 解码为业务对象，遇到 metadata 时不建立对应结构体。代码中的 XML 字符串只是演示输入，真实场景可以替换为文件或网络流。

package main

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

type Item struct {
    ID   string `xml:"id,attr"`
    Name string `xml:"name"`
}

func main() {
    input := `team-aunusedalphabeta`
    decoder := xml.NewDecoder(strings.NewReader(input))

    for {
        token, err := decoder.Token()
        if err == io.EOF {
            // EOF 表示整个 XML 正常读完，不是一个需要重试的节点。
            break
        }
        if err != nil {
            // Token 阶段的语法错误要保留，不能继续消费不确定的流。
            panic(err)
        }

        start, ok := token.(xml.StartElement)
        if !ok {
            // 字符数据和结束元素不参与目标节点判断。
            continue
        }

        switch start.Name.Local {
        case "metadata":
            // 当前 StartElement 已经交给 Decoder，Skip 会消费匹配的结束元素。
            if err := decoder.Skip(); err != nil {
                panic(err)
            }
        case "item":
            var item Item
            // DecodeElement 从当前 StartElement 开始读取这一棵业务子树。
            if err := decoder.DecodeElement(&item, &start); err != nil {
                panic(err)
            }
            fmt.Printf("%s: %s\n", item.ID, item.Name)
        }
    }
}

这个程序的核心不是把所有 Token 保存下来，而是让解码动作与节点用途对应：需要业务字段时调用 DecodeElement，明确不要的数据用 Skip。这样遍历仍然是流式的，跳过的子树不会进入业务对象。

三、Skip 返回后，游标从哪里继续

Skip 成功返回时，匹配的结束元素已经被消费。下一次调用 Token 不会重新返回被跳过子树里的节点，而是从它后面的 Token 开始。如果 XML 中还有下一个同级 item，循环可以直接处理它。

需要注意，Skip 不会替调用方判断业务节点，也不会把跳过内容转换成摘要。若后续还要记录某个属性，应当在调用 Skip 之前从当前 StartElement 读取；一旦跳过，内部字段就不再可用。

四、EOF、截断 XML 与 Skip 错误怎么分

正常结束时，Token 返回 io.EOF。如果 XML 在目标子树中间被截断，Skip 会返回错误；这和“没有更多数据”的正常 EOF 不是一回事。生产代码应把错误返回给上层，并保留输入来源或记录位置，不能用继续循环掩盖结构不完整。

func skipMetadata(decoder *xml.Decoder) error {
    for {
        token, err := decoder.Token()
        if err == io.EOF {
            // 调用方可以把这里视为文档正常结束。
            return nil
        }
        if err != nil {
            // Token 错误说明当前流已经不能可靠解析。
            return fmt.Errorf("read XML token: %w", err)
        }

        start, ok := token.(xml.StartElement)
        if !ok || start.Name.Local != "metadata" {
            continue
        }
        if err := decoder.Skip(); err != nil {
            // Skip 错误通常意味着目标子树缺少匹配结束标签或输入已截断。
            return fmt.Errorf("skip metadata: %w", err)
        }
        return nil
    }
}

如果业务需要更精确的错误位置，可以在读取关键 Token 后结合 Decoder.InputOffset() 或 Decoder.InputPos() 记录当前位置；但这些位置表示解码器最近处理到的边界，不应被误解成 XML 业务字段的行号。

五、Skip 和 DecodeElement 该选哪个

还有一个容易忽略的边界：Skip 依赖 XML 元素结构是可配对的。它适合“我已经识别出一个开始元素，现在不需要其内部内容”的场景，不适合用来修复不完整 XML，也不等于忽略所有格式错误。

六、常见问题

调用 Skip 前必须先读到 StartElement 吗？

是。Skip 的语义是跳过最近已经消费的开始元素所对应的内容；通常先通过 Token 得到 xml.StartElement，再调用 Skip。

Skip 会跳过下一个同级节点吗？

不会。它只消费当前开始元素对应的嵌套子树和匹配结束元素，成功返回后，下一次 Token 从后续位置继续。

为什么不直接用 Unmarshal？

如果整个 XML 都需要映射到对象，Unmarshal 更直接；如果文档很大且只关心少数节点，Token 加 Skip 可以把处理范围限制在需要的部分。

Skip 返回 io.EOF 算成功吗？

不要把它当成成功。外层遍历自然结束时可以收到 io.EOF；如果 Skip 在寻找匹配结束元素时遇到异常结束，应按错误处理并检查输入是否截断。

总结

Go 的 xml.Decoder.Skip 解决的是流式 XML 遍历中的“这个节点我已经识别出来，但整棵子树都不需要”的问题。先用 Token 找到目标 StartElement，再 Skip；成功后从匹配结束元素之后继续处理。把 Token、Skip、DecodeElement 和错误处理的职责分开，就能在大型 XML 中减少无关对象构造，同时保留对截断和结构错误的明确判断。