1. Produkter
  2.   Kalkylblad
  3.   Rust
  4.   umya-spreadsheet

umya-spreadsheet

 
 

Rent Rust-bibliotek för XLSX/XLSM-filer

Läs, skriv, formatera och manipulera XLSX/XLSM-kalkylblad utan externa beroenden.

Vad är umya-spreadsheet?

umya-spreadsheet är ett högpresterande, rent Rust-bibliotek för att läsa och skriva Excel‑kalkylbladsfiler i XLSX‑ och XLSM‑format. Designat för säkerhet och effektivitet undviker det osäker kod och externa beroenden, vilket gör det idealiskt för skrivbordsapplikationer, server‑sidig bearbetning och WebAssembly‑miljöer. Biblioteket erbjuder ett rent, idiomatiskt Rust‑API för åtkomst till celler, rader, kolumner, stilar, diagram och bilder, vilket möjliggör för utvecklare att bygga robusta kalkylbladsverktyg utan att förlita sig på Microsoft Office eller COM‑interoperabilitet.

Med fullt stöd för lazy loading, lösenordsskydd och rik formatering överbryggar umya-spreadsheet klyftan mellan prestanda och användbarhet. Det stödjer CSV‑export, diagramgenerering, bildinbäddning och områdesoperationer som att flytta och kopiera. Projektet underhålls aktivt, är väl dokumenterat och testat, med fokus på korrekthet och kompatibilitet med moderna Excel‑funktioner. Utvecklare kan integrera det i CLI‑verktyg, webb‑backend eller skrivbordsappar med ramverk som Tauri eller Axo.

Previous Next

Komma igång med umya-spreadsheet

För att börja använda umya-spreadsheet, lägg till den i din Cargo.toml med `umya-spreadsheet = "3.1.1"`. För WebAssembly-stöd, aktivera `js`-funktionen. Biblioteket är lätt på beroenden och kompilerar snabbt. När det är installerat, importera det via `extern crate umya_spreadsheet;` och börja läsa eller skriva kalkylblad. Du kan också utforska umya-spreadsheet GitHub för exempel, tester och dokumentation. Det stöder lazy loading för stora filer och erbjuder robust felhantering.

Installera umya-spreadsheet via Cargo

[dependencies]
umya-spreadsheet = "3.1.1"

# WebAssembly support
umya-spreadsheet = { version = "3.1.1", features = ["js"] }

Läsa & skriva XLSX/XLSM-filer

umya-spreadsheet tillhandahåller intuitiva API:er för att läsa och skriva XLSX- och XLMS-filer. Använd `reader::xlsx::read()` för att läsa in en arbetsbok från disk, eller `new_file()` för att skapa en tom. Skrivning är lika enkelt: anropa `writer::xlsx::write()` med arbetsboken och målvägen. Biblioteket stöder lat laddning via `lazy_read()` för förbättrad prestanda på stora filer, och tillåter lösenordsskyddad skrivning eller att sätta lösenord efter skapandet. Alla operationer är säkra, nollkopiering där det är möjligt, och undviker externa binärer.

Hur läser och skriver man en XLSX-fil via Rust?

use std::path::Path;

// Read file
let path = Path::new("./input.xlsx");
let mut book = umya_spreadsheet::reader::xlsx::read(path).unwrap();

// Write file
let out_path = Path::new("./output.xlsx");
umya_spreadsheet::writer::xlsx::write(&book, out_path).unwrap();

Cellåtkomst & stilmanipulering

Att komma åt och ändra cellvärden är enkelt: använd `cell("A1")` eller `cell((1,1))` för läsning, och `cell_mut()` för skrivning. Stilar hanteras via `style_mut()`, vilket möjliggör bakgrundsfärg, teckensnitt, kanter och justeringsändringar. Biblioteket exponerar ett rikt urval av stilegenskaper samtidigt som det upprätthåller oföränderlighetsgarantier där det är möjligt. Du kan också hämta formaterade värden, tillämpa villkorlig logik och batchuppdatera stilar över områden. Detta gör det idealiskt för att generera rapporter, instrumentpaneler eller dataexporter med konsekvent formatering.

Hur ändrar man cellvärde och stil via Rust?

let mut book = umya_spreadsheet::new_file();
book.sheet_by_name_mut("Sheet1")
    .unwrap()
    .cell_mut("A1")
    .set_value("Hello, Rust!");

let mut style = book.sheet_by_name_mut("Sheet1")
    .unwrap()
    .style_mut("A1");
style.set_background_color(umya_spreadsheet::Color::COLOR_RED);

Diagram & bildstöd

umya-spreadsheet stödjer att skapa och redigera diagram—inklusive linje-, stapel- och områdesdiagram—genom att definiera serieräckvidder och markörer. Du kan bädda in bilder direkt i blad med hjälp av `Image`-strukturen, med stöd för PNG och andra format beroende på vilka funktioner som är aktiverade. Diagram och bilder integreras sömlöst med cellkoordinater och ritlager, vilket möjliggör dynamisk instrumentpanelgenerering. Även om vissa avancerade ritfunktioner fortfarande utvecklas, är kärnfunktionaliteten produktionsklar och utbyggbar.

Hur lägger man till ett linjediagram i ett kalkylblad via Rust?

let mut book = umya_spreadsheet::new_file();
let mut from_marker = umya_spreadsheet::structs::drawing::spreadsheet::MarkerType::default();
from_marker.set_coordinate("C1");
let mut to_marker = umya_spreadsheet::structs::drawing::spreadsheet::MarkerType::default();
to_marker.set_coordinate("D11");
let series = vec!["Sheet1!$A$1:$A$10", "Sheet1!$B$1:$B$10"];
let mut chart = umya_spreadsheet::structs::Chart::default();
chart.new_chart(
    umya_spreadsheet::structs::ChartType::LineChart,
    from_marker,
    to_marker,
    series,
);
book.sheet_by_name_mut("Sheet1")
    .unwrap()
    .add_chart(chart);

Områdesoperationer & lösenordsskydd

Utför avancerade operationer som att flytta, kopiera och ändra storlek på områden med `move_range()`, vilket möjliggör dynamisk dataomorganisering. Biblioteket stödjer också lösenordsskyddade arbetsböcker: skriv filer med `write_with_password()` eller applicera lösenord på befintliga filer via `set_password()`. Dessa funktioner är kritiska för säker datahantering i företags- eller regelefterlevnadskänsliga applikationer. Kombinerat med en design utan beroenden och WASM-kompatibilitet levererar umya-spreadsheet både flexibilitet och säkerhet.

Hur flyttar man ett område och skyddar en fil med lösenord via Rust?

// Move range
let range = "A1:A3";
book.sheet_by_name_mut("Sheet1")
    .unwrap()
    .move_range(range, &10, &2);

// Password protection
umya_spreadsheet::writer::xlsx::write_with_password(
    &book,
    Path::new("./protected.xlsx"),
    "mypassword",
).unwrap();
 Svenska