Go 语言中高效解析 HTML：选择与实践-Golang-PHP中文网

go 语言中高效解析 html：选择与实践

在 Go 语言中处理 HTML 文件，尤其是需要从中提取结构化数据时，选择一个高效且健壮的解析库是首要任务。开发者常常面临一个疑问：是使用 Go 标准库中的 encoding/xml 包，还是选择专门为 HTML 设计的 go.net/html？这两种方案各有侧重，理解它们的底层原理和适用场景对于编写可靠的 HTML 解析逻辑至关重要。

HTML 与 XML：核心差异解析

尽管 HTML 在外观上与 XML 有诸多相似之处，但它们在语法规则和容错性方面存在根本差异。XML 是一种严格的标记语言，要求文档必须是“格式良好”（well-formed）的，这意味着所有标签都必须正确关闭，属性值必须加引号，且元素不能重叠。例如，一个自闭合标签在 XML 中必须写作 <br/>。

相比之下，HTML，尤其是现代的 HTML5，具有更高的容错性。浏览器在渲染时能够智能地纠正许多不符合 XML 规范的 HTML 结构。例如，<br> 是一个完全合法的 HTML 标签，它不需要显式关闭。此外，HTML 允许省略某些标签的结束标签（如 <p>、<li>），或者属性值不加引号等。

历史上的 XHTML 曾试图将 HTML 规则与 XML 的严格性结合起来，要求 HTML 文档同时符合 XML 规范。然而，XHTML 并未成为主流，现代 Web 开发更倾向于 HTML5 及其灵活的解析模型。

立即学习“前端免费学习笔记（深入）”；

选择合适的解析库

在 Go 语言中，根据 HTML 文档的特性，可以选择以下两种主要的解析策略：

1. 使用 encoding/xml 包

如果您的 HTML 文件被严格保证是“格式良好”的 XML，即它完全遵循 XML 的语法规则（例如，所有标签都正确关闭，自闭合标签使用 <tag/> 形式），那么 encoding/xml 包是一个可行的选择。它能够将 XML 文档解析为 Go 结构体，这对于处理结构高度规范的数据非常方便。

适用场景：

云雀语言模型

云雀是一款由字节跳动研发的语言模型，通过便捷的自然语言交互，能够高效的完成互动对话

查看详情

当您确定 HTML 文档实际上是 XHTML 或其他严格遵循 XML 规范的标记语言时。
从特定系统或服务输出的、已知格式良好且结构化的 XML 数据（即使其内容是 HTML 标签）。

注意事项：

极少用于通用 HTML 解析： 对于大多数从互联网获取的 HTML 页面，使用 encoding/xml 几乎肯定会失败，因为它无法容忍 HTML 中常见的非格式良好结构。它会报告解析错误，而不是尝试修复或忽略这些问题。
不推荐用于未知或非标准 HTML： 如果您无法保证 HTML 的 XML 格式良好性，请避免使用此包。

2. 使用 go.net/html 包

对于大多数实际的 HTML 解析任务，尤其是处理从网页抓取或用户输入中获取的非标准或包含错误标记的 HTML，官方推荐使用 go.net/html 包。这个包实现了 HTML5 规范的解析算法，能够像现代浏览器一样处理各种畸形 HTML，构建一个可靠的文档对象模型（DOM）树。

适用场景：

解析任意来源的 HTML 页面，包括那些可能包含语法错误或不符合 XML 规范的页面。
需要遍历 DOM 树、查找特定元素、提取属性或文本内容的任务。
执行网页抓取（Web Scraping）等操作。

优势：

健壮性： 能够处理大多数浏览器都能解析的“坏”HTML。
符合标准： 遵循 HTML5 解析规范。
DOM 遍历： 提供了一套直观的 API 来遍历和操作解析后的 HTML 节点树。

实践示例：使用 go.net/html 解析 HTML 表格数据

以下示例将演示如何使用 go.net/html 包来解析一个复杂的嵌套 HTML 表格，并从中提取出结构化的数据。我们将解析问题中提供的 HTML 片段，目标是提取每个内层表格中的“Type”、“Count”和“Percent”信息。

package main

import (
    "fmt"
    "io"
    "log"
    "strconv"
    "strings"

    "golang.org/x/net/html" // 确保已安装 go get golang.org/x/net/html
)

