Introduktion

Aspose.Cells FOSS för Rust exponerar sin funktionalitet via aspose-cells-foss-rust-paketet, centrerat kring en kompakt uppsättning kärntyper: Workbook, Worksheet, Cells, Cell och DocumentProperties, var och en med matchande *Mut-accessorer för skrivåtkomst. Detta inlägg är en systematisk genomgång av den kärn API-ytan — inte en smal funktion, utan grunderna som varje applikation byggd på paketet slutligen använder: skapa och namnge arbetsblad, läsa och skriva typade cellvärden, sätta dokumentmetadata, skydda och dölja arbetsblad, justera rader och kolumner, slå ihop celler och läsa in filer på ett defensivt sätt.

Paketet är licensierat under MIT och riktar sig mot Rust-edition 2021. Nästan varje operation som kan misslyckas returnerar Result<_, CellsError>, så felhantering med ?-operatorn körs genom exemplen nedan på samma sätt som i riktig kod. Paketet drar in en liten uppsättning runtime-beroenden i stället för att implementera allt från grunden — chrono för datum-tid-värden, zip för XLSX-paketformatet, roxmltree för XML-parsing, serde_json för strukturerad data, sha2 och base64 för hashning och kodning, samt getrandom för slumpmässighet.

Varje avsnitt nedan täcker ett område av API med de konkreta typerna och metoderna som är inblandade, understödda av fungerande Rust-exempel hämtade från paketets egna exempelkod.

Viktiga funktioner

Grundläggande om Workbook och Worksheet

En Workbook startar tom med Workbook::new(), med ett arbetsblad namngivet "Sheet1". Ytterligare blad skapas via WorksheetsMut::add(name), som returnerar det nya bladets index. Worksheets/WorksheetsMut spårar också vilket blad som är aktivt via active_sheet_name() och set_active_sheet_name().

let mut workbook = Workbook::new();
{
    let mut worksheets = workbook.get_worksheets_mut();
    let sheet = worksheets.get(0)?;
    sheet.set_name("Summary")?;

    let detail_index = worksheets.add("Detail")?;
    let detail = worksheets.get(detail_index)?;
    detail.get_cells_mut().get("A1")?.put_value_string("Detail data")?;

    worksheets.set_active_sheet_name("Detail")?;
}

let sheets = workbook.get_worksheets();
println!("Worksheet count: {}", sheets.count());
println!("Active sheet: {}", sheets.active_sheet_name());

Typade cellvärden och formler

Cells/CellsMut adresserar en cell med A1-stilreferens (get("B3")) eller med rad-/kolumn-index (get_by_index(row, column)). Varje Cell/CellMut accepterar typade värden via dedikerade set-metoder, så inga sträng-baserade konverteringar behövs, och formler skrivs tillsammans med ett cachat värde så filen öppnas med korrekta resultat innan någon omberäkning.

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("typed-values.xlsx")?;

let loaded = Workbook::load_xlsx("typed-values.xlsx")?;
let sheet = loaded.worksheet("Sheet1")?;
let cells = sheet.get_cells();
println!(
    "{:?}: {}",
    cells.get("B1")?.value_type(),
    cells.get("B1")?.display_string_value()
);
println!("G1 cached value -> {}", cells.get("G1")?.display_string_value());

Dokumentegenskaper

Workbook::get_document_properties_mut() når ett DocumentProperties-objekt som täcker de vanliga metadatafälten (title, subject, author, keywords, category, company), samt ett nästlat CoreDocumentProperties (get_core_mut()) och ExtendedDocumentProperties (get_extended_mut()) för OOXML-core/-utökade egendomsuppsättningar.

{
    let properties = workbook.get_document_properties_mut();
    properties.set_title("Annual Sales Report 2024");
    properties.set_subject("Financial Performance Analysis");
    properties.set_author("Finance Department");
    properties.set_keywords("sales, finance, 2024, report");
    properties.set_category("Financial Reports");
    properties.set_company("Acme Corporation");

    let core = properties.get_core_mut();
    core.set_creator("Finance Department");
    core.set_created(Some(Utc::now()));

    let extended = properties.get_extended_mut();
    extended.set_company("Acme Corporation");
}
workbook.save("with-properties.xlsx")?;

let loaded = Workbook::load_xlsx("with-properties.xlsx")?;
let properties = loaded.get_document_properties();
println!("Title: {}", properties.get_title());
println!("Core creator: {}", properties.get_core().get_creator());

Skydd och synlighet för arbetsblad

