Einleitung

Aspose.Cells FOSS für Rust bringt die Aspose.Cells FOSS Familie in das Rust-Ökosystem. Die aspose-cells-foss-rust crate ermöglicht Rust-Anwendungen, Excel XLSX-Arbeitsmappen von Grund auf zu erstellen, vorhandene Dateien zu laden, deren Inhalte zu ändern und das Ergebnis zu speichern – ohne Microsoft Office-Installation, COM-Automatisierung oder externe Laufzeit.

Die crate ist unter der MIT-Lizenz veröffentlicht und richtet sich an Rust-Edition 2021. Sie folgt den Konventionen, die Rust-Entwickler erwarten: Konstruktoren wie Workbook::new, Result-basierte Fehlerbehandlung über CellsError und explizite mutable Accessoren wie get_worksheets_mut und get_cells_mut, die die Borrow-Regeln klar halten. Wenn Sie Backend-Services, CLI-Tools oder Datenpipelines bauen, die Tabellenkalkulationen erzeugen oder verarbeiten müssen, bietet Ihnen diese Bibliothek eine native Möglichkeit dazu.

Dieser Abschnitt wurde anhand des aktuellen Quellmodells für das neueste Produktverhalten und die API-Abdeckung geprüft.

Aspose.Cells FOSS ist bereits für .NET, C++, Java, Python und TypeScript verfügbar; das Rust-Crate ergänzt die Familie mit demselben Fokus: ehrliche, verifizierbare XLSX-Unterstützung unter einer permissiven Lizenz.

Was enthalten ist

Arbeitsmappen, Arbeitsblätter und typisierte Zellwerte

Ein Workbook beginnt mit einem Arbeitsblatt und wächst über add_worksheet. Zellen akzeptieren typisierte Werte – Zeichenketten, Ganzzahlen, Booleans, Dezimalzahlen und Datums-Zeitwerte – über dedizierte Setter, sodass keine stringbasierten Konvertierungen nötig sind:

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)?;
}
workbook.save("hello.xlsx")?;

Formeln mit zwischengespeicherten Ergebnissen

Formeln werden zusammen mit einem zwischengespeicherten Wert geschrieben, sodass die gespeicherte Datei in Excel sofort mit korrekten Ergebnissen geöffnet wird — ein Neuberechnungsdurchlauf ist nicht erforderlich:

cells.get("F1")?.put_value_i32(10)?;
cells.get("G1")?
    .put_formula_with_cached_value("=F1*2", CellValue::Number(20.0))?;

Diagramme an Datenbereiche angeheftet

Spalten-, Linien- und andere Diagrammtypen aus dem ChartType-Enum können an Zellbereiche eines Arbeitsblatts angeheftet werden, und die Diagrammgeometrie kann aus geladenen Dateien wieder ausgelesen werden:

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

Styling, Seiteneinrichtung und Struktur

Die Zellformatierung erfolgt über CellStyle mit Font, Fill und Borders und wird selektiv mit StyleFlag angewendet. PageSetup steuert Papiergröße und Ausrichtung für den Druck, FreezePane hält Kopfzeilen sichtbar, und strukturierte Tabellen werden über ListObject mit TableStyleType bereitgestellt.

Validierung, Bedingte Formatierung und Filter

Datenqualitäts-Features gehören zum Kernumfang: Validation-Regeln mit OperatorType, bedingte Formatierung über FormatCondition, Auto-Filter via AutoFilter, definierte Namen über DefinedName sowie Arbeitsmappen- oder Arbeitsblatt-Schutz durch WorkbookProtection und WorksheetProtection.

Defensives Laden mit Diagnostik

Echte XLSX-Dateien sind nicht immer wohlgeformt. LoadOptions stellt Reparatur-Flags bereit, und LoadDiagnostics berichtet, was der Loader festgestellt hat:

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

let loaded = Workbook::load_xlsx_with_options(&valid_path, &options)?;
println!(
    "Loaded workbook with {} worksheet(s) and {} diagnostic issue(s).",
    loaded.get_worksheets().count(),
    loaded.get_load_diagnostics().issues().len()
);

Schnellstart

Fügen Sie die crate zu Ihrem Cargo.toml als Git-Abhängigkeit hinzu (die crate ist noch nicht auf crates.io veröffentlicht):

# Cargo.toml
[dependencies]
aspose-cells-foss-rust = { git = "https://github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Rust" }

Erstelle, speichere und lade dein erstes Arbeitsbuch neu:

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("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(())
}

Unterstützte Formate

FormatErweiterungLesenSchreiben
XLSX.xlsx✓✓

XLSX steht im Mittelpunkt der aktuellen Veröffentlichung: Vollständiges Round-Trip-Lesen und -Schreiben über Workbook::load_xlsx und Workbook::save, wobei die Enums LoadFormat und SaveFormat die explizite Formatwahl steuern.

Open Source & Lizenzierung

Aspose.Cells FOSS für Rust ist unter der MIT-Lizenz lizenziert. Der vollständige Quellcode ist auf GitHub verfügbar, und die Lizenz erlaubt kommerzielle Nutzung, Modifikation und Weiterverteilung.

Erste Schritte

Verwandte Ressourcen