Ir a Biblioteca para trabajar con documentos Excel XLSX

Primeros pasos con Xlsx2Go

La forma recomendada de instalar xlsx es desde GitHub. Utilice el siguiente comando para una instalación sin problemas.

go get https://github.com/tealeg/xlsx.git

Creación de NUEVOS archivos XLSX a través de Go Library

La biblioteca xlsx de código abierto brinda a los desarrolladores de software la capacidad de crear un nuevo archivo XLSX vacío desde cero usando un par de comandos Go. Los desarrolladores pueden usar la nueva función NewFile() para generar un nuevo archivo. Una vez que se crea, puede agregar fácilmente contenido nuevo al libro de trabajo. Puede agregar una hoja nueva o adjuntar una hoja existente con facilidad. Una vez creado y completado el trabajo, guarde su trabajo, se recomienda Cerrar () la hoja.

// Demonstrates how to create/open/save XLSX files
func Example_files() {
	// Create a new XLSX file
	xl := xlsx.New()
	// Open the XLSX file using file name
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	// Open the XLSX file using file handler
	zipFile, err := os.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	xl, err = xlsx.Open(zipFile)
	if err != nil {
		log.Fatal(err)
	}
	// Update the existing XLSX file
	err = xl.Save()
	if err != nil {
		log.Fatal(err)
	}
	// Save the XLSX file under different name
	err = xl.SaveAs("new_file.xlsx")
	if err != nil {
		log.Fatal(err)
	}
}

Acceder y leer archivos XLSX

La biblioteca xlsx de código abierto ha proporcionado un conjunto de funciones que permiten a los desarrolladores acceder, abrir y leer un archivo de hoja de cálculo XLSX existente dentro de sus propias aplicaciones Go. También puede acceder fácilmente a las hojas de un libro de trabajo con solo un par de comandos Go. Los desarrolladores también pueden acceder fácilmente a una hoja particular de su elección.

func Example_access() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	// Get sheet by 0-based index
	sheet := xl.Sheet(0)
	// Get cell by 0-based indexes
	cell := sheet.Cell(13, 27)
	fmt.Println(cell.Value())
	// Get cell by reference
	cell = sheet.CellByRef("N28")
	fmt.Println(cell.Value())
	// Get row by 0-based index
	row := sheet.Row(9)
	fmt.Println(strings.Join(row.Values(), ","))
	// Get cell of row at 0-based col index
	cell = row.Cell(0)
	fmt.Println(cell.Value())
	// Get col by 0-based index
	col := sheet.Col(3)
	fmt.Println(strings.Join(col.Values(), ","))
	// Get cell of col at 0-based row index
	cell = col.Cell(0)
	fmt.Println(cell.Value())
	// Get range by references
	area := sheet.RangeByRef("D10:H13")
	fmt.Println(strings.Join(area.Values(), ","))
}

Manejo de filas y columnas en hojas de trabajo

Las celdas son la columna vertebral de una hoja de cálculo de Excel. Una hoja de trabajo se compone de celdas organizadas en filas y columnas. La biblioteca xlsx brinda a los desarrolladores de software una amplia gama de funciones para manejar filas y columnas dentro de sus aplicaciones mediante los comandos Go. Admite agregar nuevas filas y columnas, iterar filas y columnas, eliminar filas y columnas no deseadas, agregar nuevas celdas a una fila, obtener valor de una celda, aplicar formato a un rango de celdas y mucho más.

func Example_insert() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	sheet := xl.Sheet(0)
	fmt.Println(sheet.Dimension())
	fmt.Println(strings.Join(sheet.Col(3).Values(), ","))
	// Insert a new col
	sheet.InsertCol(3)
	fmt.Println(sheet.Dimension())
	fmt.Println(strings.Join(sheet.Col(3).Values(), ","))
	fmt.Println(strings.Join(sheet.Col(4).Values(), ","))
	// Insert a new row
	fmt.Println(strings.Join(sheet.Row(9).Values(), ","))
	sheet.InsertRow(3)
	fmt.Println(sheet.Dimension())
	fmt.Println(strings.Join(sheet.Row(9).Values(), ","))
	fmt.Println(strings.Join(sheet.Row(10).Values(), ","))
}

Aplicar estilos y formato

La biblioteca Free library xlsx ha proporcionado varias funciones importantes que permiten a los desarrolladores de software aplicar formatos y estilos a sus hojas de cálculo con facilidad. Los estilos brindan diseño y decoración de celdas como fuente, color, alineación de contenido, tamaño de fuente, relleno, etc. Puede aplicar fácilmente el estilo a un rango de celdas con solo un par de líneas de código. Solo necesita crear un estilo una vez y reutilizarlo cuando sea necesario. También puede aplicar formatos de número y fecha para las celdas.

gfunc Example_formatting() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	// Create a new format for a bold font with red color and yellow solid background
	redBold := styles.New(
		styles.Font.Bold,
		styles.Font.Color("#ff0000"),
		styles.Fill.Background("#ffff00"),
		styles.Fill.Type(styles.PatternTypeSolid),
	)
	// Add formatting to xlsx
	styleID := xl.AddStyles(redBold)
	sheet := xl.Sheet(0)
	// Set formatting for cell
	sheet.CellByRef("N28").SetStyles(styleID)
	// Set DEFAULT formatting for row. Affects cells not yet allocated in the row.
	// In other words, this style applies to new cells.
	sheet.Row(9).SetStyles(styleID)
	// Set DEFAULT formatting for col. Affects cells not yet allocated in the col.
	// In other words, this style applies to new cells.
	sheet.Col(3).SetStyles(styleID)
	//set formatting for all cells in range
	sheet.RangeByRef("D10:H13").SetStyles(styleID)
}