Trabajo con XML en Rust: bibliotecas roxmltree, quick-xml y serde-xml-rs

Trabajo con XML en Rust: revisión de bibliotecas y ejemplos prácticos

Rust es un lenguaje de programación de sistemas moderno que se utiliza cada vez más para crear servicios web de alta carga, herramientas de línea de comandos y sistemas embebidos. Al trabajar con datos, a menudo surge la necesidad de procesar documentos XML. A diferencia de Python, donde la biblioteca estándar xml.etree.ElementTree cubre la mayoría de las tareas, en Rust el ecosistema ofrece varios crates especializados con diferentes enfoques. En este artículo, analizaremos tres de las herramientas más populares para trabajar con XML en Rust: roxmltree, quick-xml y serde-xml-rs.

1. roxmltree — analizador rápido y seguro solo para lectura

roxmltree es un crate diseñado exclusivamente para la lectura de XML. No admite la mutación ni la creación de documentos, pero proporciona un analizador muy rápido y confiable con soporte completo para espacios de nombres (namespaces). La principal ventaja es el trabajo con datos prestados (zero-copy), lo que minimiza la asignación de memoria.

// cargo add roxmltreeuse roxmltree::Document;

fn main() -> Result<(), roxmltree::Error> {    let xml = r#"    <root>        <item id="1">Primer elemento</item>        <item id="2">Segundo elemento</item>    </root>"#;

    let doc = Document::parse(xml)?;

    // Obtenemos el elemento raíz    let root = doc.root_element();    println!("Elemento raíz: {}", root.tag_name().name());

    // Buscamos todos los elementos hijos <item>    for item in root.children().filter(|n| n.has_tag_name("item")) {        let id = item.attribute("id").unwrap_or("unknown");        let text = item.text().unwrap_or("");        println!("ID: {}, Texto: {}", id, text);    }

    Ok(())}

Cuándo usarlo: si solo necesita leer archivos XML (configuraciones, respuestas de API, feeds RSS) y el máximo rendimiento es importante. roxmltree es ideal para análisis de una sola vez.

2. quick-xml — analizador universal con soporte de lectura y escritura

quick-xml es el crate más popular para trabajar con XML en Rust. Admite tanto el análisis (basado en eventos y similar a DOM) como la serialización (escritura) de XML. Funciona tanto con flujos (Reader) como con cadenas completas. Soporta atributos, CDATA, comentarios y secuencias de escape.

// cargo add quick-xmluse quick_xml::Reader;use quick_xml::events::Event;

fn main() -> Result<(), quick_xml::Error> {    let xml = r#"<library>    <book genre="rust">Programación en Rust</book>    <book genre="python">Python para principiantes</book></library>"#;

    let mut reader = Reader::from_str(xml);    reader.trim_text(true);    let mut txt = String::new();    let mut current_genre = String::new();

    loop {        match reader.read_event_into(&mut txt) {            Ok(Event::Start(ref e)) => {                if e.name().as_ref() == b"book" {                    // Obtenemos el atributo genre                    if let Some(attr) = e.attributes().flatten().find(|a| a.key.as_ref() == b"genre") {                        current_genre = String::from_utf8_lossy(&attr.value).to_string();                    }                }            }            Ok(Event::Text(ref e)) => {                let text = e.unescape()?;                println!("Género: {}, Título: {}", current_genre, text);            }            Ok(Event::Eof) => break,            Err(e) => panic!("Error: {:?}", e),            _ => {}        }        txt.clear();    }    Ok(())}

Cuándo usarlo: si necesita flexibilidad — leer archivos grandes de forma fluida, crear nuevos documentos XML o