1. Prodotti
  2.   Aspose.Cells
  3.   Aspose.Cells FOSS for Go

Aspose.Cells FOSS per Go

Crea, modifica ed esporta fogli di calcolo Excel da Go — gratuito e open-source, zero dipendenze esterne.

Aspose.Cells FOSS for Go Aspose.Cells FOSS
for Go

Documenti GitHub

Libreria Go Open-Source per fogli di calcolo Excel

Aspose.Cells FOSS for Go è una libreria gratuita e open-source per lavorare con file di fogli di calcolo Excel in applicazioni Go. Installala con go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 e inizia a creare cartelle di lavoro, leggere e scrivere celle, applicare stili, aggiungere la convalida dei dati e esportare in CSV, senza richiedere Microsoft Excel o alcuna dipendenza da Office.

La libreria espone un piccolo e idiomatico API Go costruito attorno a Workbook, Worksheet, Cells e Cell. Accedi alle celle tramite la collezione Cells() con Get/Set/Remove, raggruppa la formattazione in oggetti Style riutilizzabili creati da Font, Fill, Alignment e Border, e costruisci intervalli Table strutturati con una riga di intestazione e uno stile di tabella nominato. Un StreamingReader dedicato legge le cartelle di lavoro .xlsx riga per riga tramite una callback, così i file di grandi dimensioni possono essere elaborati senza caricare l’intero foglio in memoria.

go.mod non dichiara dipendenze esterne — la libreria è interamente costruita sulla standard library di Go. È rilasciata sotto licenza MIT, ospitata su GitHub, e si installa con un unico comando go get; nessun cgo, nessuna libreria Office nativa e nessun pacchetto di sistema da configurare. Per la famiglia di prodotti enterprise, vedi Aspose.Cells — Enterprise Product Family.

Leggere e scrivere file Excel

  • Accesso alle celle: Leggi e scrivi valori con Cells().Get(ref) / Cells().Set(ref, value).
  • Formule: Cell.SetFormula/GetFormula memorizzano una stringa di formula nella cella — valutata da Excel o LibreOffice all’apertura, non dalla libreria al momento del salvataggio.
  • Interop CSV: Workbook.ExportToCSV/ImportFromCSV e Worksheet.ToCSV/FromCSV convertono tra XLSX e CSV.
  • Letture in streaming: StreamingReader.ProcessRows trasmette un foglio di lavoro riga per riga tramite una callback, per l’elaborazione di file di grandi dimensioni senza caricare l’intero foglio in memoria.
  • Protezione con password: Workbook.SetPassword/VerifyPassword proteggono e verificano le password della cartella di lavoro.

Dove Aspose.Cells FOSS Può Essere Utilizzato

  • Data pipelines: Esporta i risultati delle query del database direttamente in XLSX o CSV.
  • Report generation: Crea report Excel con stile da un servizio backend Go.
  • Large-file processing: Esegui lo streaming attraverso cartelle di lavoro con migliaia di righe usando StreamingReader invece di caricarle completamente in memoria.
  • ETL workflows: Leggi i fogli di input, trasforma i dati e scrivi le cartelle di lavoro di output.
  • CI/CD automation: Genera artefatti di fogli di calcolo all’interno di pipeline di build basate su Go e container Docker.

Formattazione, Convalida dei Dati e Tabelle

  • Oggetti di stile: Raggruppa Font (name, size, bold, italic, color), Fill (type, color), Alignment (horizontal, vertical, wrap text) e Border (top/bottom/left/right, color) in un Style riutilizzabile, applicato con Cell.SetStyle.
  • Convalida dei dati: Worksheet.AddDataValidation aggiunge regole di convalida a elenco e intervallo di numeri interi, ciascuna con un titolo di errore personalizzato, messaggio e stile di errore.
  • Tabelle: Worksheet.AddTable/GetTable crea un intervallo Table strutturato con una riga di intestazione opzionale e uno stile di tabella nominato.
  • Immagini: Worksheet.AddPicture incorpora un’immagine Picture con posizionamento SetAnchor(row, col).

Esperienza dello sviluppatore

Aspose.Cells FOSS for Go si installa con un unico comando go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. go.mod non ha voci require — non ci sono dipendenze esterne da verificare o includere.

