Inleiding
Aspose.Cells FOSS voor Rust maakt zijn functionaliteit beschikbaar via de aspose-cells-foss-rust crate, gecentreerd rond een compacte set kerntypen: Workbook, Worksheet, Cells, Cell en DocumentProperties, elk met bijbehorende *Mut accessors voor schrijftoegang. Dit bericht is een systematische rondleiding door die kern-API-interface — niet één smal kenmerk, maar de fundamenten die elke applicatie die op de crate is gebouwd uiteindelijk gebruikt: werkbladen maken en benoemen, getypeerde celwaarden lezen en schrijven, documentmetadata instellen, werkbladen beveiligen en verbergen, rijen en kolommen dimensioneren, cellen samenvoegen en bestanden defensief laden.
De crate heeft een MIT-licentie en richt zich op Rust-edition 2021. Bijna elke mislukbare bewerking retourneert Result<_, CellsError>, zodat foutafhandeling met de ?-operator door de onderstaande voorbeelden loopt op dezelfde manier als in echte code. De crate haalt een kleine set runtime-afhankelijkheden binnen in plaats van alles vanaf nul te implementeren — chrono voor datum-tijdwaarden, zip voor het XLSX-pakketformaat, roxmltree voor XML-parsing, serde_json voor gestructureerde data, sha2 en base64 voor hashing en codering, en getrandom voor willekeurigheid.
Elke sectie hieronder behandelt één gebied van de API met de concrete typen en methoden die erbij horen, ondersteund door werkende Rust-voorbeelden gehaald uit de eigen voorbeeldcode van de crate.
Belangrijkste functies
Basisprincipes van Workbook en Worksheet
Een Workbook begint leeg met Workbook::new(), met één werkblad genaamd "Sheet1". Extra bladen komen van WorksheetsMut::add(name), die de index van het nieuwe blad retourneert. Worksheets/WorksheetsMut houden ook bij welk blad actief is via active_sheet_name() en 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());
Getypte celwaarden en formules
Cells/CellsMut adresseren een cel via A1-stijl referentie (get("B3")) of via rij/kolom index (get_by_index(row, column)). Elke Cell/CellMut accepteert getypte waarden via toegewijde setters, zodat er geen stringly-typed conversies nodig zijn, en formules worden geschreven samen met een gecachte waarde zodat het bestand opent met correcte resultaten vóór enige herberekening.
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());
Documenteigenschappen
Workbook::get_document_properties_mut() bereikt een DocumentProperties object dat de veelvoorkomende metagegevensvelden (titel, onderwerp, auteur, trefwoorden, categorie, bedrijf) omvat, plus een geneste CoreDocumentProperties (get_core_mut()) en ExtendedDocumentProperties (get_extended_mut()) voor OOXML core/extended eigenschapsets.
{
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());
Werkbladbeveiliging en zichtbaarheid
Een Worksheet kan worden verborgen met set_visibility_type(VisibilityType::Hidden), gekleurd met set_tab_color, en vergrendeld met protect() plus een WorksheetProtection object (via get_protection_mut()) dat exact regelt welke acties — cellen opmaken, vergrendelde cellen selecteren, enzovoort — beschikbaar blijven zodra de bescherming is ingeschakeld.
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());
Rijen, kolommen en samengevoegde cellen
CellsMut exposeert get_rows()/get_columns() als RowsMut/ColumnsMut voor het aanpassen van de grootte en het verbergen van individuele rijen en kolommen, en merge(first_row, first_column, total_rows, total_columns) om een bereik van cellen te combineren tot één samengevoegd gebied.
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());
Defensief laden met diagnostiek
XLSX-bestanden uit de praktijk zijn niet altijd goed gevormd. LoadOptions legt reparatie-vlaggen bloot (try_repair_package, try_repair_xml), en Workbook::get_load_diagnostics() retourneert een LoadDiagnostics object waarvan de issues() rapporteert wat de loader heeft gevonden en gerepareerd.
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());
Snelstart
# Cargo.toml
[dependencies]
aspose-cells-foss-rust = { git = "https://github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Rust" }Een minimale sessie die de basis van werkmap, werkblad, cel en document-eigenschap behandelt:
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(())
}
Ondersteunde formaten
| Formaat | Extensie | Lezen | Schrijven |
|---|---|---|---|
| XLSX | .xlsx | ✓ | ✓ |
XLSX staat centraal in de huidige release: volledige round-trip lezen en schrijven via Workbook::load_xlsx en Workbook::save, met LoadFormat en SaveFormat enum’s die expliciete formatselectie beheren.
Open source & licensering
Aspose.Cells FOSS voor Rust is onder de MIT-licentie. De volledige broncode is beschikbaar op GitHub, en de licentie staat commercieel gebruik, wijziging en herdistributie toe.
