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

Aspose.Cells FOSS para Go

Crea, modifica y exporta hojas de cálculo Excel desde Go — gratuito y de código abierto, sin dependencias externas.

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

Documentación GitHub

Biblioteca Go de código abierto para hojas de cálculo de Excel

Aspose.Cells FOSS for Go es una biblioteca gratuita y de código abierto para trabajar con archivos de hojas de cálculo Excel en aplicaciones Go. Instálala con go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 y comienza a crear libros de trabajo, leer y escribir celdas, aplicar estilos, agregar validación de datos y exportar a CSV, sin requerir Microsoft Excel ni ninguna dependencia de Office.

La biblioteca expone un pequeño y idiomático API de Go construido alrededor de Workbook, Worksheet, Cells y Cell. Accede a las celdas a través de la colección Cells() con Get/Set/Remove, agrupa el formato en objetos reutilizables Style creados a partir de Font, Fill, Alignment y Border, y construye rangos estructurados Table con una fila de encabezado y estilo de tabla nombrado. Un StreamingReader dedicado lee libros de trabajo .xlsx fila por fila mediante una devolución de llamada, de modo que los archivos grandes pueden procesarse sin cargar toda la hoja en memoria.

go.mod no declara dependencias externas — la biblioteca está construida completamente sobre la biblioteca estándar de Go. Tiene licencia MIT, está alojada en GitHub y se instala con un único comando go get; sin cgo, sin bibliotecas nativas de Office y sin paquetes del sistema que configurar. Para la familia de productos empresariales, vea Aspose.Cells — Enterprise Product Family.

Leer y escribir archivos Excel

  • Acceso a celdas: Leer y escribir valores con Cells().Get(ref) / Cells().Set(ref, value).
  • Fórmulas: Cell.SetFormula/GetFormula almacenan una cadena de fórmula en la celda — evaluada por Excel o LibreOffice al abrir, no por la biblioteca al guardar.
  • Interoperabilidad CSV: Workbook.ExportToCSV/ImportFromCSV y Worksheet.ToCSV/FromCSV convierten entre XLSX y CSV.
  • Lecturas por streaming: StreamingReader.ProcessRows transmite una hoja de cálculo fila por fila mediante una devolución de llamada, para procesar archivos grandes sin cargar toda la hoja en memoria.
  • Protección con contraseña: Workbook.SetPassword/VerifyPassword protegen y verifican las contraseñas del libro.

Dónde Aspose.Cells FOSS Puede Usarse

  • Data pipelines: Exportar resultados de consultas de base de datos directamente a XLSX o CSV.
  • Report generation: Crear informes de Excel con estilo desde un servicio backend en Go.
  • Large-file processing: Transmitir a través de libros de trabajo de varios miles de filas con StreamingReader en lugar de cargarlos completamente en memoria.
  • ETL workflows: Leer hojas de entrada, transformar datos y escribir libros de trabajo de salida.
  • CI/CD automation: Generar artefactos de hojas de cálculo dentro de canalizaciones de compilación basadas en Go y contenedores Docker.

Estilos, validación de datos y tablas

  • Objetos de estilo: Agrupe Font (name, size, bold, italic, color), Fill (type, color), Alignment (horizontal, vertical, wrap text) y Border (top/bottom/left/right, color) en un Style reutilizable, aplicado con Cell.SetStyle.
  • Validación de datos: Worksheet.AddDataValidation adjunta reglas de validación de lista y de rango de números enteros, cada una con un título de error personalizado, mensaje y estilo de error.
  • Tablas: Worksheet.AddTable/GetTable crean un rango estructurado Table con una fila de encabezado opcional y un estilo de tabla con nombre.
  • Imágenes: Worksheet.AddPicture incrusta una imagen Picture con posicionamiento SetAnchor(row, col).

Experiencia del desarrollador

Aspose.Cells FOSS for Go se instala con un solo comando go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. go.mod no tiene entradas require — no hay dependencias externas que validar o incluir.

La superficie de API está intencionalmente compacta: Workbook, Worksheet, Cells, Cell, Style, y un puñado de tipos de soporte cubren la creación de hojas de cálculo, estilo, validación y E/S CSV/streaming. El código está bajo licencia MIT y alojado en GitHub.

Crear un libro de trabajo y escribir celdas

Instala con go get, crea un Workbook, accede a la primera Worksheet y escribe valores directamente en las celdas a través de la colección Cells() antes de guardar.

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

Agregar reglas de validación de datos

Adjunte una validación de tipo lista (un menú desplegable de valores permitidos) y una validación de rango de números enteros a dos columnas diferentes, cada una con su propio título y mensaje de error.

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

Transmitir libros de trabajo grandes fila a fila

StreamingReader lee una hoja de cálculo una fila a la vez mediante una devolución de llamada, de modo que un libro de trabajo de varios miles de filas nunca tiene que cargarse completamente en 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)
}

Preguntas frecuentes

¿Cuál es el modelo de licencia para Aspose.Cells FOSS for Go?

Aspose.Cells FOSS for Go se publica bajo la MIT License, que permite el uso comercial y de código abierto.

¿Puedo usarlo en productos comerciales?

Sí. La Licencia MIT permite el uso comercial sin obligación de divulgar su propio código fuente, siempre que se conserve el aviso de derechos de autor original.

¿Cómo instalo Aspose.Cells FOSS for Go?

Añádelo como una dependencia de módulo Go con go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. Requiere Go 1.24 o posterior.

¿Hay dependencias externas?

No. go.mod no declara entradas require — la biblioteca está construida completamente sobre la biblioteca estándar de Go.

¿Puedo procesar libros de trabajo grandes sin cargarlos completamente en memoria?

Sí. StreamingReader.ProcessRows lee una hoja de cálculo fila por fila a través de una callback, evitando una carga completa en memoria.

  

Recursos de soporte y aprendizaje

 Español