Go API para manipulação de planilhas do Microsoft Excel XLSX

Introdução ao Xlsx2Go

A maneira recomendada de instalar o Xlsx2Go em seu projeto é usando o GitHub. Por favor, use o seguinte comando para uma instalação suave.

go get https://github.com/LucienLS/xlsx2go.git

Gerar planilha XLSX via Go API

A biblioteca de código aberto Xlsx2Go permite que programadores de computador gerem uma planilha Excel XLSX dentro de seus próprios aplicativos usando comandos Go. Você também pode abrir, modificar ou excluir facilmente uma planilha existente. Você também pode usar vários recursos importantes, como inserir novas linhas e colunas em uma planilha, definir o valor padrão de uma célula, aplicar formatação a um intervalo de células e muito mais.

func main() {
	// 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)
	}
}

Gerenciar células e linhas na planilha do Excel

A biblioteca gratuita Xlsx2Go incluiu vários recursos importantes relacionados ao gerenciamento de células e linhas dentro de planilhas do Excel. Você pode facilmente inserir novas linhas e células, mesclar linhas e células, adicionar um comentário a uma célula do Excel, obter todas as células em uma linha, criar uma nova célula, selecionar um intervalo de células, aplicar estilos a um intervalo de células, adicionar um hiperlink para uma célula, definir hora e data em uma célula e muito mais.

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

Anexar Ross, Colunas e Folhas em uma planilha

Às vezes, um usuário ou uma organização tem várias planilhas com estruturas semelhantes (linhas e colunas) e deseja mesclar as informações em uma planilha grande. O recurso de acréscimo ajuda os desenvolvedores a adicionar uma planilha ou várias planilhas a uma existente ou combinar todas em uma nova planilha. A biblioteca Xlsx2Go forneceu funcionalidade para anexar de forma programática colunas, linhas e planilhas com facilidade.

func main() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	sheet := xl.Sheet(0)
	// To append a new col/row, simple request it - sheet will be auto expanded.
	// E.g.: we have 14 cols, 28 rows.
	fmt.Println(sheet.Dimension())
	// Append 72 rows
	sheet.Row(99)
	fmt.Println(sheet.Dimension())
	// Append 36 cols
	sheet.Col(49)
	fmt.Println(sheet.Dimension())
	// Append 3 sheet
	fmt.Println(strings.Join(xl.SheetNames(), ","))
	xl.AddSheet("new sheet")
	xl.AddSheet("new sheet")
	xl.AddSheet("new sheet")
	fmt.Println(strings.Join(xl.SheetNames(), ","))
}

Gerencie a formatação da planilha via Go API

A biblioteca gratuita Xlsx2Go permite que desenvolvedores de software adicionem estilos para formatar suas planilhas usando comandos Go. Os desenvolvedores podem criar facilmente um novo formato para definir estilos de fonte, cor de fonte, cor de fundo e muito mais. Você pode definir a formatação para um intervalo de células, bem como para toda a planilha. Você também pode definir a formatação padrão para a linha e para uma coluna com facilidade. Você pode facilmente adicionar imagens e fotos a uma planilha

func main() {
	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)
}