
umya-spreadsheet
Bibliothèque Rust pure pour les fichiers XLSX/XLSM
Lire, écrire, styliser et manipuler des feuilles de calcul XLSX/XLSM sans aucune dépendance externe.
Qu'est-ce que umya-spreadsheet ?
umya-spreadsheet est une bibliothèque Rust pure, haute performance, pour lire et écrire des fichiers de feuilles de calcul Excel aux formats XLSX et XLSM. Conçue pour la sécurité et l’efficacité, elle évite le code non sécurisé et les dépendances externes, ce qui la rend idéale pour les applications de bureau, le traitement côté serveur et les environnements WebAssembly. La bibliothèque fournit une API Rust propre et idiomatique pour accéder aux cellules, lignes, colonnes, styles, graphiques et images, permettant aux développeurs de créer des outils de feuille de calcul robustes sans dépendre de Microsoft Office ou de l’interop COM.
Grâce à une prise en charge complète du chargement paresseux, de la protection par mot de passe et d’un formatage riche, umya-spreadsheet comble le fossé entre performance et convivialité. Elle prend en charge l’exportation CSV, la génération de graphiques, l’intégration d’images et les opérations sur les plages comme le déplacement et la copie. Le projet est activement maintenu, bien documenté et testé, avec un accent sur la justesse et la compatibilité avec les fonctionnalités modernes d’Excel. Les développeurs peuvent l’intégrer dans des outils CLI, des back‑ends web ou des applications de bureau en utilisant des frameworks comme Tauri ou Axo.
Premiers pas avec umya-spreadsheet
Pour commencer à utiliser umya-spreadsheet, ajoutez‑le à votre Cargo.toml avec `umya-spreadsheet = "3.1.1"`. Pour la prise en charge de WebAssembly, activez la fonctionnalité `js`. La bibliothèque est légère en dépendances et se compile rapidement. Une fois installé, importez‑le via `extern crate umya_spreadsheet;` et commencez à lire ou écrire des feuilles de calcul. Vous pouvez également explorer le GitHub umya-spreadsheet pour des exemples, des tests et de la documentation. Elle prend en charge le chargement paresseux pour les gros fichiers et offre une gestion d’erreurs robuste.
Installer umya-spreadsheet via Cargo
[dependencies]
umya-spreadsheet = "3.1.1"
# WebAssembly support
umya-spreadsheet = { version = "3.1.1", features = ["js"] }
Lire et écrire des fichiers XLSX/XLSM
umya-spreadsheet fournit des API intuitives pour lire et écrire des fichiers XLSX et XLMS. Utilisez `reader::xlsx::read()` pour charger un classeur depuis le disque, ou `new_file()` pour en créer un vierge. L'écriture est tout aussi simple : appelez `writer::xlsx::write()` avec le classeur et le chemin cible. La bibliothèque prend en charge le chargement paresseux via `lazy_read()` pour améliorer les performances sur les gros fichiers, et permet l'écriture protégée par mot de passe ou la définition de mots de passe après la création. Toutes les opérations sont sûres, zéro copie lorsque cela est possible, et évitent les binaires externes.
Comment lire et écrire un fichier XLSX avec Rust ?
use std::path::Path;
// Read file
let path = Path::new("./input.xlsx");
let mut book = umya_spreadsheet::reader::xlsx::read(path).unwrap();
// Write file
let out_path = Path::new("./output.xlsx");
umya_spreadsheet::writer::xlsx::write(&book, out_path).unwrap();
Accès aux cellules et manipulation du style
L'accès et la modification des valeurs de cellules sont simples : utilisez `cell("A1")` ou `cell((1,1))` pour la lecture, et `cell_mut()` pour l'écriture. Les styles sont gérés via `style_mut()`, permettant de modifier la couleur d'arrière-plan, la police, les bordures et l'alignement. La bibliothèque expose un ensemble riche de propriétés de style tout en maintenant les garanties d'immutabilité lorsque cela est possible. Vous pouvez également récupérer les valeurs formatées, appliquer une logique conditionnelle et mettre à jour en lot les styles sur des plages. Cela la rend idéale pour générer des rapports, des tableaux de bord ou des exportations de données avec un formatage cohérent.
Comment modifier la valeur et le style d’une cellule via Rust ?
let mut book = umya_spreadsheet::new_file();
book.sheet_by_name_mut("Sheet1")
.unwrap()
.cell_mut("A1")
.set_value("Hello, Rust!");
let mut style = book.sheet_by_name_mut("Sheet1")
.unwrap()
.style_mut("A1");
style.set_background_color(umya_spreadsheet::Color::COLOR_RED);
Prise en charge des graphiques et des images
umya-spreadsheet prend en charge la création et la modification de graphiques—y compris les graphiques en ligne, à barres et de zone—en définissant les plages de séries et les marqueurs. Vous pouvez intégrer des images directement dans les feuilles en utilisant la structure `Image`, avec prise en charge du PNG et d’autres formats selon les fonctionnalités activées. Les graphiques et les images s’intègrent parfaitement aux coordonnées des cellules et aux calques de dessin, permettant la génération dynamique de tableaux de bord. Bien que certaines fonctionnalités de dessin avancées soient encore en cours de développement, la fonctionnalité de base est prête pour la production et extensible.
Comment ajouter un graphique en courbes à une feuille de calcul via Rust ?
let mut book = umya_spreadsheet::new_file();
let mut from_marker = umya_spreadsheet::structs::drawing::spreadsheet::MarkerType::default();
from_marker.set_coordinate("C1");
let mut to_marker = umya_spreadsheet::structs::drawing::spreadsheet::MarkerType::default();
to_marker.set_coordinate("D11");
let series = vec!["Sheet1!$A$1:$A$10", "Sheet1!$B$1:$B$10"];
let mut chart = umya_spreadsheet::structs::Chart::default();
chart.new_chart(
umya_spreadsheet::structs::ChartType::LineChart,
from_marker,
to_marker,
series,
);
book.sheet_by_name_mut("Sheet1")
.unwrap()
.add_chart(chart);
Opérations sur les plages et protection par mot de passe
Effectuez des opérations avancées telles que le déplacement, la copie et le redimensionnement de plages en utilisant `move_range()`, permettant la réorganisation dynamique des données. La bibliothèque prend également en charge les classeurs protégés par mot de passe : écrivez des fichiers avec `write_with_password()` ou appliquez des mots de passe aux fichiers existants via `set_password()`. Ces fonctionnalités sont essentielles pour la gestion sécurisée des données dans les entreprises ou les applications sensibles à la conformité. Associé à une conception sans dépendances et à la compatibilité WASM, umya-spreadsheet offre à la fois flexibilité et sécurité.
Comment déplacer une plage et protéger un fichier par mot de passe via Rust ?
// Move range
let range = "A1:A3";
book.sheet_by_name_mut("Sheet1")
.unwrap()
.move_range(range, &10, &2);
// Password protection
umya_spreadsheet::writer::xlsx::write_with_password(
&book,
Path::new("./protected.xlsx"),
"mypassword",
).unwrap();
