Introducere

Aspose.Cells FOSS pentru Rust aduce familia Aspose.Cells FOSS în ecosistemul Rust. Cratea aspose-cells-foss-rust permite aplicațiilor Rust să creeze registre de lucru Excel XLSX de la zero, să încarce fișiere existente, să le modifice conținutul și să salveze rezultatul — fără instalarea Microsoft Office, automatizare COM sau runtime extern.

Cratea este licențiată sub MIT și vizează ediția Rust 2021. Urmează convențiile pe care dezvoltatorii Rust le așteaptă: constructori precum Workbook::new, gestionarea erorilor bazată pe Result prin CellsError și accesori explici mutabili precum get_worksheets_mut și get_cells_mut care păstrează regulile de împrumut clare. Dacă dezvolti servicii backend, instrumente CLI sau fluxuri de date care trebuie să producă sau să consume foi de calcul, această bibliotecă îți oferă o modalitate nativă de a face asta.

Această secțiune a fost revizuită în raport cu modelul sursă actual pentru comportamentul cel mai recent al produsului și acoperirea API.

Aspose.Cells FOSS este deja disponibil pentru .NET, C++, Java, Python și TypeScript; crate-ul Rust se alătură familiei cu același accent: suport XLSX onest, verificabil, sub o licență permisivă.

Ce este inclus

Registri de lucru, foi de calcul și valori de celule tipizate

Un Workbook începe cu un singur worksheet și se extinde prin add_worksheet. Celulele acceptă valori tipizate — șiruri, întregi, booleene, zecimale și date-oră — prin setări dedicate, astfel încât nu sunt necesare conversii de tip stringly:

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 cu rezultate în cache

Formulele sunt scrise împreună cu o valoare în cache, astfel încât fișierul salvat se deschide în Excel cu rezultatele corecte imediat — nu este necesară o trecere de recalculare:

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

Grafice ancorate la intervale de date

Tipurile de diagramă coloană, linie și altele din enumul ChartType pot fi ancorate la intervale de celule pe un worksheet, iar geometria diagramelor poate fi citită din fișierele încărcate:

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

Stilizare, configurare pagină și structură

Formatarea celulelor trece prin CellStyle cu Font, Fill și Borders, aplicată selectiv cu StyleFlag. PageSetup controlează dimensiunea hârtiei și orientarea pentru tipărire, FreezePane menține vizibile rândurile de antet, iar tabelele structurate apar prin ListObject cu TableStyleType.

Validare, formatare condițională și filtre

Funcționalitățile de calitate a datelor fac parte din suprafața de bază: regulile Validation cu OperatorType, formatarea condiționată prin FormatCondition, filtrele automate prin AutoFilter, numele definite prin DefinedName și protecția registrului de lucru sau a foii de calcul prin WorkbookProtection și WorksheetProtection.

Încărcare defensivă cu diagnosticare

Fișierele XLSX din viața reală nu sunt întotdeauna bine formate. LoadOptions expune indicatorii de reparare, iar LoadDiagnostics raportează ce a întâlnit încărcătorul:

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

Start rapid

Adaugă pachetul în Cargo.toml ca o dependență git (pachetul nu este încă publicat pe crates.io):

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

Apoi creează, salvează și reîncarcă primul tău 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(())
}

Formate suportate

FormatExtensieCitireScriere
XLSX.xlsx✓✓

XLSX este punctul central al versiunii curente: citire și scriere completă în buclă prin Workbook::load_xlsx și Workbook::save, cu enum-urile LoadFormat și SaveFormat care guvernează selecția explicită a formatului.

Open Source & Licențiere

Aspose.Cells FOSS pentru Rust este licențiat sub MIT. Codul sursă complet este disponibil pe GitHub, iar licența permite utilizarea comercială, modificarea și redistribuirea.

Începere

Resurse conexe