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

Aspose.Cells FOSS pro Go

Vytvářejte, upravujte a exportujte Excel tabulky z Go — zdarma a s otevřeným zdrojovým kódem, žádné externí závislosti.

Open-Source Go knihovna pro Excel tabulky

Aspose.Cells FOSS for Go je bezplatná, open-source knihovna pro práci se soubory Excel tabulek v aplikacích Go. Nainstalujte ji pomocí go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 a začněte vytvářet sešity, číst a zapisovat buňky, aplikovat styly, přidávat ověřování dat a exportovat do CSV, aniž byste potřebovali Microsoft Excel nebo jakoukoli závislost na Office.

Knihovna poskytuje malý, idiomatický Go API postavený kolem Workbook, Worksheet, Cells a Cell. Přistupujte k buňkám přes kolekci Cells() pomocí Get/Set/Remove, seskupujte formátování do znovupoužitelných objektů Style vytvořených z Font, Fill, Alignment a Border, a vytvářejte strukturované rozsahy Table s řádkem hlavičky a pojmenovaným stylem tabulky. Vyhrazený StreamingReader čte .xlsx sešity řádek po řádku prostřednictvím callbacku, takže velké soubory lze zpracovávat bez načítání celé listu do paměti.

go.mod neuvádí žádné externí závislosti — knihovna je postavena výhradně na standardní knihovně Go. Je licencována pod MIT, hostována na GitHub, a instalujete ji jedním příkazem go get; žádný cgo, žádné nativní knihovny Office a žádné systémové balíčky k nastavení. Pro rodinu podnikových produktů viz Aspose.Cells — Enterprise Product Family.

Čtení a zápis souborů Excel

  • Přístup k buňkám: Číst a zapisovat hodnoty pomocí Cells().Get(ref) / Cells().Set(ref, value).
  • Vzorce: Cell.SetFormula/GetFormula uloží řetězec vzorce do buňky — vyhodnocuje jej Excel nebo LibreOffice při otevření, nikoli knihovna při ukládání.
  • CSV interoperabilita: Workbook.ExportToCSV/ImportFromCSV a Worksheet.ToCSV/FromCSV převádějí mezi XLSX a CSV.
  • Streamové čtení: StreamingReader.ProcessRows streamuje řádky listu po řádku pomocí callbacku, pro zpracování velkých souborů bez načítání celého listu do paměti.
  • Ochrana heslem: Workbook.SetPassword/VerifyPassword chrání a ověřuje hesla sešitu.

Kde lze Aspose.Cells FOSS použít

  • Datové potrubí: Exportujte výsledky databázových dotazů přímo do XLSX nebo CSV.
  • Generování zpráv: Vytvářejte stylované Excelové zprávy z backendové služby v Go.
  • Zpracování velkých souborů: Streamujte skrze sešity s tisíci řádky pomocí StreamingReader místo jejich kompletního načtení do paměti.
  • ETL pracovní toky: Čtěte vstupní listy, transformujte data a zapisujte výstupní sešity.
  • Automatizace CI/CD: Generujte artefakty tabulek uvnitř build pipeline založených na Go a Docker kontejnerech.

Styling, ověřování dat a tabulky

  • Style objects: Seskupí Font (name, size, bold, italic, color), Fill (type, color), Alignment (horizontal, vertical, wrap text) a Border (top/bottom/left/right, color) do znovupoužitelného Style, aplikovaného pomocí Cell.SetStyle.
  • Data validation: Worksheet.AddDataValidation připojuje seznam a pravidla pro rozsah celých čísel, každé s vlastním názvem chyby, zprávou a stylem chyby.
  • Tables: Worksheet.AddTable/GetTable vytvoří strukturovaný rozsah Table s volitelným řádkem záhlaví a pojmenovaným stylem tabulky.
  • Pictures: Worksheet.AddPicture vloží obrázek Picture s pozicováním pomocí SetAnchor(row, col).

Zkušenost vývojáře

Aspose.Cells FOSS for Go se nainstaluje jediným go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 příkazem. go.mod nemá žádné položky require — neexistují žádné externí závislosti k ověření nebo vendorování.

Rozhraní API je úmyslně kompaktní: Workbook, Worksheet, Cells, Cell, Style a několik doplňujících typů pokrývají vytváření tabulek, formátování, validaci a CSV/streaming I/O. Kódová základna je licencována pod licencí MIT a je hostována na GitHub.

Vytvořte sešit a zapište buňky

Nainstalujte pomocí go get, vytvořte Workbook, přistupte k prvnímu Worksheet a zapisujte hodnoty přímo do buněk pomocí kolekce Cells() před uložením.

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

Přidat pravidla validace dat

Přidejte validaci typu seznam (rozbalovací seznam povolených hodnot) a validaci rozsahu celých čísel do dvou různých sloupců, každou s vlastním názvem a zprávou chyby.

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

Streamovat velké sešity řádek po řádku

StreamingReader čte list po řádku pomocí zpětného volání, takže se sešit s několika tisíci řádky nikdy nemusí načíst celý do paměti.

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

Často kladené dotazy

Jaký je licenční model pro Aspose.Cells FOSS for Go?

Aspose.Cells FOSS for Go je vydán pod licencí MIT, která umožňuje komerční i open-source použití.

Mohu jej použít v komerčních produktech?

Ano. Licence MIT umožňuje komerční využití bez povinnosti zveřejnit váš vlastní zdrojový kód, pokud je zachováno původní upozornění na autorská práva.

Jak nainstaluji Aspose.Cells FOSS for Go?

Přidejte jej jako závislost modulu Go pomocí go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. Vyžaduje Go 1.24 nebo novější.

Existují nějaké externí závislosti?

Ne. go.mod neuvádí žádné položky require — knihovna je zcela postavena na standardní knihovně Go.

Mohu zpracovávat velké sešity, aniž bych je načítal celý do paměti?

Ano. StreamingReader.ProcessRows čte list řádek po řádku pomocí zpětného volání, čímž se vyhne načtení celého listu do paměti.

  

Podpora a vzdělávací materiály

 Čeština