L’interfaccia API è intenzionalmente compatta: Workbook, Worksheet, Cells, Cell, Style e una manciata di tipi di supporto coprono la creazione di fogli di calcolo, lo stile, la validazione e CSV/streaming I/O. Il codice è rilasciato con licenza MIT ed è ospitato su GitHub.

Crea un Workbook e Scrivi Celle

Installa con go get, crea un Workbook, accedi al primo Worksheet e scrivi i valori direttamente nelle celle tramite la collezione Cells() prima di salvare.

go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26
func main() {
	wb := cells_foss.NewWorkbook()
	ws := wb.Worksheets[0]
	ws.Cells().Set("A1", "Hello")
	ws.Cells().Set("B1", "World")
	ws.Cells().Set("A2", "Answer")
	ws.Cells().Set("B2", 42)
	outPath := "outputfiles/basic.xlsx"
	if err := wb.Save(outPath); err != nil {
		fmt.Printf("Error saving workbook: %v\n", err)
		return
	}
	fmt.Printf("Workbook saved to %s\n", outPath)
}

Aggiungi regole di convalida dei dati

Allega una convalida di tipo elenco (un menu a discesa dei valori consentiti) e una convalida di intervallo di numeri interi a due colonne diverse, ciascuna con il proprio titolo e messaggio di errore.

func main() {
	wb := cells_foss.NewWorkbook()
	ws := wb.Worksheets[0]
	ws.Cells().Set("A1", "Fruit")
	ws.Cells().Set("A2", "Apple")
	ws.Cells().Set("A3", "Banana")
	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,
	}
	if err := ws.AddDataValidation("A2:A10", dv); err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	dv2 := &cells_foss.DataValidation{
		Type:             cells_foss.DataValidationTypeWhole,
		Formula1:         "1",
		Formula2:         "100",
		ShowErrorMessage: true,
		ErrorTitle:       "Invalid Value",
		ErrorMessage:     "Enter a whole number between 1 and 100.",
		ErrorStyle:       cells_foss.ErrorStyleWarning,
	}
	ws.Cells().Set("B1", "Score (1-100)")
	ws.AddDataValidation("B2:B10", dv2)
	outPath := "outputfiles/data_validation.xlsx"
	if err := wb.Save(outPath); err != nil {
		fmt.Printf("Error saving workbook: %v\n", err)
		return
	}
	fmt.Printf("Workbook saved to %s\n", outPath)
}

Esegui lo streaming di grandi cartelle di lavoro riga per riga

StreamingReader legge un foglio di lavoro una riga alla volta tramite una callback, quindi una cartella di lavoro con migliaia di righe non deve mai essere completamente caricata in memoria.

func main() {
	genPath := "outputfiles/streaming_data.xlsx"
	sr := cells_foss.NewStreamingReader(genPath)
	rowCount := 0
	var totalScore float64
	err := sr.ProcessRows("Sheet1", func(rowIdx int, cells map[string]string) error {
		rowCount++
		if rowIdx == 1 {
			fmt.Printf("  Header: %v\n", cells)
			return nil
		}
		if score, ok := cells["C"+fmt.Sprint(rowIdx)]; ok {
			var s float64
			fmt.Sscanf(score, "%f", &s)
			totalScore += s
		}
		return nil
	})
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error streaming: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Streamed %d rows (header + %d data rows)\n", rowCount, rowCount-1)
}

Domande Frequenti

Qual è il modello di licenza per Aspose.Cells FOSS for Go?

Aspose.Cells FOSS for Go è rilasciato sotto la Licenza MIT, che consente l’uso commerciale e open-source.

Posso usarlo in prodotti commerciali?

Sì. La licenza MIT consente l’uso commerciale senza obbligo di divulgare il proprio codice sorgente, purché venga mantenuto l’avviso di copyright originale.

Come installo Aspose.Cells FOSS for Go?

Aggiungilo come dipendenza del modulo Go con go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. Richiede Go 1.24 o versioni successive.

Ci sono dipendenze esterne?

No. go.mod non dichiara voci require — la libreria è costruita interamente sulla libreria standard di Go.

Posso elaborare cartelle di lavoro di grandi dimensioni senza caricarle completamente in memoria?

Sì. StreamingReader.ProcessRows legge un foglio di lavoro riga per riga tramite una callback, evitando un caricamento completo in memoria.

  

Risorse di Supporto e Apprendimento

 Italiano