1. Produits
  2.   Aspose.Cells
  3.   Aspose.Cells FOSS for Rust

Aspose.Cells FOSS pour Rust

crate Rust open source pour créer, lire, modifier et enregistrer des feuilles de calcul Excel XLSX sans dépendances Office.

Aspose.Cells FOSS — Bibliothèque Rust Open Source

Aspose.Cells FOSS for Rust est une bibliothèque open-source pour travailler avec les feuilles de calcul Excel XLSX dans les applications Rust. Elle offre aux programmeurs systèmes une méthode native et sûre en mémoire pour créer des classeurs à partir de zéro, charger des fichiers XLSX existants, modifier leur contenu et enregistrer le résultat — sans Microsoft Office, automatisation COM, ni aucun runtime externe.

Le crate modélise l’arbre complet d’objets de la feuille de calcul : Workbook, Worksheet et les collections de cellules avec des définisseurs de valeurs typées (put_value_string, put_value_i32, put_value_bool, put_value_decimal), des formules avec valeurs en cache via put_formula_with_cached_value, des graphiques (Chart, ChartType), le formatage conditionnel (FormatCondition), la validation des données (Validation), les filtres automatiques (AutoFilter), le style des cellules (CellStyle, Font, Fill, Borders), la configuration de la page (PageSetup), les images, les formes, les commentaires, les hyperliens, les tableaux (ListObject), les sparklines (SparklineGroup), les noms définis, ainsi que la protection du classeur/feuille.

Aspose.Cells FOSS for Rust est sous licence MIT et cible l’édition Rust 2021. Il s’installe comme une dépendance Cargo standard depuis le dépôt GitHub — consultez le guide d’installation pour l’entrée exacte du Cargo.toml. Les erreurs sont exposées via les types Result conventionnels (CellsError), et le chargement XLSX propose des options de réparation (LoadOptions) avec des diagnostics structurés (LoadDiagnostics). Pour la famille de produits d’entreprise, voir Aspose.Cells — Enterprise Product Family.

Gestion des classeurs et des feuilles de calcul

  • Créez des classeurs vides avec Workbook::new ou chargez des fichiers existants avec Workbook::load_xlsx
  • Ajoutez et accédez aux feuilles via add_worksheet, worksheet et les collections de feuilles mutables
  • Enregistrez sur le disque avec save, save_xlsx ou save_with_format explicite du format
  • Contrôlez les vues du classeur, les paramètres et les propriétés du document

Où cela s’insère

  • Services back-end générant des rapports XLSX sans Office installé
  • Outils CLI qui produisent par lots ou post-traitent des feuilles de calcul
  • Pipelines de données Rust exportant des résultats tabulaires pour les utilisateurs métier

Données de cellule, Formules, et Types

  • Définisseurs typés : put_value_string, put_value_i32, put_value_bool, put_value_decimal, put_value_date_time
  • Écrire des formules avec des résultats mis en cache via put_formula_with_cached_value
  • Lire les valeurs avec display_string_value et value_type
  • Faire référence aux cellules par nom A1 ou par indice ligne/colonne (get, get_by_index)

Utilisations pratiques

  • Exportations financières où les formules doivent s’ouvrir avec les valeurs mises en cache correctes
  • Modèles de saisie de données avec des colonnes typées
  • Édition en aller-retour de classeurs fournis par l’utilisateur

Style et mise en page

  • Style des cellules via CellStyle avec Font, Fill et Borders
  • Appliquer des mises à jour de style ciblées avec StyleFlag
  • Formatage des nombres via NumberFormat
  • Impression et mise en page via PageSetup (taille du papier, orientation, marges)
  • Geler les volets avec FreezePane ; contrôler la visibilité des lignes/colonnes

Pourquoi c’est important

  • Rapports personnalisés, prêts à imprimer directement depuis les services Rust
  • Exportations lisibles avec les formats de nombres et de dates appropriés
  • Grandes feuilles qui restent navigables grâce aux lignes d’en-tête gelées

Graphiques, Images et Formes

  • Ajouter des graphiques en colonnes, en lignes et d’autres types via ChartType sur la collection de graphiques d’une feuille
  • Lire les ancres et les types de graphiques à partir des fichiers chargés (Chart, ChartCollection)
  • Intégrer des images avec Picture et des formes de dessin avec Shape
  • Compacter les tendances en cellule avec SparklineGroup

