Introducción

Aspose.Cells FOSS para Rust aporta la familia Aspose.Cells FOSS al ecosistema de Rust. El crate aspose-cells-foss-rust permite a las aplicaciones Rust crear libros de trabajo Excel XLSX desde cero, cargar archivos existentes, modificar su contenido y guardar el resultado — sin necesidad de instalar Microsoft Office, automatización COM ni tiempo de ejecución externo.

El crate tiene licencia MIT y está dirigido a la edición 2021 de Rust. Sigue las convenciones que los desarrolladores de Rust esperan: constructores como Workbook::new, manejo de errores basado en Result mediante CellsError, y accesores mutables explícitos como get_worksheets_mut y get_cells_mut que mantienen claras las reglas de préstamo. Si construyes servicios backend, herramientas CLI o pipelines de datos que necesiten generar o consumir hojas de cálculo, esta biblioteca te brinda una forma nativa de hacerlo.

Esta sección se ha revisado en base al modelo de origen actual para el comportamiento más reciente del producto y la cobertura de API.

Aspose.Cells FOSS ya está disponible para .NET, C++, Java, Python y TypeScript; el crate Rust se une a la familia con el mismo enfoque: soporte XLSX honesto y verificable bajo una licencia permisiva.

Qué incluye

Libros de trabajo, hojas de cálculo y valores de celda tipados

Un Workbook comienza con una hoja de cálculo y crece mediante add_worksheet. Las celdas aceptan valores tipados — cadenas, enteros, booleanos, decimales y fechas-horas — mediante setters dedicados, por lo que no se requieren conversiones basadas en cadenas:

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 con resultados en caché

Las fórmulas se guardan junto con un valor en caché, de modo que el archivo guardado se abre en Excel con los resultados correctos de inmediato — no se necesita una pasada 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 anclados a rangos de datos

Los tipos de gráfico de columna, línea y otros del enumerado ChartType pueden anclarse a rangos de celdas en una hoja, y la geometría del gráfico puede leerse de los archivos cargados:

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

Estilos, configuración de página y estructura

El formato de celdas se gestiona mediante CellStyle con Font, Fill y Borders, aplicados de forma selectiva con StyleFlag. PageSetup controla el tamaño y la orientación del papel para la impresión, FreezePane mantiene visibles las filas de encabezado, y las tablas estructuradas aparecen a través de ListObject con TableStyleType.

Validación, formato condicional y filtros

Las funciones de calidad de datos forman parte de la superficie central: reglas de Validation con OperatorType, formato condicional mediante FormatCondition, autofiltros vía AutoFilter, nombres definidos mediante DefinedName, y protección de libros o hojas mediante WorkbookProtection y WorksheetProtection.

Carga defensiva con diagnósticos

Los archivos XLSX del mundo real no siempre están bien formados. LoadOptions expone banderas de reparación, y LoadDiagnostics informa lo que encontró el cargador:

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

Inicio rápido

Agrega la crate a tu Cargo.toml como una dependencia git (la crate aún no está publicada en crates.io):

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

Luego crea, guarda y vuelve a cargar tu primer libro de trabajo:

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 compatibles

FormatoExtensiónLeerEscribir
XLSX.xlsx✓✓

XLSX es el foco de la versión actual: lectura y escritura de ida y vuelta completas mediante Workbook::load_xlsx y Workbook::save, con los enums LoadFormat y SaveFormat que controlan la selección explícita del formato.

Código abierto y Licencias

Aspose.Cells FOSS para Rust tiene licencia MIT. El código fuente completo está disponible en GitHub, y la licencia permite el uso comercial, la modificación y la redistribución.

Primeros pasos

Recursos relacionados