1. Produtos
  2.   Aspose.Cells
  3.   Aspose.Cells FOSS for Rust

Aspose.Cells FOSS para Rust

Crate Rust de código aberto para criar, ler, editar e salvar planilhas Excel XLSX sem dependências do Office.

Aspose.Cells FOSS — Biblioteca Rust de Código Aberto

Aspose.Cells FOSS for Rust é uma biblioteca de código aberto para trabalhar com planilhas Excel XLSX em aplicações Rust. Ela oferece aos programadores de sistemas uma forma nativa e segura em memória de criar pastas de trabalho do zero, carregar arquivos XLSX existentes, modificar seu conteúdo e salvar o resultado — sem Microsoft Office, automação COM ou qualquer runtime externo.

A crate modela a árvore completa de objetos da planilha: Workbook, Worksheet e coleções de células com definidores de valor tipados (put_value_string, put_value_i32, put_value_bool, put_value_decimal), fórmulas com valores em cache via put_formula_with_cached_value, gráficos (Chart, ChartType), formatação condicional (FormatCondition), validação de dados (Validation), auto-filtros (AutoFilter), estilo de célula (CellStyle, Font, Fill, Borders), configuração de página (PageSetup), imagens, formas, comentários, hyperlinks, tabelas (ListObject), sparklines (SparklineGroup), nomes definidos e proteção de pasta de trabalho/planilha.

Aspose.Cells FOSS for Rust tem licença MIT e tem como alvo a edição 2021 do Rust. Ela é instalada como uma dependência padrão do Cargo a partir do repositório GitHub — veja o guia de instalação para a entrada exata em Cargo.toml. Erros são expostos através dos tipos convencionais Result (CellsError), e o carregamento de XLSX oferece opções de reparo (LoadOptions) com diagnósticos estruturados (LoadDiagnostics). Para a família de produtos empresariais, veja Aspose.Cells — Enterprise Product Family.

Gerenciamento de Pasta de Trabalho e Planilha

  • Crie pastas de trabalho vazias com Workbook::new ou carregue arquivos existentes com Workbook::load_xlsx
  • Adicione e acesse planilhas via add_worksheet, worksheet e coleções mutáveis de planilhas
  • Salve no disco com save, save_xlsx ou save_with_format com formato explícito
  • Controle as visualizações da pasta de trabalho, configurações e propriedades do documento

Onde se encaixa

  • Serviços de backend que geram relatórios XLSX sem Office instalado
  • Ferramentas CLI que produzem em lote ou pós-processam planilhas
  • Pipelines de dados Rust que exportam resultados tabulares para usuários de negócios

Dados da Célula, Fórmulas e Tipos

  • Definidores tipados: put_value_string, put_value_i32, put_value_bool, put_value_decimal, put_value_date_time
  • Escreva fórmulas com resultados em cache via put_formula_with_cached_value
  • Recupere os valores com display_string_value e value_type
  • Enderece células pelo nome A1 ou índice de linha/coluna (get, get_by_index)

Usos Práticos

  • Exportações financeiras onde as fórmulas devem abrir com valores em cache corretos
  • Modelos de entrada de dados com colunas tipadas
  • Edição de ida e volta de pastas de trabalho fornecidas pelo usuário

Estilo e Layout

  • Estilização de células através de CellStyle com Font, Fill e Borders
  • Aplicar atualizações de estilo direcionadas com StyleFlag
  • Formatação de números via NumberFormat
  • Impressão e layout de página via PageSetup (tamanho do papel, orientação, margens)
  • Congelar painéis com FreezePane; controlar a visibilidade de linhas/colunas

Por que isso importa

  • Relatórios com marca, prontos para impressão, diretamente dos serviços Rust
  • Exportações legíveis com formatos corretos de número e data
  • Planilhas grandes que permanecem navegáveis com linhas de cabeçalho congeladas

Gráficos, Imagens e Formas

  • Adicionar tipos de gráfico de coluna, linha e outros via ChartType na coleção de gráficos de uma planilha
  • Ler âncoras de gráfico e tipos a partir de arquivos carregados (Chart, ChartCollection)
  • Incorporar imagens com Picture e formas de desenho com Shape
  • Compactar tendências em célula com SparklineGroup

Casos de Uso

  • Painéis e workbooks de KPI gerados em uma programação
  • Resumos visuais incorporados ao lado dos dados brutos
  • Posicionamento automático de gráficos a partir de intervalos de dados

Análise de Dados e Proteção

  • Regras de formatação condicional via FormatCondition
  • Regras de validação de dados via Validation com OperatorType
  • Auto-filtros via AutoFilter; tabelas estruturadas via ListObject
  • Nomes definidos via DefinedName; proteção via WorkbookProtection e WorksheetProtection
  • Carregamento robusto de XLSX com LoadOptions flags de reparo e LoadDiagnostics

Quem se beneficia

  • Equipes enviando livros de trabalho de entrada de dados validados
  • Serviços ingerindo arquivos XLSX de terceiros que podem precisar de reparo
  • Analistas recebendo relatórios pré-filtrados e protegidos

Criar, Salvar e Recarregar uma Pasta de Trabalho

Crie uma pasta de trabalho, escreva valores tipados e uma fórmula com um resultado em cache, salve-a como XLSX e carregue-a novamente:

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("C1")?.put_value_bool(true)?;
        cells.get("D1")?.put_value_decimal(12.5)?;
        cells.get("F1")?.put_value_i32(10)?;
        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(())
}

Carregar arquivos XLSX com opções de reparo

Abra as pastas de trabalho de forma defensiva com as flags de reparo do LoadOptions e inspecione os diagnósticos de carregamento estruturados:

let options = LoadOptions {
    try_repair_package: true,
    try_repair_xml: true,
    ..LoadOptions::default()
};

let loaded = Workbook::load_xlsx_with_options(&valid_path, &options)?;
let sheet = loaded.worksheet("Sheet1")?;
let cells = sheet.get_cells();

println!("Saved: {}", valid_path.display());
println!(
    "Loaded workbook with {} worksheet(s) and {} diagnostic issue(s).",
    loaded.get_worksheets().count(),
    loaded.get_load_diagnostics().issues().len()
);

Adicionar Gráficos a partir de Intervalos de Dados

Preencha um intervalo de dados e, em seguida, ancore os gráficos de coluna e linha a ele:

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

Perguntas Frequentes

Qual licença o Aspose.Cells FOSS for Rust usa?

O crate é distribuído sob a Licença MIT; o texto completo está incluído no repositório como LICENSE.txt.

Posso usá-lo em produtos comerciais?

Sim. A MIT License permite uso comercial, modificação e redistribuição, desde que o aviso de direitos autorais e a licença sejam preservados.

Como instalo o crate?

Adicione aspose-cells-foss-rust ao seu Cargo.toml como uma dependência git do repositório do GitHub.

Quais formatos podem ser lidos e escritos?

XLSX, com leitura e escrita de ida e volta completas via Workbook::load_xlsx e save. Outros formatos de planilha não são suportados na versão atual.

É necessário o Microsoft Office?

Não. A biblioteca lê e grava o formato de pacote XLSX diretamente — não há instalação do Office, automação COM ou runtime externo envolvido.

  

Recursos de Suporte e Aprendizado

 Português