Wprowadzenie

Aspose.Cells FOSS dla Rust wprowadza rodzinę Aspose.Cells FOSS do ekosystemu Rust. Biblioteka aspose-cells-foss-rust pozwala aplikacjom Rust tworzyć skoroszyty Excel XLSX od podstaw, ładować istniejące pliki, modyfikować ich zawartość i zapisywać wynik — bez instalacji Microsoft Office, automatyzacji COM ani zewnętrznego środowiska uruchomieniowego.

Biblioteka jest licencjonowana na licencji MIT i skierowana jest do edycji Rust 2021. Spełnia konwencje, których oczekują programiści Rust: konstruktory takie jak Workbook::new, obsługa błędów oparta na Result poprzez CellsError oraz explicite mutowalne akcesory, takie jak get_worksheets_mut i get_cells_mut, które utrzymują zasady pożyczania w jasności. Jeśli tworzysz usługi backendowe, narzędzia CLI lub potoki danych, które muszą generować lub odczytywać arkusze kalkulacyjne, ta biblioteka zapewnia natywny sposób realizacji.

Ta sekcja została przeglądnięta w odniesieniu do bieżącego modelu źródłowego pod kątem najnowszego zachowania produktu oraz pokrycia API.

Aspose.Cells FOSS jest już dostępny dla .NET, C++, Java, Python oraz TypeScript; pakiet Rust dołącza do rodziny z tym samym założeniem: rzetelne, weryfikowalne wsparcie XLSX pod licencją permissive.

Co zawiera

Skoroszyty, Arkusze i Typowane Wartości Komórek

Workbook zaczyna się od jednego arkusza i rozwija się za pomocą add_worksheet. Komórki akceptują wartości typowane — ciągi znaków, liczby całkowite, wartości logiczne, liczby dziesiętne i daty-czasy — poprzez dedykowane settery, więc nie są potrzebne konwersje typu stringly-typed:

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

Formuły z buforowanymi wynikami

Formuły są zapisywane razem z buforowaną wartością, więc zapisany plik otwiera się w Excelu z prawidłowymi wynikami od razu — nie jest wymagana ponowna kalkulacja:

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

Wykresy zakotwione w zakresach danych

Typy wykresów kolumnowych, liniowych i inne z wyliczenia ChartType można zakotwiczyć w zakresach komórek na arkuszu, a geometria wykresu może być odczytana z załadowanych plików:

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

Stylizacja, ustawienia strony i struktura

Formatowanie komórek odbywa się za pośrednictwem CellStyle wraz z Font, Fill i Borders, stosowane selektywnie przy użyciu StyleFlag. PageSetup kontroluje rozmiar papieru i orientację przy drukowaniu, FreezePane utrzymuje widoczne wiersze nagłówka, a tabele strukturalne pojawiają się poprzez ListObject z TableStyleType.

Walidacja, formatowanie warunkowe i filtry

Funkcje zapewniające jakość danych są częścią rdzenia: reguły Validation z OperatorType, formatowanie warunkowe przez FormatCondition, automatyczne filtry za pomocą AutoFilter, zdefiniowane nazwy poprzez DefinedName oraz ochronę skoroszytu lub arkusza poprzez WorkbookProtection i WorksheetProtection.

Ładowanie defensywne z diagnostyką

Rzeczywiste pliki XLSX nie zawsze są poprawnie sformatowane. LoadOptions udostępnia flagi naprawy, a LoadDiagnostics raportuje, co napotkał loader:

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

Szybki start

Dodaj bibliotekę do swojego Cargo.toml jako zależność git (biblioteka nie została jeszcze opublikowana na crates.io):

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

Następnie utwórz, zapisz i ponownie wczytaj swój pierwszy skoroszyt:

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

Obsługiwane formaty

FormatRozszerzenieOdczytZapis
XLSX.xlsx✓✓

XLSX jest głównym tematem bieżącego wydania: pełny cykl odczytu i zapisu za pomocą Workbook::load_xlsx i Workbook::save, przy użyciu wyliczeń LoadFormat i SaveFormat sterujących jawnym wyborem formatu.

Open Source i licencjonowanie

Aspose.Cells FOSS dla Rust jest licencjonowane na licencji MIT. Pełny kod źródłowy jest dostępny na GitHub, a licencja zezwala na komercyjne użycie, modyfikację i redystrybucję.

Rozpoczęcie

Powiązane zasoby