Rust HTML处理工具库swc_html_utils的使用，高效解析与操作HTML文档的实用工具集

安装

在项目目录中运行以下Cargo命令：

cargo add swc_html_utils

或者在Cargo.toml中添加以下行：

swc_html_utils = "14.0.0"

示例代码

以下是一个使用swc_html_utils的完整示例demo：

use swc_html_utils::parser::{parse_document, parse_fragment};
use swc_html_utils::visit::{VisitMut, VisitMutWith};

// 自定义HTML访问器
struct HtmlVisitor;

impl VisitMut for HtmlVisitor {
    fn visit_mut_element(&mut self, n: &mut Element) {
        // 处理HTML元素
        println!("Found element: {}", n.tag_name);
        n.visit_mut_children_with(self);
    }
    
    fn visit_mut_text(&mut self, n: &mut Text) {
        // 处理文本节点
        println!("Found text: {}", n.value);
    }
}

fn main() {
    // 示例HTML文档
    let html = r#"
        <!DOCTYPE html>
        <html>
        <head>
            <title>示例页面</title>
        </head>
        <body>
            <h1>欢迎使用swc_html_utils</h1>
            <p>这是一个HTML解析示例</p>
        </body>
        </html>
    "#;
    
    // 解析完整HTML文档
    let mut document = parse_document(html, Default::default()).unwrap();
    
    // 使用访问器遍历文档
    document.visit_mut_with(&mut HtmlVisitor);
    
    // 解析HTML片段
    let fragment = r#"<div><p>片段内容</p></div>"#;
    let mut fragment_dom = parse_fragment(fragment, Default::default()).unwrap();
    
    // 使用访问器遍历片段
    fragment_dom.visit_mut_with(&mut HtmlVisitor);
}

功能特点

高效解析：swc_html_utils提供了快速的HTML解析能力
DOM操作：可以轻松遍历和修改HTML文档结构
片段处理：支持解析和处理HTML片段
访问者模式：通过VisitMut trait实现自定义DOM遍历逻辑

完整示例代码

以下是基于上述示例扩展的完整demo，展示了更多swc_html_utils的功能：

use swc_html_utils::parser::{parse_document, parse_fragment};
use swc_html_utils::visit::{VisitMut, VisitMutWith};
use swc_html_utils::ast::{Element, Text};

// 自定义HTML访问器 - 扩展版
struct AdvancedHtmlVisitor;

impl VisitMut for AdvancedHtmlVisitor {
    fn visit_mut_element(&mut self, el: &mut Element) {
        // 打印元素标签名和属性
        println!("元素标签: {}", el.tag_name);
        
        // 修改特定元素
        if el.tag_name == "h1" {
            // 添加class属性
            el.attrs.push(("class".into(), "title".into()));
        }
        
        // 继续遍历子节点
        el.visit_mut_children_with(self);
    }
    
    fn visit_mut_text(&mut self, text: &mut Text) {
        // 处理文本内容
        if text.value.contains("示例") {
            println!("发现包含'示例'的文本节点");
            // 修改文本内容
            text.value = text.value.replace("示例", "演示");
        }
    }
}

fn main() {
    // 示例HTML文档
    let html = r#"
        <!DOCTYPE html>
        <html>
        <head>
            <title>示例页面</title>
        </head>
        <body>
            <h1>欢迎使用swc_html_utils</h1>
            <p>这是一个HTML解析示例</p>
            <div class="content">
                <p>更多内容...</p>
            </div>
        </body>
        </html>
    "#;
    
    // 1. 解析完整HTML文档
    let mut document = parse_document(html, Default::default()).unwrap();
    
    // 2. 使用访问器遍历和修改文档
    document.visit_mut_with(&mut AdvancedHtmlVisitor);
    
    // 3. 解析HTML片段
    let fragment = r#"<section><article>文章内容</article></section>"#;
    let mut fragment_dom = parse_fragment(fragment, Default::default()).unwrap();
    
    // 4. 使用相同的访问器处理片段
    fragment_dom.visit_mut_with(&mut AdvancedHtmlVisitor);
    
    // 注意：实际应用中，你可以将修改后的DOM序列化回HTML
    // 这里只是演示解析和修改的过程
}

功能特点详解

高效解析：
- 基于Rust的高性能HTML解析器
- 支持HTML5标准
DOM操作：
- 完整的DOM树结构表示
- 支持节点增删改查
- 支持属性操作
片段处理：
- 可以解析不完整的HTML片段
- 适用于处理用户输入或部分页面内容
访问者模式：
- 提供VisitMut trait实现自定义处理逻辑
- 支持深度优先遍历DOM树
- 可以中断遍历过程

文档

更多详细用法请参考官方文档。

sinazl 1楼作者

Rust HTML处理工具库swc_html_utils使用指南

概述

swc_html_utils是一个高效的Rust库，专门用于HTML文档的解析和操作。它基于swc项目(一个用Rust编写的可扩展平台)，提供了快速、安全的HTML处理能力。

主要特性

高性能HTML解析
符合HTML5规范的解析器
低内存占用
提供DOM操作API
支持HTML序列化

安装

在Cargo.toml中添加依赖：

[dependencies]
swc_html_utils = "0.1"

