Introduzione

La gestione dei fogli di calcolo è il nucleo del crate aspose-cells-foss-rust: gli oggetti che modellano una cartella di lavoro, i suoi fogli e le loro celle, e le operazioni che trasformano i dati Rust in file XLSX presentabili. Questo post esplora quella superficie — dalla creazione dei fogli e scrittura di valori tipizzati allo styling, layout di pagina e le funzionalità strutturali che rendono le cartelle di lavoro utilizzabili: commenti, collegamenti ipertestuali, tabelle e nomi definiti.

Tutto ciò che è mostrato qui fa parte del crate open-source con licenza MIT. Nessuna installazione di Microsoft Office è coinvolta in alcun momento; la libreria legge e scrive direttamente il formato del pacchetto XLSX.

Questa sezione è stata revisionata rispetto al modello sorgente attuale per il comportamento più recente del prodotto e la copertura di API.

Caratteristiche principali

Foglio di lavoro e collezioni di celle

I fogli di lavoro sono gestiti tramite le collezioni di fogli di lavoro della cartella. I fogli sono indicizzati per indice o nome, rinominati con set_name, e le loro celle sono accessibili tramite get_cells (lettura) o get_cells_mut (scrittura):

let mut workbook = Workbook::new();
{
    let mut worksheets = workbook.get_worksheets_mut();
    let sheet = worksheets.get(0)?;
    sheet.set_name("Charts")?;
    {
        let mut cells = sheet.get_cells_mut();
        cells.get("A1")?.put_value_string("Month")?;
        cells.get("B1")?.put_value_string("Sales")?;
    }
}

Valori tipizzati per nome o indice

Le celle accettano stringhe, interi, booleani, decimali e date/ora tramite setter tipizzati. Le celle possono essere indirizzate in stile A1 (get("B3")) o numericamente (get_by_index(row, column)), il che si adatta a layout generati:

for month in 1..=12_u32 {
    cells
        .get_by_index(month, 0)
        .put_value_string(format!("Month {month}"))?;
    cells
        .get_by_index(month, 1)
        .put_value_i32((month as i32 * 1000) + (month as i32 * 50))?;
}

Formule con valori memorizzati nella cache

put_formula_with_cached_value memorizza il testo della formula insieme al valore che Excel dovrebbe visualizzare prima della prima ricalcolazione — importante quando il file è consumato da altri strumenti che leggono i risultati memorizzati:

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

Stile e layout di pagina

CellStyle contiene Font, Fill e Borders; StyleFlag seleziona quali aspetti dello stile vengono aggiornati. NumberFormat controlla il rendering del valore, e PageSetup gestisce PaperSizeType e PageOrientationType per la stampa. FreezePane e il VisibilityType di righe/colonne mantengono navigabili i fogli di grandi dimensioni.

Commenti, collegamenti ipertestuali e nomi

I flussi di lavoro e la navigazione del revisore sono gestiti da Comment e CommentCollection, Hyperlink con HyperlinkCollection, e DefinedName con DefinedNameCollection per gli intervalli denominati.

Tabelle strutturate e filtri

ListObject trasforma un intervallo in una tabella strutturata con lo stile TableStyleType e righe TotalsCalculation; AutoFilter aggiunge il filtraggio con condizioni FilterColumn e FilterOperatorType.

Avvio rapido

Aggiungi il crate al tuo Cargo.toml come dipendenza git (il crate non è ancora pubblicato su crates.io):

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

Una sessione minima di gestione di fogli di calcolo — crea, scrivi, salva, ricarica:

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)?;
        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("Apples")?;
        cells.get("B2")?.put_value_i32(12)?;
    }
    workbook.save("inventory.xlsx")?;

    let loaded = Workbook::load_xlsx("inventory.xlsx")?;
    let sheet = loaded.worksheet("Sheet1")?;
    let cells = sheet.get_cells();
    println!("A2 = {}", cells.get("A2")?.display_string_value());

    Ok(())
}

Formati supportati

FormatoEstensioneLeggiScrivi
XLSX.xlsx✓✓

Il caricamento accetta i flag di riparazione LoadOptions (try_repair_package, try_repair_xml) con LoadDiagnostics strutturato; il salvataggio avviene tramite save, save_xlsx o save_with_format con l’enumerazione SaveFormat.

Open Source e Licenze

Aspose.Cells FOSS per Rust è con licenza MIT. Il codice sorgente è ospitato su GitHub; l’uso commerciale, la modifica e la ridistribuzione sono consentiti.

Guida introduttiva

Risorse correlate