// TableRow 结构体用于存储从内层表格中提取的数据
type TableRow struct {
    Type    string
    Count   int
    Percent float64
}

// forEachNode 遍历 HTML 节点树，并在每个节点上执行 pre 和 post 函数
func forEachNode(n *html.Node, pre, post func(n *html.Node)) {
    if pre != nil {
        pre(n)
    }
    for c := n.FirstChild; c != nil; c = c.NextSibling {
        forEachNode(c, pre, post)
    }
    if post != nil {
        post(n)
    }
}

// parseHTMLTable 从给定的 HTML Reader 中解析表格数据
func parseHTMLTable(r io.Reader) ([]TableRow, error) {
    doc, err := html.Parse(r)
    if err != nil {
        return nil, fmt.Errorf("解析 HTML 失败: %w", err)
    }

    var results []TableRow
    var currentTableRows []TableRow // 临时存储当前处理的内层表格数据
    inInnerTable := false           // 标志是否在内层表格中

    // 遍历 DOM 树
    forEachNode(doc, func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "table" {
            // 检查是否是内层表格（通过其父节点判断，这里简化为发现 table 元素即开始检查其内容）
            // 更严谨的做法是检查其祖先节点是否是 td，但对于本例，我们可以直接进入解析
            currentTableRows = []TableRow{} // 重置当前表格行
            inInnerTable = true
        } else if n.Type == html.ElementNode && n.Data == "tr" && inInnerTable {
            // 找到表格行，尝试提取数据
            var rowData TableRow
            tdCount := 0
            for c := n.FirstChild; c != nil; c = c.NextSibling {
                if c.Type == html.ElementNode && c.Data == "td" {
                    tdCount++
                    text := extractText(c) // 提取 td 中的文本内容
                    switch tdCount {
                    case 1: // Type
                        rowData.Type = strings.TrimSpace(text)
                    case 3: // Count
                        // 清理逗号并转换为整数
                        cleanCount := strings.ReplaceAll(text, ",", "")
                        if count, err := strconv.Atoi(cleanCount); err == nil {
                            rowData.Count = count
                        }
                    case 4: // Percent
                        // 清理百分号并转换为浮点数
                        cleanPercent := strings.TrimSuffix(strings.TrimSpace(text), "%")
                        if percent, err := strconv.ParseFloat(cleanPercent, 64); err == nil {
                            rowData.Percent = percent
                        }
                    }
                }
            }
            // 如果成功提取了至少 Type 和 Count，则添加到当前表格行中
            if rowData.Type != "" && rowData.Count != 0 {
                currentTableRows = append(currentTableRows, rowData)
            }
        }
    }, func(n *html.Node) {
        // 在节点处理完成后，如果退出一个 table 元素，则将当前表格数据添加到总结果中
        if n.Type == html.ElementNode && n.Data == "table" && inInnerTable {
            results = append(results, currentTableRows...)
            inInnerTable = false // 退出内层表格处理模式
        }
    })

    return results, nil
}

// extractText 辅助函数，用于提取节点及其子孙节点中的所有文本内容
func extractText(n *html.Node) string {
    var buf strings.Builder
    var f func(*html.Node)
    f = func(n *html.Node) {
        if n.Type == html.TextNode {
            buf.WriteString(n.Data)
        }
        for c := n.FirstChild; c != nil; c = c.NextSibling {
            f(c)
        }
    }
    f(n)
    return buf.String()
}