Ett Worksheet kan döljas med set_visibility_type(VisibilityType::Hidden), färgas med set_tab_color och låses med protect() samt ett WorksheetProtection-objekt (via get_protection_mut()) som exakt styr vilka åtgärder — formatera celler, markera låsta celler osv. — som förblir tillgängliga när skyddet är aktiverat.

let mut workbook = Workbook::new();
{
    let mut worksheets = workbook.get_worksheets_mut();
    let layout = worksheets.get(0)?;
    layout.set_name("Layout")?;
    layout.set_visibility_type(VisibilityType::Hidden);
    layout.set_tab_color(Color::from_argb(255, 34, 68, 102));
    layout.set_show_gridlines(false);
    layout.set_right_to_left(true);
    layout.set_zoom(85)?;
    layout.protect();

    let protection = layout.get_protection_mut();
    protection.set_objects(true);
    protection.set_format_cells(true);
    protection.set_select_locked_cells(true);
}
workbook.save("protected.xlsx")?;

let loaded = Workbook::load_xlsx("protected.xlsx")?;
let sheet = loaded.worksheet("Layout")?;
println!("Visibility: {:?}", sheet.get_visibility_type());
println!("Protected: {}", sheet.is_protected());

Rader, kolumner och sammanslagna celler

CellsMut exponerar get_rows()/get_columns() som RowsMut/ColumnsMut för storleksändring och döljning av enskilda rader och kolumner, samt merge(first_row, first_column, total_rows, total_columns) för att kombinera ett cellintervall till en sammanslagen region.

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("Merged")?;
    cells.get("C4")?.put_value_i32(99)?;
    cells.get_rows().get(1).set_height(22.5)?;
    cells.get_rows().get(3).set_is_hidden(true)?;
    cells.get_columns().get(0).set_width(18.25)?;
    cells.get_columns().get(2).set_is_hidden(true)?;

    let mut cells = sheet.get_cells_mut();
    cells.merge(0, 0, 2, 2)?;
}
workbook.save("rows-columns.xlsx")?;

let loaded = Workbook::load_xlsx("rows-columns.xlsx")?;
let sheet = loaded.worksheet("Sheet1")?;
println!(
    "Row 2 height: {}",
    sheet.get_rows().get(1).get_height().unwrap_or_default()
);
println!(
    "Column A width: {}",
    sheet.get_columns().get(0).get_width().unwrap_or_default()
);
println!("Merged regions: {}", sheet.get_cells().get_merged_cells().len());

Defensiv inläsning med diagnostik

XLSX-filer i verkligheten är inte alltid välformade. LoadOptions exponerar reparationsflaggor (try_repair_package, try_repair_xml), och Workbook::get_load_diagnostics() returnerar ett LoadDiagnostics-objekt vars issues() rapporterar vad inläsaren hittade och reparerade.

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

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

println!(
    "Loaded workbook with {} worksheet(s) and {} diagnostic issue(s).",
    loaded.get_worksheets().count(),
    loaded.get_load_diagnostics().issues().len()
);
println!("First item: {}", cells.get("A2")?.display_string_value());

Snabbstart

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

En minimal session som berör arbetsbok, arbetsblad, cell och grundläggande dokumentegenskaper:

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

fn main() -> Result<(), Box<dyn Error>> {
    let mut workbook = Workbook::new();
    {
        let mut worksheets = workbook.get_worksheets_mut();
        let sheet = worksheets.get(0)?;
        sheet.set_name("Report")?;

        let mut cells = sheet.get_cells_mut();
        cells.get("A1")?.put_value_string("Item")?;
        cells.get("B1")?.put_value_string("Quantity")?;
        cells.get("A2")?.put_value_string("Widgets")?;
        cells.get("B2")?.put_value_i32(12)?;
        cells.get("B3")?
            .put_formula_with_cached_value("=SUM(B2:B2)", CellValue::Number(12.0))?;
    }

    workbook.get_document_properties_mut().set_title("Quick Start Report");
    workbook.save("report.xlsx")?;

    let loaded = Workbook::load_xlsx("report.xlsx")?;
    let sheet = loaded.worksheet("Report")?;
    let cells = sheet.get_cells();
    println!("Title: {}", loaded.get_document_properties().get_title());
    println!("Total formula -> {}", cells.get("B3")?.display_string_value());

    Ok(())
}

Stödda format

FormatFiländelseLäsSkriv
XLSX.xlsx✓✓

XLSX är huvudfokus för den nuvarande versionen: fullständig rundresa för läsning och skrivning via Workbook::load_xlsx och Workbook::save, med LoadFormat och SaveFormat enumar som styr explicit formatval.

Öppen källkod och licensiering

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

Komma igång

Relaterade resurser