Introduktion

Aspose.Cells FOSS för Rust tar med Aspose.Cells FOSS-familjen till Rust-ekosystemet. Craten aspose-cells-foss-rust låter Rust-applikationer skapa Excel-XLSX-arbetsböcker från början, ladda befintliga filer, modifiera deras innehåll och spara resultatet — utan Microsoft Office-installation, COM-automation eller extern runtime.

Craten är licensierad under MIT och riktar sig mot Rust-edition 2021. Den följer de konventioner som Rust-utvecklare förväntar sig: konstruktorer som Workbook::new, Result-baserad felhantering via CellsError, och explicita muterbara åtkomstmetoder såsom get_worksheets_mut och get_cells_mut som håller låningsreglerna tydliga. Om du bygger backend-tjänster, CLI-verktyg eller datapipelines som behöver producera eller konsumera kalkylblad, ger detta bibliotek dig ett inbyggt sätt att göra det.

Detta avsnitt har granskats mot den aktuella källmodellen för den senaste produktbeteendet och API-täckning.

Aspose.Cells FOSS är redan tillgänglig för .NET, C++, Java, Python och TypeScript; Rust-crate:n ansluter sig till familjen med samma fokus: ärligt, verifierbart XLSX-stöd under en permissiv licens.

Vad som ingår

Arbetsböcker, arbetsblad och typade cellvärden

En Workbook startar med ett kalkylblad och växer via add_worksheet. Celler accepterar typade värden — strängar, heltal, booleska, decimaltal och datum-tider — genom dedikerade set-metoder, så inga string-baserade konverteringar behövs:

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

Formler med cachade resultat

Formler skrivs tillsammans med ett cachat värde, så den sparade filen öppnas i Excel med korrekta resultat omedelbart — ingen omräkningspass krävs:

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

Diagram förankrade till dataområden

Kolumn-, linje- och andra diagramtyper från ChartType-enum kan förankras till cellområden i ett kalkylblad, och diagramgeometri kan läsas tillbaka från inlästa filer:

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

Formatering, sidinställning och struktur

Cellformatering sker via CellStyle med Font, Fill och Borders, applicerad selektivt med StyleFlag. PageSetup styr papperstorlek och orientering för utskrift, FreezePane håller rubrikrader synliga, och strukturerade tabeller kommer via ListObject med TableStyleType.

Validering, villkorsstyrd formatering och filter

Datakvalitetsfunktioner är en del av kärnan: Validation-regler med OperatorType, villkorlig formatering via FormatCondition, autofilter via AutoFilter, definierade namn via DefinedName, samt skydd för arbetsbok eller kalkylblad genom WorkbookProtection och WorksheetProtection.

Defensiv inläsning med diagnostik

XLSX-filer i verkligheten är inte alltid välformade. LoadOptions exponerar reparationsflaggor, och LoadDiagnostics rapporterar vad laddaren stötte på:

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

Snabbstart

Lägg till paketet i din Cargo.toml som ett git-beroende (paketet är ännu inte publicerat på crates.io):

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

Skapa sedan, spara och ladda om din första arbetsbok:

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

Stödda format

FormatFiländelseLäsSkriv
XLSX.xlsx✓✓

XLSX är huvudfokus i den aktuella releasen: fullständig rundresa för läsning och skrivning via Workbook::load_xlsx och Workbook::save, med LoadFormat- och SaveFormat-enum som styr explicit formatval.

Öppen källkod & licensiering

Aspose.Cells FOSS för Rust är licensierad under MIT. Den kompletta källkoden finns tillgänglig på GitHub, och licensen tillåter kommersiell användning, modifiering och vidaredistribution.

Komma igång

Relaterade resurser