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

Aspose.Cells FOSS pentru Go

Creează, modifică și exportă foi de calcul Excel din Go — gratuit și cu sursă deschisă, fără dependențe externe.

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

Documentație GitHub

Bibliotecă Go open-source pentru foi de calcul Excel

Aspose.Cells FOSS for Go este o bibliotecă gratuită, open-source pentru lucrul cu fișiere de calcul Excel în aplicații Go. Instalați-o cu go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 și începeți să creați registre de lucru, să citiți și să scrieți celule, să aplicați stiluri, să adăugați validare de date și să exportați în CSV, fără a necesita Microsoft Excel sau orice dependență Office.

Biblioteca expune un mic, idiomatic API Go construit în jurul lui Workbook, Worksheet, Cells și Cell. Accesați celulele prin colecția Cells() cu Get/Set/Remove, grupați formatarea în obiecte reutilizabile Style construite din Font, Fill, Alignment și Border, și construiți intervale structurate Table cu un rând de antet și stil de tabel numit. Un StreamingReader dedicat citește registrele de lucru .xlsx rând cu rând printr-un callback, astfel încât fișierele mari pot fi procesate fără a încărca întreaga foaie în memorie.

go.mod nu declară dependențe externe — biblioteca este construită în totalitate pe bibliotecile standard Go. Este licențiată sub MIT, găzduită pe GitHub și se instalează cu o singură comandă go get; fără cgo, fără biblioteci native Office și fără pachete de sistem de configurat. Pentru familia de produse enterprise, vedeți Aspose.Cells — Enterprise Product Family.

Citire și scriere fișiere Excel

  • Acces la celule: Citește și scrie valori cu Cells().Get(ref) / Cells().Set(ref, value).
  • Formule: Cell.SetFormula/GetFormula stochează un șir de formulă în celulă — evaluat de Excel sau LibreOffice la deschidere, nu de bibliotecă la salvare.
  • Interoperabilitate CSV: Workbook.ExportToCSV/ImportFromCSV și Worksheet.ToCSV/FromCSV convertesc între XLSX și CSV.
  • Citiri în flux: StreamingReader.ProcessRows transmite un rând al foii de calcul rând cu rând printr-un callback, pentru procesarea fișierelor mari fără a încărca întreaga foaie în memorie.
  • Protecție prin parolă: Workbook.SetPassword/VerifyPassword protejează și verifică parolele workbook-ului.

Unde Aspose.Cells FOSS poate fi utilizat

  • Pipelines de date: Exportă rezultatele interogărilor bazei de date direct în XLSX sau CSV.
  • Generarea de rapoarte: Construiește rapoarte Excel stilizate dintr-un serviciu backend Go.
  • Procesarea fișierelor mari: Transmite în flux registre de lucru cu mii de rânduri cu StreamingReader în loc să le încarci complet în memorie.
  • Fluxuri de lucru ETL: Citește foile de intrare, transformă datele și scrie registrele de lucru de ieșire.
  • Automatizare CI/CD: Generează artefacte de foi de calcul în interiorul pipeline-urilor de construcție bazate pe Go și containere Docker.

Stilizare, validarea datelor și tabele

  • Obiecte de stil: Grupează Font (name, size, bold, italic, color), Fill (type, color), Alignment (horizontal, vertical, wrap text) și Border (top/bottom/left/right, color) într-un Style reutilizabil, aplicat cu Cell.SetStyle.
  • Validare de date: Worksheet.AddDataValidation atașează reguli de validare de tip listă și interval de numere întregi, fiecare cu un titlu de eroare personalizat, mesaj și stil de eroare.
  • Tabele: Worksheet.AddTable/GetTable creează un interval structurat Table cu un rând de antet opțional și un stil de tabel numit.
  • Imagini: Worksheet.AddPicture încorporează o imagine Picture cu poziționarea SetAnchor(row, col).

Experiența dezvoltatorului

Aspose.Cells FOSS for Go se instalează cu o singură comandă go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. go.mod nu are intrări require — nu există dependențe externe de verificat sau de adăugat în vendor.

Suprafața API este intenționat compactă: Workbook, Worksheet, Cells, Cell, Style și câteva tipuri de suport acoperă crearea de foi de calcul, stilizarea, validarea și CSV/streaming I/O. Codul sursă este licențiat sub MIT și găzduit pe GitHub.

Creează un Workbook și scrie celule

Instalați cu go get, creaţi un Workbook, accesaţi primul Worksheet şi scrieţi valori direct în celule prin colecţia Cells() înainte de a salva.

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

Adăugați reguli de validare a datelor

Atașați o validare de tip listă (un meniu derulant cu valori permise) și o validare de interval de numere întregi pentru două coloane diferite, fiecare având propriul titlu și mesaj de eroare.

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

Transmiteți registre de lucru mari rând cu rând

StreamingReader citește o foaie de calcul rând cu rând printr-un callback, astfel încât un registru cu mii de rânduri nu trebuie să fie încărcat complet în memorie.

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

Întrebări Frecvente

Care este modelul de licențiere pentru Aspose.Cells FOSS for Go?

Aspose.Cells FOSS for Go este lansat sub Licența MIT, care permite utilizarea comercială și open-source.

Pot să-l folosesc în produse comerciale?

Da. Licența MIT permite utilizarea comercială fără nicio obligație de a dezvălui codul sursă propriu, atâta timp cât se păstrează notificarea originală de drepturi de autor.

Cum instalez Aspose.Cells FOSS for Go?

Adăugați-l ca dependență de modul Go cu go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. Necesită Go 1.24 sau o versiune ulterioară.

Există dependențe externe?

Nu. go.mod nu declară nicio intrare require — biblioteca este construită în întregime pe biblioteca standard Go.

Pot procesa registre de lucru mari fără să le încarc complet în memorie?

Da. StreamingReader.ProcessRows citește o foaie de lucru rând cu rând printr-un callback, evitând o încărcare completă în memorie.

  

Resurse de Suport și Învățare

 Română