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

Aspose.Cells FOSS för Go

Skapa, ändra och exportera Excel-kalkylblad från Go — gratis och öppen källkod, utan externa beroenden.

Öppen källkod Go-bibliotek för Excel-kalkylblad

Aspose.Cells FOSS for Go är ett gratis, open-source-bibliotek för att arbeta med Excel-kalkylblad i Go-applikationer. Installera det med go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 och börja skapa arbetsböcker, läsa och skriva celler, applicera stilar, lägga till datavalidering och exportera till CSV, utan att kräva Microsoft Excel eller någon Office-beroende.

Biblioteket exponerar en liten, idiomatisk Go API byggd kring Workbook, Worksheet, Cells och Cell. Åtkomst till celler sker via samlingen Cells() med Get/Set/Remove, gruppera formatering i återanvändbara Style-objekt byggda från Font, Fill, Alignment och Border, och bygg strukturerade Table-intervall med en rubrikrad och namngiven tabellstil. En dedikerad StreamingReader läser .xlsx-arbetsböcker rad för rad via en återuppringning, så stora filer kan behandlas utan att ladda hela bladet i minnet.

go.mod deklarerar inga externa beroenden — biblioteket är byggt helt på Go:s standardbibliotek. Det är MIT-licensierat, hostat på GitHub, och installeras med ett enda go get-kommando; ingen cgo, inga inhemska Office-bibliotek och inga systempaket att konfigurera. För företagsproduktfamiljen, se Aspose.Cells — Enterprise Product Family.

Läsa och skriva Excel-filer

  • Cellåtkomst: Läs och skriv värden med Cells().Get(ref) / Cells().Set(ref, value).
  • Formler: Cell.SetFormula/GetFormula lagrar en formelsträng i cellen — utvärderas av Excel eller LibreOffice vid öppning, inte av biblioteket när filen sparas.
  • CSV-interoperabilitet: Workbook.ExportToCSV/ImportFromCSV och Worksheet.ToCSV/FromCSV konverterar mellan XLSX och CSV.
  • Strömläsning: StreamingReader.ProcessRows strömmar ett kalkylblad rad för rad via en återuppringning, för bearbetning av stora filer utan att ladda in hela bladet i minnet.
  • Lösenordsskydd: Workbook.SetPassword/VerifyPassword skyddar och kontrollerar arbetsbokslösenord.

Var Aspose.Cells FOSS kan användas

  • Datapipelines: Exportera databasfrågeresultat direkt till XLSX eller CSV.
  • Rapportgenerering: Skapa stiliserade Excel-rapporter från en Go-backendtjänst.
  • Storskalig filbehandling: Strömma igenom arbetsböcker med flera tusen rader med StreamingReader istället för att ladda dem helt i minnet.
  • ETL-arbetsflöden: Läs inmatningsblad, transformera data och skriv utdataarbetsböcker.
  • CI/CD-automation: Generera kalkylbladsartefakter i Go-baserade byggpipelines och Docker-containrar.

Styling, datavalidering och tabeller

  • Stilobjekt: Gruppera Font (name, size, bold, italic, color), Fill (type, color), Alignment (horizontal, vertical, wrap text) och Border (top/bottom/left/right, color) i ett återanvändbart Style, som tillämpas med Cell.SetStyle.
  • Datavalidering: Worksheet.AddDataValidation lägger till list- och heltalsintervall-valideringsregler, var och en med en anpassad felrubrik, meddelande och felstil.
  • Tabeller: Worksheet.AddTable/GetTable skapar ett strukturerat Table-område med en valfri rubrikrad och en namngiven tabellstil.
  • Bilder: Worksheet.AddPicture bäddar in en bild Picture med positionering via SetAnchor(row, col).

Utvecklarupplevelse

Aspose.Cells FOSS for Go installeras med ett enda go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 kommando. go.mod har inga require-poster — det finns inga externa beroenden att granska eller vendor.

Ytan för API är avsiktligt kompakt: Workbook, Worksheet, Cells, Cell, Style, och ett fåtal stödjande typer täcker skapande av kalkylblad, formatering, validering och CSV/streaming I/O. Kodbasen är MIT-licensierad och hostad på GitHub.

Skapa en arbetsbok och skriv celler

Installera med go get, skapa en Workbook, få åtkomst till det första Worksheet och skriv värden direkt till celler via Cells()-samlingen innan du sparar.

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

Lägg till datavalideringsregler

Lägg till en listtypvalidering (en rullgardinsmeny med tillåtna värden) och en heltalsintervallvalidering på två olika kolumner, var och en med sin egen felrubrik och felmeddelande.

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

Strömma stora arbetsböcker rad för rad

StreamingReader läser ett kalkylblad rad för rad via en återuppringning, så en arbetsbok med flera tusen rader aldrig behöver laddas helt i minnet.

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

Vanliga Frågor

Vad är licensmodellen för Aspose.Cells FOSS for Go?

Aspose.Cells FOSS for Go släpps under MIT-licensen, vilket tillåter kommersiell och öppen källkodsanvändning.

Kan jag använda den i kommersiella produkter?

Ja. MIT License tillåter kommersiell användning utan någon skyldighet att avslöja din egen källkod, så länge det ursprungliga upphovsrättsmeddelandet behålls.

Hur installerar jag Aspose.Cells FOSS for Go?

Lägg till det som ett Go-modulberoende med go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. Kräver Go 1.24 eller senare.

Finns det några externa beroenden?

Nej. go.mod deklarerar inga require-poster — biblioteket är helt byggt på Go-standardbiblioteket.

Kan jag bearbeta stora arbetsböcker utan att ladda dem helt i minnet?

Ja. StreamingReader.ProcessRows läser ett arbetsblad rad för rad via ett återanrop, vilket undviker en full in-memory laddning.

  

Stöd och Lärande Resurser

 Svenska