Introduzione

Aspose.Cells FOSS per Rust porta la famiglia Aspose.Cells FOSS nell’ecosistema Rust. Il crate aspose-cells-foss-rust consente alle applicazioni Rust di creare cartelle di lavoro Excel XLSX da zero, caricare file esistenti, modificarne il contenuto e salvare il risultato — senza l’installazione di Microsoft Office, automazione COM o runtime esterno.

Il crate è con licenza MIT e mira all’edizione Rust 2021. Segue le convenzioni che gli sviluppatori Rust si aspettano: costruttori come Workbook::new, gestione degli errori basata su Result tramite CellsError, e accessor mutabili espliciti come get_worksheets_mut e get_cells_mut che mantengono chiare le regole di borrowing. Se costruisci servizi backend, strumenti CLI o pipeline di dati che devono produrre o consumare fogli di calcolo, questa libreria ti offre un modo nativo per farlo.

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

Aspose.Cells FOSS è già disponibile per .NET, C++, Java, Python e TypeScript; il crate Rust si unisce alla famiglia con lo stesso focus: supporto XLSX onesto e verificabile sotto una licenza permissiva.

Cosa è incluso

Cartelle di lavoro, fogli di lavoro e valori di cella tipizzati

Un Workbook inizia con un foglio di lavoro e cresce tramite add_worksheet. Le celle accettano valori tipizzati — stringhe, interi, booleani, decimali e data/ora — tramite setter dedicati, quindi non sono necessarie conversioni basate su stringhe:

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

Formule con risultati memorizzati

Le formule vengono scritte insieme a un valore memorizzato, così il file salvato si apre in Excel con i risultati corretti immediatamente — non è necessario un passaggio di ricalcolo:

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

Grafici ancorati a intervalli di dati

I tipi di grafico colonna, linea e altri presenti nell’enum ChartType possono essere ancorati a intervalli di celle su un foglio di lavoro, e la geometria del grafico può essere letta nuovamente dai file caricati:

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

Stile, Impostazione pagina e Struttura

La formattazione delle celle avviene tramite CellStyle con Font, Fill e Borders, applicata selettivamente con StyleFlag. PageSetup controlla le dimensioni della carta e l’orientamento per la stampa, FreezePane mantiene visibili le righe di intestazione, e le tabelle strutturate sono disponibili tramite ListObject con TableStyleType.

Convalida, Formattazione condizionale e Filtri

Le funzionalità di qualità dei dati fanno parte della superficie principale: regole Validation con OperatorType, formattazione condizionale tramite FormatCondition, auto-filtri tramite AutoFilter, nomi definiti tramite DefinedName, e protezione del workbook o del foglio di lavoro tramite WorkbookProtection e WorksheetProtection.

Caricamento difensivo con diagnostica

I file XLSX reali non sono sempre ben formati. LoadOptions espone flag di riparazione, e LoadDiagnostics riporta ciò che il caricatore ha incontrato:

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

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" }

Quindi crea, salva e ricarica il tuo primo workbook:

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

Formati supportati

FormatoEstensioneLeggiScrivi
XLSX.xlsx✓✓

XLSX è il focus della versione attuale: lettura e scrittura a ciclo completo tramite Workbook::load_xlsx e Workbook::save, con gli enum LoadFormat e SaveFormat che governano la selezione esplicita del formato.

Open Source & Licenze

Aspose.Cells FOSS per Rust è con licenza MIT. Il codice sorgente completo è disponibile su GitHub, e la licenza consente l’uso commerciale, la modifica e la redistribuzione.

Guida introduttiva

Risorse correlate