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

Aspose.Cells FOSS para Rust

Crate Rust de código abierto para crear, leer, editar y guardar hojas de cálculo Excel XLSX sin dependencias de Office.

Aspose.Cells FOSS — Biblioteca Rust de código abierto

Aspose.Cells FOSS for Rust es una biblioteca de código abierto para trabajar con hojas de cálculo Excel XLSX en aplicaciones Rust. Proporciona a los programadores de sistemas una forma nativa y segura en memoria de crear libros de trabajo desde cero, cargar archivos XLSX existentes, modificar su contenido y guardar el resultado — sin Microsoft Office, automatización COM, ni ningún tiempo de ejecución externo.

La crate modela el árbol completo de objetos de la hoja de cálculo: Workbook, Worksheet, y colecciones de celdas con establecedores de valores tipados (put_value_string, put_value_i32, put_value_bool, put_value_decimal), fórmulas con valores en caché mediante put_formula_with_cached_value, gráficos (Chart, ChartType), formato condicional (FormatCondition), validación de datos (Validation), auto-filtros (AutoFilter), estilo de celdas (CellStyle, Font, Fill, Borders), configuración de página (PageSetup), imágenes, formas, comentarios, hipervínculos, tablas (ListObject), minigráficos (SparklineGroup), nombres definidos y protección de libros/hojas.

Aspose.Cells FOSS for Rust tiene licencia MIT y está dirigida a la edición 2021 de Rust. Se instala como una dependencia estándar de Cargo desde el repositorio de GitHub — consulte la guía de instalación para la entrada exacta de Cargo.toml. Los errores se exponen mediante los tipos convencionales Result (CellsError), y la carga de XLSX ofrece opciones de reparación (LoadOptions) con diagnósticos estructurados (LoadDiagnostics). Para la familia de productos empresariales, vea Aspose.Cells — Enterprise Product Family.

Gestión de libros de trabajo y hojas de cálculo

  • Crea libros de trabajo vacíos con Workbook::new o carga archivos existentes con Workbook::load_xlsx
  • Agrega y accede a hojas mediante add_worksheet, worksheet y colecciones mutables de hojas de cálculo
  • Guarda en disco con save, save_xlsx o con formato explícito save_with_format
  • Controla las vistas del libro de trabajo, la configuración y las propiedades del documento

Dónde encaja

  • Servicios backend que generan informes XLSX sin Office instalado
  • Herramientas CLI que producen en lote o post-procesan hojas de cálculo
  • Canalizaciones de datos Rust que exportan resultados tabulares para usuarios de negocio

Datos de celdas, fórmulas y tipos

  • Setters tipados: put_value_string, put_value_i32, put_value_bool, put_value_decimal, put_value_date_time
  • Escribe fórmulas con resultados en caché mediante put_formula_with_cached_value
  • Lee los valores de vuelta con display_string_value y value_type
  • Direcciona celdas por nombre A1 o índice de fila/columna (get, get_by_index)

Usos Prácticos

  • Exportaciones financieras donde las fórmulas deben abrirse con los valores almacenados en caché correctos
  • Plantillas de entrada de datos con columnas tipadas
  • Edición de ida y vuelta de libros de trabajo suministrados por el usuario

Estilo y diseño

  • Estilizado de celdas mediante CellStyle con Font, Fill y Borders
  • Aplicar actualizaciones de estilo específicas con StyleFlag
  • Formateo de números mediante NumberFormat
  • Impresión y diseño de página mediante PageSetup (tamaño de papel, orientación, márgenes)
  • Congelar paneles con FreezePane; controlar la visibilidad de filas/columnas

¿Por qué importa?

  • Informes con marca, listos para imprimir directamente desde servicios Rust
  • Exportaciones legibles con formatos correctos de número y fecha
  • Hojas grandes que siguen siendo navegables con filas de encabezado congeladas

Gráficos, Imágenes y Formas

  • Añadir tipos de gráfico de columnas, líneas y otros mediante ChartType en la colección de gráficos de una hoja
  • Leer los anclajes y tipos de gráfico de los archivos cargados (Chart, ChartCollection)
  • Insertar imágenes con Picture y formas de dibujo con Shape
  • Compactar tendencias dentro de celdas con SparklineGroup

Casos de uso

  • Paneles de control y libros de trabajo KPI generados según un horario
  • Resúmenes visuales incrustados junto a los datos sin procesar
  • Colocación automática de gráficos a partir de rangos de datos

Análisis de datos y protección

  • Reglas de formato condicional mediante FormatCondition
  • Reglas de validación de datos mediante Validation con OperatorType
  • Auto-filtros mediante AutoFilter; tablas estructuradas mediante ListObject
  • Nombres definidos mediante DefinedName; protección mediante WorkbookProtection y WorksheetProtection
  • Carga robusta de XLSX con banderas de reparación de LoadOptions y LoadDiagnostics

¿Quién se beneficia?

  • Equipos que envían libros de trabajo de entrada de datos validados
  • Servicios que ingieren archivos XLSX de terceros que pueden necesitar reparación
  • Analistas que reciben informes prefiltrados y protegidos

Crear, guardar y volver a cargar un libro de trabajo

Cree un libro de trabajo, escriba valores tipados y una fórmula con un resultado en caché, guárdelo como XLSX y cárguelo de nuevo:

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

Cargar archivos XLSX con opciones de reparación

Abra libros de trabajo de forma defensiva con las banderas de reparación de LoadOptions y examine los diagnósticos de carga estructurados:

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

Agregar gráficos a partir de rangos de datos

Rellena un rango de datos, luego ancla los gráficos de columnas y de líneas a él:

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

Preguntas frecuentes

¿Qué licencia usa Aspose.Cells FOSS for Rust?

El crate se publica bajo la MIT License; el texto completo se envía en el repositorio como LICENSE.txt.

¿Puedo usarlo en productos comerciales?

Sí. La Licencia MIT permite el uso comercial, la modificación y la redistribución, siempre que se conserve el aviso de derechos de autor y la licencia.

¿Cómo instalo el crate?

Agrega aspose-cells-foss-rust a tu Cargo.toml como una dependencia git del repositorio de GitHub.

¿Qué formatos pueden leerse y escribirse?

XLSX, con lectura y escritura de ida y vuelta completas mediante Workbook::load_xlsx y save. Otros formatos de hoja de cálculo no son compatibles en la versión actual.

¿Requiere Microsoft Office?

No. La biblioteca lee y escribe el formato de paquete XLSX directamente — no se requiere instalación de Office, automatización COM o tiempo de ejecución externo.

  

Recursos de soporte y aprendizaje

 Español