Go XML Token 解析混合节点的遍历方式

Go 的 encoding/xml.Decoder.Token 适合处理“节点类型不固定、只关心其中几种元素”的 XML。它不会一次把整棵树装进结构体，而是按输入顺序返回 StartElement、CharData、EndElement 等 Token。遇到不关心的开始元素时，再调用 Skip 跳过完整子树，遍历就能保持清晰且节省内存。

官方文档：https://pkg.go.dev/encoding/xml

本文只聚焦 Token 顺序、混合节点和跳过子树，不展开 XML 映射标签或完整结构体反序列化。

先理解 Token 的顺序

假设输入同时包含文本、属性、列表和暂时不需要的 debug 节点：

  hello
  keyboardignoredmouse

解码器看到的不是一组“已经分好类的字段”，而是一串有顺序的事件：order 开始、空白文本、item 开始、商品文本、item 结束……因此循环必须把“读到什么 Token”和“现在是否在目标节点内部”分开思考。

用 StartElement 找到目标节点

最小遍历器通常只在 StartElement 分支里做业务判断。Name.Local 是不带命名空间前缀的本地名；如果还要区分命名空间，再结合 Name.Space 判断。属性则在 StartElement.Attr 中读取。

package main

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

func printItems(r io.Reader) error {
	dec := xml.NewDecoder(r)

	for {
		tok, err := dec.Token()
		if err == io.EOF {
			// EOF 表示输入正常结束，不是一个需要上抛的业务错误。
			return nil
		}
		if err != nil {
			// 结构不完整或语法错误要保留原始错误上下文。
			return fmt.Errorf("读取 XML Token: %w", err)
		}

		start, ok := tok.(xml.StartElement)
		if !ok || start.Name.Local != "item" {
			// 空白文本、结束标签和其他节点不参与商品提取。
			continue
		}

		var sku string
		for _, attr := range start.Attr {
			if attr.Name.Local == "sku" {
				sku = attr.Value
			}
		}
		fmt.Printf("开始读取商品 sku=%s\\n", sku)
	}
}

func main() {
	input := `keyboard`
	if err := printItems(strings.NewReader(input)); err != nil {
		fmt.Println(err)
	}
}

这个版本只识别 item 的开始事件，还没有读取商品文本。注意不要把一次 Token 返回的值保存为长期引用：官方文档说明，部分 Token 数据会复用解码器内部缓冲区；需要跨下一次读取保存时，应复制相应 Token 或立即转成自己的字符串。

在目标节点内部消费文本

读到 item 的 StartElement 后，下一段 Token 才属于这个元素。可以用一个小循环消费到配对的 EndElement，只收集 CharData。这样即使文本被实体、换行或多个文本片段分开，也不会误把兄弟节点的内容拼进来。

type Item struct {
	SKU  string
	Name string
}

func readItem(dec *xml.Decoder, start xml.StartElement) (Item, error) {
	item := Item{}
	for _, attr := range start.Attr {
		if attr.Name.Local == "sku" {
			item.SKU = attr.Value
		}
	}

	var text strings.Builder
	for {
		tok, err := dec.Token()
		if err != nil {
			// 目标元素没有闭合时，不能把部分结果当成完整商品返回。
			return Item{}, fmt.Errorf("读取 item 内容: %w", err)
		}

		switch value := tok.(type) {
		case xml.CharData:
			// Trim 只用于业务文本，不修改 Token 流本身。
			text.WriteString(string(value))
		case xml.EndElement:
			if value.Name == start.Name {
				item.Name = strings.TrimSpace(text.String())
				return item, nil
			}
		}
	}
}

这里用 value.Name == start.Name 判断配对标签，避免遇到嵌套元素的结束标签时提前返回。如果业务规定 item 只能有纯文本，也可以对嵌套的 StartElement 直接返回自定义错误，让输入约束更明确。

遇到不关心的节点时用 Skip

