Introduzione

Aspose.Cells FOSS per Go è una libreria pure-Go per lavorare con i fogli di calcolo Excel. Espone un API per creare nuove cartelle di lavoro da zero, scrivere e formattare i valori delle celle, applicare regole di convalida dei dati, costruire tabelle strutturate, incorporare immagini e leggere grandi file .xlsx riga per riga — tutto senza dipendenze native C o C++.

La libreria è disponibile come modulo Go su github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go ed è rilasciata sotto licenza MIT. Installala con go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 in qualsiasi progetto Go 1.24+.

Questo post copre le funzionalità principali: formattazione delle celle, convalida dei dati, tabelle, immagini e letture in streaming.

Caratteristiche principali

Formattazione delle celle

Raggruppa le impostazioni Font, Fill, Alignment e Border in un Style riutilizzabile, quindi applicalo a una cella con Cell.SetStyle:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]

boldStyle := cells_foss.NewStyle()
boldStyle.Font.Bold = true
boldStyle.Font.Size = 12

cell, _ := ws.Cells().Get("A1")
cell.SetStyle(boldStyle)

Alignment controlla Horizontal, Vertical e WrapText; Border controlla la visibilità delle regole Top, Bottom, Left e Right oltre a Color.

Convalida dei dati

Worksheet.AddDataValidation aggiunge una regola di convalida a un intervallo di celle. La struttura DataValidation contiene la regola Type, uno o due valori Formula e i campi del messaggio di errore:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]

dv := &cells_foss.DataValidation{
	Type:             cells_foss.DataValidationTypeList,
	Formula1:         `"Apple,Banana,Cherry,Dragonfruit"`,
	AllowBlank:       true,
	ShowErrorMessage: true,
	ErrorTitle:       "Invalid Fruit",
	ErrorMessage:     "Please pick a fruit from the list.",
	ErrorStyle:       cells_foss.ErrorStyleStop,
}
ws.AddDataValidation("A2:A10", dv)

Tabelle

Worksheet.AddTable crea un Table strutturato su un intervallo, con una riga di intestazione opzionale e uno stile di tabella denominato:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
ws.Cells().Set("A1", "Item")
ws.Cells().Set("B1", "Qty")

tbl := ws.AddTable("A1:B2")
tbl.HasHeaderRow = true
tbl.StyleName = "TableStyleMedium6"

Immagini

Worksheet.AddPicture incorpora un’immagine; Picture.SetAnchor(row, col) la posiziona:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
imageBytes := []byte{} // populate with real image bytes before use

pic := &cells_foss.Picture{Data: imageBytes, Format: "png"}
ws.AddPicture(pic)
pic.SetAnchor(5, 0)

Streaming di file di grandi dimensioni

StreamingReader legge un foglio di lavoro riga per riga tramite una callback, quindi un workbook con migliaia di righe non deve mai essere caricato completamente in memoria:

sr := cells_foss.NewStreamingReader("large_workbook.xlsx")
err := sr.ProcessRows("Sheet1", func(rowIdx int, cells map[string]string) error {
	// process one row at a time
	return nil
})
if err != nil {
	fmt.Printf("Error streaming: %v\n", err)
}

Guida rapida

Installa il modulo:

go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26

Un flusso di lavoro minimale — crea un workbook, scrivi due celle, rendi grassetto l’intestazione e salva:

package main

import (
	"fmt"

	cells_foss "github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26/aspose/cells_foss"
)

func main() {
	wb := cells_foss.NewWorkbook()
	ws := wb.Worksheets[0]

	ws.Cells().Set("A1", "Product")
	ws.Cells().Set("B1", "Revenue")

	boldStyle := cells_foss.NewStyle()
	boldStyle.Font.Bold = true
	for _, ref := range []string{"A1", "B1"} {
		cell, _ := ws.Cells().Get(ref)
		cell.SetStyle(boldStyle)
	}

	if err := wb.Save("report.xlsx"); err != nil {
		fmt.Printf("Error saving workbook: %v\n", err)
		return
	}
	fmt.Println("Workbook saved to report.xlsx")
}

Formati supportati

FormatoEstensioneLeggiScrivi
XLSX.xlsx—✓
CSV.csv✓✓

I workbook XLSX sono costruiti in memoria con NewWorkbook e scritti con Workbook.Save. CSV è bidirezionale tramite Workbook.ImportFromCSV e Workbook.ExportToCSV.

Open Source & Licenza

Aspose.Cells FOSS per Go è rilasciato sotto licenza MIT. Non ci sono restrizioni d’uso, né costi di runtime, né requisiti di registrazione. Il codice sorgente è disponibile su github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go.

L’uso commerciale è consentito secondo i termini della licenza MIT. Se il tuo progetto richiede supporto di livello enterprise, copertura estesa dei formati o integrazione cloud, il Aspose.Cells — Enterprise Product Family è un’offerta commerciale separata.

Guida introduttiva

Risorse correlate