Introductie

Aspose.Cells FOSS voor Rust brengt de Aspose.Cells FOSS familie naar het Rust-ecosysteem. De aspose-cells-foss-rust crate stelt Rust-applicaties in staat Excel-XLSX-werkboeken vanaf nul te maken, bestaande bestanden te laden, hun inhoud te wijzigen en het resultaat op te slaan — zonder Microsoft Office-installatie, COM-automatisering of een externe runtime.

De crate heeft een MIT-licentie en richt zich op Rust-edition 2021. Hij volgt de conventies die Rust-ontwikkelaars verwachten: constructors zoals Workbook::new, op Result gebaseerde foutafhandeling via CellsError, en expliciete mutabele accessors zoals get_worksheets_mut en get_cells_mut die de leenvregels duidelijk houden. Als je backend-services, CLI-tools of datapijplijnen bouwt die spreadsheets moeten produceren of consumeren, biedt deze bibliotheek je een native manier om dat te doen.

Deze sectie is beoordeeld aan de hand van het huidige source-model voor het laatste productgedrag en de API-dekking.

Aspose.Cells FOSS is al beschikbaar voor .NET, C++, Java, Python en TypeScript; de Rust-crate voegt zich bij de familie met dezelfde focus: eerlijke, verifieerbare XLSX-ondersteuning onder een permissieve licentie.

Wat er inbegrepen is

Werkboeken, Werkbladen en Getypeerde Celwaarden

Een Workbook begint met één werkblad en groeit via add_worksheet. Cellen accepteren getypeerde waarden — strings, integers, booleans, decimals en datum-tijden — via toegewijde setters, zodat er geen string-gebaseerde conversies nodig zijn:

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")?;

Formules met gecachte resultaten

Formules worden geschreven samen met een gecachte waarde, zodat het opgeslagen bestand direct in Excel opent met correcte resultaten — geen herberekeningsstap nodig:

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

Grafieken verankerd aan gegevensbereiken

Kolom-, lijn- en andere grafiektypes uit de ChartType-enum kunnen worden verankerd aan celbereiken op een werkblad, en de grafiekgeometrie kan worden teruggelezen uit geladen bestanden:

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

Stijlen, paginainstelling en structuur

Celopmaak verloopt via CellStyle met Font, Fill en Borders, die selectief worden toegepast met StyleFlag. PageSetup regelt papierformaat en -oriëntatie voor afdruk, FreezePane houdt koprijen zichtbaar, en gestructureerde tabellen komen via ListObject met TableStyleType.

Validatie, voorwaardelijke opmaak en filters

Data-kwaliteitsfuncties maken deel uit van de core-interface: Validation-regels met OperatorType, voorwaardelijke opmaak via FormatCondition, autofilters via AutoFilter, gedefinieerde namen via DefinedName, en bescherming van werkboeken of werkbladen via WorkbookProtection en WorksheetProtection.

Defensief laden met diagnostiek

XLSX-bestanden uit de praktijk zijn niet altijd goed gevormd. LoadOptions biedt herstel-vlaggen, en LoadDiagnostics rapporteert wat de loader tegenkwam:

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()
);

Snelstart

Voeg de crate toe aan je Cargo.toml als een git-dependency (de crate is nog niet gepubliceerd op crates.io):

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

Maak vervolgens je eerste werkboek, sla het op en laad het opnieuw:

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

Ondersteunde formaten

FormaatExtensieLezenSchrijven
XLSX.xlsx✓✓

XLSX staat centraal in de huidige release: volledige round-trip lezen en schrijven via Workbook::load_xlsx en Workbook::save, met de LoadFormat- en SaveFormat-enumeraties die expliciete formatselectie regelen.

Open source & licenties

Aspose.Cells FOSS voor Rust is gelicentieerd onder de MIT-licentie. De volledige broncode is beschikbaar op GitHub, en de licentie staat commercieel gebruik, modificatie en herdistributie toe.

Aan de slag

Gerelateerde bronnen