Introdução

Aspose.Cells FOSS para Rust traz a família Aspose.Cells FOSS para o ecossistema Rust. O crate aspose-cells-foss-rust permite que aplicações Rust criem livros de trabalho Excel XLSX do zero, carreguem arquivos existentes, modifiquem seu conteúdo e salvem o resultado — sem necessidade de instalação do Microsoft Office, automação COM ou runtime externo envolvido.

O crate tem licença MIT e tem como alvo a edição 2021 do Rust. Ele segue as convenções que os desenvolvedores Rust esperam: construtores como Workbook::new, tratamento de erros baseado em Result através de CellsError, e acessores mutáveis explícitos como get_worksheets_mut e get_cells_mut que mantêm as regras de empréstimo claras. Se você desenvolve serviços backend, ferramentas CLI ou pipelines de dados que precisam produzir ou consumir planilhas, esta biblioteca oferece uma maneira nativa de fazê-lo.

Esta seção foi revisada em relação ao modelo de origem atual para o comportamento mais recente do produto e cobertura de API.

Aspose.Cells FOSS já está disponível para .NET, C++, Java, Python e TypeScript; o crate Rust se une à família com o mesmo foco: suporte XLSX honesto e verificável sob uma licença permissiva.

O que está incluído

Pastas de trabalho, planilhas e valores de célula tipados

Um Workbook começa com uma planilha e cresce via add_worksheet. As células aceitam valores tipados — strings, inteiros, booleanos, decimais e date-times — através de setters dedicados, portanto nenhuma conversão baseada em strings é necessária:

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

Fórmulas com Resultados em Cache

As fórmulas são gravadas juntamente com um valor em cache, de modo que o arquivo salvo abre no Excel com resultados corretos imediatamente — não é necessária uma passagem de recálculo:

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

Gráficos Ancorados a Intervalos de Dados

Tipos de gráfico coluna, linha e outros do enum ChartType podem ser ancorados a intervalos de células em uma planilha, e a geometria do gráfico pode ser lida de volta a partir de arquivos carregados:

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

Estilização, Configuração de Página e Estrutura

A formatação de células flui através de CellStyle com Font, Fill e Borders, aplicada seletivamente com StyleFlag. PageSetup controla o tamanho e a orientação do papel para impressão, FreezePane mantém as linhas de cabeçalho visíveis, e tabelas estruturadas são fornecidas via ListObject com TableStyleType.

Validação, Formatação Condicional e Filtros

Recursos de qualidade de dados fazem parte da superfície central: regras de Validation com OperatorType, formatação condicional via FormatCondition, auto-filtros através de AutoFilter, nomes definidos via DefinedName e proteção de livro ou planilha através de WorkbookProtection e WorksheetProtection.

Carregamento Defensivo com Diagnósticos

Arquivos XLSX do mundo real nem sempre são bem formados. LoadOptions expõe flags de reparo, e LoadDiagnostics relata o que o carregador encontrou:

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

Início Rápido

Adicione a crate ao seu Cargo.toml como uma dependência git (a crate ainda não foi publicada no crates.io):

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

Em seguida, crie, salve e recarregue sua primeira pasta de trabalho:

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

Formatos Suportados

FormatoExtensãoLeituraGravação
XLSX.xlsx✓✓

XLSX é o foco da versão atual: leitura e gravação completas em round-trip via Workbook::load_xlsx e Workbook::save, com os enums LoadFormat e SaveFormat controlando a seleção explícita de formato.

Código Aberto & Licenciamento

Aspose.Cells FOSS para Rust tem licença MIT. O código-fonte completo está disponível em GitHub, e a licença permite uso comercial, modificação e redistribuição.

Começando

Recursos Relacionados