Travailler avec XML en Rust : bibliothèques pour l'analyse…

Travailler avec XML en Rust : aperçu des bibliothèques et exemples pratiques

Rust est un langage de programmation système moderne, de plus en plus utilisé pour créer des services web à forte charge, des outils en ligne de commande et des systèmes embarqués. Lors du traitement de données, il est souvent nécessaire de manipuler des documents XML. Contrairement à Python, où la bibliothèque standard xml.etree.ElementTree couvre la plupart des besoins, l'écosystème Rust propose plusieurs crates spécialisés avec des approches différentes. Dans cet article, nous examinerons trois outils les plus populaires pour travailler avec XML en Rust : roxmltree, quick-xml et serde-xml-rs.

1. roxmltree — un analyseur rapide et sécurisé en lecture seule

roxmltree est un crate dédié exclusivement à la lecture de XML. Il ne prend pas en charge la mutation ou la création de documents, mais offre un analyseur très rapide et fiable avec un support complet des espaces de noms (namespaces). Son principal avantage est le travail avec des données empruntées (zero-copy), ce qui minimise l'allocation mémoire.

// cargo add roxmltreeuse roxmltree::Document;

fn main() -> Result<(), roxmltree::Error> {    let xml = r#"    <root>        <item id="1">Premier élément</item>        <item id="2">Deuxième élément</item>    </root>"#;

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

    // Obtenir l'élément racine    let root = doc.root_element();    println!("Élément racine : {}", root.tag_name().name());

    // Chercher tous les éléments enfants <item>    for item in root.children().filter(|n| n.has_tag_name("item")) {        let id = item.attribute("id").unwrap_or("inconnu");        let text = item.text().unwrap_or("");        println!("ID : {}, Texte : {}", id, text);    }

    Ok(())}

Quand l'utiliser : si vous avez seulement besoin de lire des fichiers XML (configurations, réponses API, flux RSS) et que la performance maximale est importante. roxmltree est idéal pour une analyse unique.

2. quick-xml — un analyseur universel avec support de lecture et d'écriture

quick-xml est le crate le plus populaire pour travailler avec XML en Rust. Il prend en charge à la fois l'analyse (par événements et de type DOM) et la sérialisation (écriture) de XML. Il fonctionne aussi bien avec des flux (Reader) qu'avec des chaînes entières. Il supporte les attributs, CDATA, commentaires et séquences d'échappement.

// 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">Programmation en Rust</book>    <book genre="python">Python pour débutants</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" {                    // Obtenir l'attribut 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!("Genre : {}, Titre : {}", current_genre, text);            }            Ok(Event::Eof) => break,            Err(e) => panic!("Erreur : {:?}", e),            _ => {}        }        txt.clear();    }    Ok(())}

Quand l'utiliser : si vous avez besoin de flexibilité — lire de gros fichiers en flux, créer de nouveaux documents XML ou