Introdução

Aspose.Cells FOSS para Go é uma biblioteca pura-Go para trabalhar com planilhas Excel. Ela expõe um API para criar novas pastas de trabalho do zero, gravar e estilizar valores de células, aplicar regras de validação de dados, construir tabelas estruturadas, incorporar imagens e ler grandes arquivos .xlsx linha por linha — tudo sem dependências nativas de C ou C++.

A biblioteca está disponível como um módulo Go em github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go e é lançada sob a licença MIT. Instale-a com go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 em qualquer projeto Go 1.24+.

Este post aborda as principais funcionalidades: estilização de células, validação de dados, tabelas, imagens e leituras em streaming.

Recursos Principais

Estilização de Células

Agrupe as configurações Font, Fill, Alignment e Border em um Style reutilizável e, em seguida, aplique-o a uma célula com Cell.SetStyle:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]

boldStyle := cells_foss.NewStyle()
boldStyle.Font.Bold = true
boldStyle.Font.Size = 12

cell, _ := ws.Cells().Get("A1")
cell.SetStyle(boldStyle)

Alignment controla Horizontal, Vertical e WrapText; Border controla a visibilidade das regras Top, Bottom, Left e Right, além de Color.

Validação de Dados

Worksheet.AddDataValidation anexa uma regra de validação a um intervalo de células. A estrutura DataValidation contém a regra Type, um ou dois valores Formula e campos de mensagem de erro:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]

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,
}
ws.AddDataValidation("A2:A10", dv)

Tabelas

Worksheet.AddTable cria uma Table estruturada sobre um intervalo, com uma linha de cabeçalho opcional e um estilo de tabela nomeado:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
ws.Cells().Set("A1", "Item")
ws.Cells().Set("B1", "Qty")

tbl := ws.AddTable("A1:B2")
tbl.HasHeaderRow = true
tbl.StyleName = "TableStyleMedium6"

Imagens

Worksheet.AddPicture incorpora uma imagem; Picture.SetAnchor(row, col) a posiciona:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
imageBytes := []byte{} // populate with real image bytes before use

pic := &cells_foss.Picture{Data: imageBytes, Format: "png"}
ws.AddPicture(pic)
pic.SetAnchor(5, 0)

Transmissão de Arquivos Grandes

StreamingReader lê uma planilha linha por linha por meio de um callback, de modo que uma pasta de trabalho com milhares de linhas nunca precisa ser carregada completamente na memória:

sr := cells_foss.NewStreamingReader("large_workbook.xlsx")
err := sr.ProcessRows("Sheet1", func(rowIdx int, cells map[string]string) error {
	// process one row at a time
	return nil
})
if err != nil {
	fmt.Printf("Error streaming: %v\n", err)
}

Início rápido

Instale o módulo:

go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26

Um fluxo de trabalho mínimo — crie uma pasta de trabalho, escreva duas células, negrite o cabeçalho e salve:

package main

import (
	"fmt"

	cells_foss "github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26/aspose/cells_foss"
)

func main() {
	wb := cells_foss.NewWorkbook()
	ws := wb.Worksheets[0]

	ws.Cells().Set("A1", "Product")
	ws.Cells().Set("B1", "Revenue")

	boldStyle := cells_foss.NewStyle()
	boldStyle.Font.Bold = true
	for _, ref := range []string{"A1", "B1"} {
		cell, _ := ws.Cells().Get(ref)
		cell.SetStyle(boldStyle)
	}

	if err := wb.Save("report.xlsx"); err != nil {
		fmt.Printf("Error saving workbook: %v\n", err)
		return
	}
	fmt.Println("Workbook saved to report.xlsx")
}

Formatos suportados

FormatoExtensãoLerGravar
XLSX.xlsx—✓
CSV.csv✓✓

As pastas de trabalho XLSX são construídas na memória com NewWorkbook e gravadas com Workbook.Save. CSV é bidirecional via Workbook.ImportFromCSV e Workbook.ExportToCSV.

Código aberto e licenciamento

Aspose.Cells FOSS para Go é lançado sob a licença MIT. Não há restrições de uso, taxas de tempo de execução ou requisitos de registro. O código-fonte está disponível em github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go.

O uso comercial é permitido sob os termos da licença MIT. Se o seu projeto requer suporte de nível empresarial, cobertura de formatos ampliada ou integração com a nuvem, o Aspose.Cells — Enterprise Product Family é uma oferta comercial separada.

Iniciando

Recursos Relacionados