
rust_xlsxwriter
Bibliothèque Rust open source pour les fichiers Excel XLSX
Générer des fichiers Excel 2007+ XLSX avec un formatage complet, des graphiques, des formules et des images via l'API Rust.
Qu'est-ce que rust_xlsxwriter ?
rust_xlsxwriter est une crate Rust pure et haute performance pour générer des fichiers Excel XLSX sans nécessiter Excel ni dépendances externes. Elle permet aux développeurs de créer programmétiquement des feuilles de calcul contenant du texte, des nombres, des dates, des formules, des graphiques, des images, des cellules fusionnées, une mise en forme conditionnelle, une validation de données, et plus encore. Conçue pour la fiabilité et la rapidité, elle correspond étroitement au format de fichier natif d’Excel et prend en charge le mode mémoire constante pour les grands ensembles de données. La bibliothèque est une réécriture fidèle en Rust de la populaire bibliothèque Python XlsxWriter, avec des API idiomatiques et une documentation complète.
rust_xlsxwriter se concentre exclusivement sur l'écriture de fichiers Excel — aucune lecture ni modification de fichiers existants. Il prend en charge les fonctionnalités modernes d'Excel telles que les tableaux dynamiques, les sparklines, les cases à cocher, les zones de texte, les tableaux, les filtres automatiques, les noms définis et les thèmes de classeur. Avec des fonctionnalités optionnelles comme la sérialisation Serde, la prise en charge des dates chrono/jiff et l'intégration Polars, il s'adapte à divers écosystèmes Rust. Ses performances ne sont dépassées que par la version C, offrant une exécution 3,8× plus rapide que XlsxWriter de Python. Pour plus de détails, consultez le dépôt GitHub rust_xlsxwriter.
Premiers pas avec rust_xlsxwriter
rust_xlsxwriter est disponible sur crates.io et peut être installé via `cargo add rust_xlsxwriter`. Pour des fonctionnalités améliorées, activez les fonctionnalités optionnelles comme `constant_memory`, `chrono`, `serde` ou `polars`. La bibliothèque nécessite Rust 1.56+ et se compile en binaires natifs sans dépendances d'exécution externes au-delà de la crate `zip` (par défaut). Elle est entièrement documentée avec un guide utilisateur, un tutoriel et un cookbook. Pour des exemples détaillés et le code source, visitez le dépôt GitHub rust_xlsxwriter.
Installer rust_xlsxwriter via Cargo
cargo add rust_xlsxwriterÉcrire des cellules formatées avec du texte, des nombres et des dates
rust_xlsxwriter fournit une API simple et intuitive pour écrire du contenu formaté dans les cellules Excel. Les développeurs peuvent appliquer des formats personnalisés pour les nombres, les dates, les polices, les bordures, l'alignement et les couleurs en utilisant la structure `Format`. La bibliothèque prend en charge l'écriture de texte brut, de valeurs numériques, de dates, de formules et d'URL avec un formatage optionnel. Elle supporte également les chaînes multi-format riches pour un formatage mixte au sein d'une même cellule. Cela la rend idéale pour générer des rapports, des tableaux de bord et des exportations de données où la clarté visuelle et la structure sont essentielles. L'API garantit une haute fidélité avec le moteur de formatage natif d'Excel.
Comment écrire du texte, des nombres et des dates formatés avec Rust ?
use rust_xlsxwriter::*;
let mut workbook = Workbook::new();
let worksheet = workbook.add_worksheet();
let bold = Format::new().set_bold();
let decimal = Format::new().set_num_format("0.00");
let date_fmt = Format::new().set_num_format("yyyy-mm-dd");
worksheet.write_with_format(0, 0, "Hello", &bold)?;
worksheet.write(1, 0, 123.456)?;
worksheet.write_with_format(2, 0, 789.012, &decimal)?;
let date = ExcelDateTime::from_ymd(2023, 12, 25)?;
worksheet.write_with_format(3, 0, &date, &date_fmt)?;
workbook.save("formatted.xlsx")?;Créer des graphiques, des sparklines et des images
rust_xlsxwriter prend en charge la génération de graphiques professionnels, de sparklines et l'intégration d'images directement dans les fichiers Excel. Les développeurs peuvent créer des graphiques à barres, en lignes, en secteurs, en nuage de points et de type zone avec des axes, légendes et séries de données personnalisables. Les sparklines offrent une visualisation compacte des tendances au sein des cellules. Les images (PNG, JPEG, GIF, BMP) peuvent être insérées et positionnées avec des options de mise à l'échelle et d'ancrage. Ces éléments visuels améliorent la narration des données et les capacités de reporting. La bibliothèque assure la compatibilité avec Excel 2007+ et préserve la fidélité du rendu sur toutes les plateformes.
Comment ajouter un graphique et une image à Excel via Rust ?
use rust_xlsxwriter::*;
let mut workbook = Workbook::new();
let worksheet = workbook.add_worksheet();
// Write sample data
for i in 0..5 {
worksheet.write_number(i, 0, (i + 1) as f64 * 10.0)?;
}
// Create a chart
let mut chart = Chart::new(ChartType::Column);
chart.add_series().set_values("Sheet1!$A$1:$A$5");
worksheet.insert_chart(0, 2, &chart)?;
// Insert an image
let image = Image::new("logo.png")?;
worksheet.insert_image(5, 2, &image)?;
workbook.save("chart_image.xlsx")?;Mise en forme avancée : cellules fusionnées, tableaux et mise en forme conditionnelle
rust_xlsxwriter permet des fonctionnalités avancées de mise en forme Excel telles que les plages fusionnées, les tableaux structurés, les filtres automatiques et les règles de mise en forme conditionnelle. Les développeurs peuvent fusionner des cellules pour les en-têtes ou les libellés, appliquer des styles de tableau avec des lignes/colonnes alternées, et définir des filtres pour l'interactivité utilisateur. La mise en forme conditionnelle prend en charge les échelles de couleur, les barres de données, les jeux d'icônes et les formules personnalisées pour mettre en évidence les tendances ou les anomalies. Ces fonctionnalités améliorent la lisibilité des données et l'interactivité dans les classeurs générés. L'API abstrait les structures XML complexes en méthodes Rust intuitives, garantissant la maintenabilité et la sécurité de type.
Comment fusionner des cellules et ajouter des tableaux avec une mise en forme conditionnelle ?
use rust_xlsxwriter::*;
let mut workbook = Workbook::new();
let worksheet = workbook.add_worksheet();
// Merge cells
let merge_fmt = Format::new()
.set_border(FormatBorder::Thin)
.set_align(FormatAlign::Center);
worksheet.merge_range(0, 0, 0, 2, "Report Header", &merge_fmt)?;
// Add table
worksheet.add_table(1, 0, 5, 2, Table::new().set_columns(&[
("Item", None),
("Value", None),
("Status", None),
]))?;
// Conditional formatting
worksheet.conditional_format(
2, 0, 5, 2,
ConditionalFormat::new()
.set_type(ConditionalFormatType::Cell)
.set_format(&Format::new().set_bg_color("#D8E4BC"))
.set_formula("=A2>100")
)?;
workbook.save("advanced.xlsx")?;Optimisation des performances et prise en charge des gros fichiers
rust_xlsxwriter est optimisé pour la rapidité et l'efficacité mémoire, en particulier pour les grands ensembles de données. Il prend en charge le mode mémoire constante (`constant_memory` feature), qui écrit les données de façon incrémentielle sur le disque, minimisant l'utilisation du tas. Ce mode est idéal pour générer des fichiers Excel de plusieurs mégaoctets sans erreurs OOM. Les benchmarks montrent qu'il est environ ~3.8× plus rapide que XlsxWriter de Python et seulement ~14% plus lent que la bibliothèque native en C. Des fonctionnalités optionnelles comme `zmij` et `zlib` accélèrent davantage les écritures numériques et la compression. Ces capacités le rendent adapté aux rapports batch, aux pipelines ETL et à la génération d'Excel côté serveur.
Comment activer le mode mémoire constante pour les gros fichiers ?
cargo add rust_xlsxwriter -F constant_memoryuse rust_xlsxwriter::*;
let mut workbook = Workbook::new();
workbook.set_constant_memory(true); // Enable constant memory mode
let worksheet = workbook.add_worksheet();
for i in 0..100_000 {
worksheet.write_number(i, 0, i as f64)?;
}
workbook.save("large_file.xlsx")?;