Biblioteca Go para trabalhar com documentos XLSX do Excel

Introdução ao Xlsx2Go

A maneira recomendada de instalar o xlsx é do GitHub, use o seguinte comando para uma instalação suave.

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

Criando novos arquivos XLSX via biblioteca Go

A biblioteca xlsx de código aberto oferece aos desenvolvedores de software a capacidade de criar um novo arquivo XLSX vazio do zero usando alguns comandos Go. Os desenvolvedores podem usar a nova função NewFile() para gerar um novo arquivo. Depois de criado, você pode adicionar facilmente novo conteúdo à pasta de trabalho. Você pode adicionar uma nova planilha ou anexar uma planilha existente com facilidade. Uma vez criado e concluído o trabalho, por favor salve seu trabalho, é recomendado Fechar() a planilha.

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

Acesse e leia arquivos XLSX

A biblioteca xlsx de código aberto fornece um conjunto de funções que permitem aos desenvolvedores acessar abrir e ler um arquivo de planilha XLSX existente dentro de seus próprios aplicativos Go. Você também pode acessar facilmente as planilhas de uma pasta de trabalho com apenas alguns comandos Go. Os desenvolvedores também podem acessar uma planilha específica de sua escolha com facilidade.

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(), ","))
}

Manipulando Linhas e Colunas em Planilhas

As células são a espinha dorsal de uma planilha do Excel. Uma planilha é composta de células organizadas em linhas e colunas. A biblioteca xlsx oferece aos desenvolvedores de software uma ampla variedade de recursos para lidar com linhas e colunas dentro de seus aplicativos usando comandos Go. Ele suporta adicionar novas linhas e colunas, iterar linhas e colunas, excluir linhas e colunas indesejadas, adicionar novas células a uma linha, obter valor de uma célula, aplicar formatação a um intervalo de células e muito mais.

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 e formatação

A biblioteca Free library xlsx fornece várias funções importantes que permitem aos desenvolvedores de software aplicar formatação e estilos às suas planilhas com facilidade. Estilos fornecem layout e decoração de células como fonte, cor, alinhamento de conteúdo, tamanho de fonte, preenchimento, etc. Você pode facilmente aplicar o estilo a um intervalo de células com apenas algumas linhas de código. Você só precisa criar um estilo uma vez e reutilizá-lo quando necessário. Você também pode aplicar formatos de número e data para células.

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