func main() {
    htmlContent := `
<html><head>
<meta charset="utf-8">

</head>
<body>
<a name="Test1">
<center>
<b>Test 1</b> <table border="0">
  <tbody><tr>
  <th> Type </th>
  <th> Region </th>
  </tr>
  <tr>
  <td> <table border="0">
  <thead>
  <tr>
    <th><b>Type</b></th>
    <th>   </th>
    <th> Count </th>
    <th> Percent </th>
  </tr>
  </thead>
  <tbody><tr>
    <td> <b>T1</b> </td>
    <th>   </th>
    <td class="numeric" bgcolor="#ff0000"> 34,314 </td>
    <td class="numeric" bgcolor="#ff0000"> 31.648% </td>
  </tr>
  <tr>
    <td> <b>T2</b> </td>
    <th>   </th>
    <td class="numeric" bgcolor="#bf3f00"> 25,820 </td>
    <td class="numeric" bgcolor="#bf3f00"> 23.814% </td>
  </tr>
  <tr>
    <td> <b>T3</b> </td>
    <th>   </th>
    <td class="numeric" bgcolor="#24da00"> 4,871 </td>
    <td class="numeric" bgcolor="#24da00"> 4.493% </td>
  </tr>

</tbody></table><br>
</td>
  <td> <table border="0">
  <thead>
  <tr>
    <th><b> Type</b></th>
    <th>   </th>
    <th> Count </th>
    <th> Percent </th>
  </tr>
  </thead>
  <tbody><tr>
    <td> <b>T4</b> </td>
    <th>   </th>
    <td class="numeric" bgcolor="#ff0000"> 34,314 </td>
    <td class="numeric" bgcolor="#ff0000"> 31.648% </td>
  </tr>
  <tr>
    <td> <b>T5</b> </td>
    <th>   </th>
    <td class="numeric" bgcolor="#53ab00"> 11,187 </td>
    <td class="numeric" bgcolor="#53ab00"> 10.318% </td>
  </tr>
  <tr>
    <td> <b>T6</b> </td>
    <th>   </th>
    <td class="numeric" bgcolor="#bf3f00"> 25,820 </td>
    <td class="numeric" bgcolor="#bf3f00"> 23.814% </td>
  </tr>

</tbody></table><br>
</td>
  </tr>
</tbody></table>
</center>

  </a>
</body></html>
`
    reader := strings.NewReader(htmlContent)
    data, err := parseHTMLTable(reader)
    if err != nil {
        log.Fatalf("解析失败: %v", err)
    }

    fmt.Println("提取到的表格数据:")
    for _, row := range data {
        fmt.Printf("Type: %s, Count: %d, Percent: %.3f%%\n", row.Type, row.Count, row.Percent)
    }
}

登录后复制

代码解析：

TableRow 结构体： 定义了用于存储提取数据的结构。
forEachNode 函数： 这是一个通用的辅助函数，用于递归遍历 HTML 节点树，并在进入和退出每个节点时执行指定的回调函数。
parseHTMLTable 函数：
- 使用 html.Parse(r) 将 HTML 内容解析为一个 DOM 树的根节点。
- 通过 forEachNode 遍历 DOM 树。
- 在遍历过程中，通过检查节点的 Type 和 Data 属性来识别 <table> 和 <tr> 元素。
- 使用 inInnerTable 标志来确保只处理内层的表格数据。
- 在 <tr> 元素中，进一步遍历其子节点，识别 <td> 元素。
- extractText 辅助函数用于从 <td> 节点中提取纯文本内容，包括其子节点中的文本。
- 使用 strconv.Atoi 和 strconv.ParseFloat 将提取的字符串转换为数值类型，并处理了逗号和百分号。
main 函数： 包含了待解析的 HTML 内容，调用 parseHTMLTable 进行解析，并打印出结果。

注意事项与总结

错误处理： 在实际应用中，对 strconv 等可能失败的转换操作进行健壮的错误处理至关重要。
CSS 选择器： go.net/html 本身不提供 CSS 选择器功能。如果需要更高级的元素查找功能（例如，通过 class 或 id 查找），可以考虑结合使用第三方库，如 github.com/PuerkitoBio/goquery，它提供了类似 jQuery 的 API，底层也是基于 go.net/html。
性能： 对于大型 HTML 文档，DOM 树可能会占用大量内存。如果只需要提取少量特定信息，可以考虑流式解析（虽然 go.net/html 主要是构建 DOM 树）。
HTML 结构变化： 网页结构可能会发生变化。编写解析代码时，应尽量使其对细微的结构变动具有一定的鲁棒性，例如，不要过度依赖绝对路径或固定的子节点索引。

综上所述，在 Go 语言中解析 HTML 文件时，强烈推荐使用 go.net/html 包，因为它能够健壮地处理各种 HTML 文档，并提供了构建和遍历 DOM 树的强大能力。只有在极少数情况下，当您能严格保证 HTML 文档是格式良好的 XML 时，才应考虑 encoding/xml。理解这两种库的适用范围，将帮助您更高效、更可靠地处理 HTML 数据。

以上就是Go 语言中高效解析 HTML：选择与实践的详细内容，更多请关注php中文网其它相关文章！