Cas d’utilisation

  • Tableaux de bord et classeurs KPI générés selon un planning
  • Résumés visuels intégrés à côté des données brutes
  • Placement automatisé de graphiques à partir de plages de données

Analyse des données et protection

  • Règles de mise en forme conditionnelle via FormatCondition
  • Règles de validation des données via Validation avec OperatorType
  • Auto-filtres via AutoFilter; tables structurées via ListObject
  • Noms définis via DefinedName; protection via WorkbookProtection et WorksheetProtection
  • Chargement XLSX robuste avec les drapeaux de réparation LoadOptions et LoadDiagnostics

Qui bénéficie

  • Équipes livrant des classeurs de saisie de données validés
  • Services ingestant des fichiers XLSX tiers qui peuvent nécessiter une réparation
  • Analystes recevant des rapports pré-filtrés et protégés

Créer, enregistrer et recharger un Workbook

Créer un classeur, écrire des valeurs typées et une formule avec un résultat mis en cache, l’enregistrer au format XLSX et le recharger :

use aspose_cells_foss_rust::{CellValue, Workbook};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    // Create a new workbook (starts with one sheet, "Sheet1").
    let mut workbook = Workbook::new();
    {
        let mut worksheets = workbook.get_worksheets_mut();
        let sheet = worksheets.get(0)?;
        let mut cells = sheet.get_cells_mut();

        cells.get("A1")?.put_value_string("Hello")?;
        cells.get("B1")?.put_value_i32(123)?;
        cells.get("C1")?.put_value_bool(true)?;
        cells.get("D1")?.put_value_decimal(12.5)?;
        cells.get("F1")?.put_value_i32(10)?;
        cells.get("G1")?
            .put_formula_with_cached_value("=F1*2", CellValue::Number(20.0))?;
    }
    workbook.save("hello.xlsx")?;

    // Load it back.
    let loaded = Workbook::load_xlsx("hello.xlsx")?;
    let sheet = loaded.worksheet("Sheet1")?;
    let cells = sheet.get_cells();
    println!("A1 = {}", cells.get("A1")?.display_string_value());

    Ok(())
}

Charger des fichiers XLSX avec des options de réparation

Ouvrez les classeurs de manière défensive avec les drapeaux de réparation LoadOptions et inspectez les diagnostics de chargement structurés :

let options = LoadOptions {
    try_repair_package: true,
    try_repair_xml: true,
    ..LoadOptions::default()
};

let loaded = Workbook::load_xlsx_with_options(&valid_path, &options)?;
let sheet = loaded.worksheet("Sheet1")?;
let cells = sheet.get_cells();

println!("Saved: {}", valid_path.display());
println!(
    "Loaded workbook with {} worksheet(s) and {} diagnostic issue(s).",
    loaded.get_worksheets().count(),
    loaded.get_load_diagnostics().issues().len()
);

Ajouter des graphiques à partir de plages de données

Remplissez une plage de données, puis ancrez les graphiques en colonnes et en lignes dessus :

let mut charts = sheet.get_charts();
charts.add(
    ChartType::Column,
    "Charts!$B$1:$B$13".to_string(),
    0,
    4,
    18,
    8,
)?;
charts.add(
    ChartType::Line,
    "Charts!$C$1:$C$13".to_string(),
    0,
    9,
    18,
    13,
)?;

Foire aux questions

Quelle licence utilise Aspose.Cells FOSS for Rust ?

Le crate est publié sous la licence MIT ; le texte complet est fourni dans le dépôt sous le nom LICENSE.txt.

Puis-je l’utiliser dans des produits commerciaux ?

Oui. La MIT License autorise l’utilisation commerciale, la modification et la redistribution, à condition que l’avis de droit d’auteur et de licence soit préservé.

Comment installer le crate ?

Ajoutez aspose-cells-foss-rust à votre Cargo.toml en tant que dépendance git depuis le dépôt GitHub.

Quels formats peuvent être lus et écrits ?

XLSX, avec lecture et écriture complètes en aller-retour via Workbook::load_xlsx et save. Les autres formats de tableur ne sont pas pris en charge dans la version actuelle.

Cela nécessite-t-il Microsoft Office ?

Non. La bibliothèque lit et écrit le format de paquet XLSX directement — aucune installation d’Office, aucune automatisation COM, ou aucun runtime externe n’est impliqué.

  

Ressources de support et d'apprentissage

 Français