基本使用方法

解析HTML文档

use swc_html_utils::parser::ParserConfig;
use swc_html_utils::parse_document;

let html = r#"<html><body><h1>Hello, world!</h1></body></html>"#;
let config = ParserConfig::default();
let document = parse_document(html, config).unwrap();

println!("Parsed document: {:?}", document);

遍历DOM节点

use swc_html_utils::traverse::{traverse, Visitor};

struct MyVisitor;

impl Visitor for MyVisitor {
    fn visit_element(&mut self, element: &Element) {
        println!("Found element: {}", element.tag_name);
    }
}

let mut visitor = MyVisitor;
traverse(&document, &mut visitor);

修改HTML文档

use swc_html_utils::{
    create_element,
    dom::{Element, Node},
};

// 创建一个新的div元素
let mut div = create_element("div");
div.set_attribute("class", "container");

// 添加到body中
if let Some(body) = document.get_elements_by_tag_name("body").first() {
    body.append_child(Node::Element(div));
}

序列化回HTML

use swc_html_utils::serializer::serialize;

let html_output = serialize(&document);
println!("{}", html_output);

高级用法

处理HTML片段

use swc_html_utils::parse_fragment;

let fragment = r#"<div><p>Fragment content</p></div>"#;
let config = ParserConfig::default();
let nodes = parse_fragment(fragment, config).unwrap();

for node in nodes {
    println!("Fragment node: {:?}", node);
}

使用CSS选择器查询元素

use swc_html_utils::select::Selector;

let selector = Selector::parse(".container > p").unwrap();
let elements = document.query_selector_all(&selector);

for element in elements {
    println!("Found matching element: {:?}", element);
}

处理HTML实体

use swc_html_utils::entities::{decode, encode};

let encoded = "&lt;div&gt;";
let decoded = decode(encoded).unwrap();
println!("Decoded: {}", decoded); // 输出: <div>

let to_encode = "<div>";
let encoded = encode(to_encode);
println!("Encoded: {}", encoded); // 输出: &lt;div&gt;

性能提示

重用ParserConfig实例以减少配置开销
对于大型文档，考虑使用流式解析
批量DOM操作比多次单次操作更高效

错误处理

match parse_document(invalid_html, ParserConfig::default()) {
    Ok(doc) => {
        // 处理文档
    }
    Err(e) => {
        eprintln!("解析错误: {}", e);
        // 错误恢复或处理
    }
}

完整示例demo

下面是一个完整的使用swc_html_utils处理HTML文档的示例：

use swc_html_utils::{
    parser::ParserConfig,
    parse_document,
    traverse::{traverse, Visitor},
    create_element,
    dom::{Element, Node},
    serializer::serialize,
    select::Selector,
    entities::{decode, encode}
};

// 定义一个自定义访问器用于遍历DOM
struct MyVisitor;

impl Visitor for MyVisitor {
    fn visit_element(&mut self, element: &Element) {
        println!("访问元素: {}", element.tag_name);
        
        // 打印元素的所有属性
        for (name, value) in element.attributes.iter() {
            println!("属性: {} = {}", name, value);
        }
    }
}

fn main() {
    // 1. 解析HTML文档
    let html = r#"
    <!DOCTYPE html>
    <html>
    <head>
        <title>示例页面</title>
    </head>
    <body>
        <div class="container">
            <h1>欢迎使用swc_html_utils</h1>
            <p>这是一个演示。</p>
        </div>
    </body>
    </html>
    "#;
    
    let config = ParserConfig::default();
    let document = parse_document(html, config).unwrap();
    
    // 2. 遍历DOM节点
    println!("=== 遍历DOM ===");
    let mut visitor = MyVisitor;
    traverse(&document, &mut visitor);
    
    // 3. 修改文档 - 添加新元素
    println!("\n=== 修改DOM ===");
    let mut new_div = create_element("div");
    new_div.set_attribute("id", "new-section");
    new_div.set_attribute("class", "highlight");
    
    if let Some(body) = document.get_elements_by_tag_name("body").first() {
        body.append_child(Node::Element(new_div));
        println!("已添加新div到body");
    }
    
    // 4. 使用CSS选择器查询元素
    println!("\n=== CSS选择器查询 ===");
    let selector = Selector::parse(".container > p").unwrap();
    let elements = document.query_selector_all(&selector);
    
    for element in elements {
        println!("找到匹配元素: {:?}", element);
    }
    
    // 5. 处理HTML实体
    println!("\n=== HTML实体处理 ===");
    let encoded = "&lt;div class=&quot;test&quot;&gt;";
    let decoded = decode(encoded).unwrap();
    println!("解码前: {}", encoded);
    println!("解码后: {}", decoded);
    
    // 6. 序列化文档
    println!("\n=== 序列化HTML ===");
    let html_output = serialize(&document);
    println!("最终HTML:\n{}", html_output);
}

这个完整示例演示了swc_html_utils的主要功能：

解析HTML文档
遍历DOM结构
修改文档内容
使用CSS选择器查询
处理HTML实体
序列化回HTML

swc_html_utils提供了强大而灵活的工具集来处理HTML文档，结合了Rust的安全性和高性能特点，是构建HTML处理工具的理想选择。