混合 XML 中常见一段“大而无用”的节点，例如调试信息、扩展字段或第三方附加数据。已经拿到它的 StartElement 后，调用 dec.Skip() 会继续消费 Token，直到匹配的结束标签，并递归处理其中的嵌套开始元素。不要只调用一次 Token 就继续外层循环，否则子树里的 item 可能被误当成当前层的目标。

func collectItems(r io.Reader) ([]Item, error) {
	dec := xml.NewDecoder(r)
	var items []Item

	for {
		tok, err := dec.Token()
		if err == io.EOF {
			return items, nil
		}
		if err != nil {
			return nil, fmt.Errorf("遍历 XML: %w", err)
		}

		start, ok := tok.(xml.StartElement)
		if !ok {
			continue
		}

		switch start.Name.Local {
		case "item":
			item, err := readItem(dec, start)
			if err != nil {
				return nil, err
			}
			items = append(items, item)
		case "debug":
			// 当前已经消费了 debug 的开始标签，Skip 会连同嵌套节点一起跳过。
			if err := dec.Skip(); err != nil {
				return nil, fmt.Errorf("跳过 debug 子树: %w", err)
			}
		}
	}
}

这个函数的关键是“谁消费了开始标签，谁负责把它消费完整”：readItem 负责一个 item，Skip 负责一个 debug 子树，外层循环只接收下一个未消费的 Token。

空白文本、结束标签和命名空间怎么处理

XML 缩进会产生很多 CharData。如果只想读取元素文本，应在目标节点内部收集并 strings.TrimSpace，不要在外层循环中把所有字符数据都当成业务记录。

结束标签通常只需要让外层循环自然略过；只有在自己消费一个完整节点时，才需要用它和起始标签配对。Decoder.Token 会校验开始和结束元素是否正确嵌套，遇到结构不完整时会返回错误，不能把错误当作正常 EOF。

命名空间场景下，Name.Space 可能是命名空间 URL，而不是输入里的短前缀。不要只比较字符串前缀来判断“是不是同一标签”；优先比较 Name.Local，需要严格区分时同时比较 Name.Space。

把遍历规则整理成检查表

边界状态与可复用方式

当输入来自文件或 HTTP 响应时，只需把对应的 io.Reader 传给 collectItems。文件和响应体的关闭由调用方负责；遍历函数只负责消费 XML，不要在里面偷偷接管调用方的资源生命周期。

测试时可以使用 strings.NewReader 构造四类样本：只有一个目标节点、目标节点之间夹着未知节点、未知节点里有多层嵌套、以及缺少结束标签的坏 XML。前两类用于确认结果，第三类确认 Skip 不泄漏子节点，第四类确认错误会返回而不是静默成功。

如果节点结构已经稳定、字段映射关系明确，直接定义结构体并使用 Decode 往往更省代码；Token 遍历更适合混合结构、超大输入或只需要提取少数字段的场景。选择的标准不是“Token 更高级”，而是是否需要自己控制读取边界。

总结

Go XML Token 遍历可以归纳为三条规则：用 Token 按顺序读取，用 StartElement 决定进入哪个处理器，用 Skip 一次越过已经识别但不关心的完整子树。目标处理器必须消费到自己的结束标签，外层循环则统一处理 EOF 和结构错误。这样面对混合节点时，读取指针不会错位，代码也容易扩展到文件、HTTP 和测试输入。

相关问题

• 为什么 Token 遍历会读到很多空白字符串？ XML 缩进和换行也是字符数据，应只在目标节点内部收集并清理。
• Skip 能跳过嵌套 XML 吗？ 可以。它会继续消费嵌套开始元素，直到当前已消费开始标签对应的结束元素。
• 什么时候应该改用 Decode？ 当 XML 结构稳定、字段与结构体映射清楚，Decode 通常更直接；需要选择性读取或控制边界时再用 Token。
• Token 返回的字符数据能长期保存吗？ 不应直接依赖解码器内部缓冲区；需要跨下一次 Token 调用保存时，应复制或转成自己的字符串。