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

Aspose.Cells FOSS para Go

Crie, modifique e exporte planilhas Excel a partir do Go — gratuito e de código aberto, sem dependências externas.

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

Documentação GitHub

Biblioteca Go de Código Aberto para Planilhas Excel

Aspose.Cells FOSS for Go é uma biblioteca gratuita e de código aberto para trabalhar com arquivos de planilhas Excel em aplicações Go. Instale-a com go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 e comece a criar pastas de trabalho, ler e gravar células, aplicar estilos, adicionar validação de dados e exportar para CSV, sem precisar do Microsoft Excel ou de qualquer dependência do Office.

A biblioteca expõe um pequeno e idiomático API Go construído em torno de Workbook, Worksheet, Cells e Cell. Acesse células através da coleção Cells() com Get/Set/Remove, agrupe formatação em objetos reutilizáveis Style construídos a partir de Font, Fill, Alignment e Border, e construa intervalos Table estruturados com uma linha de cabeçalho e estilo de tabela nomeado. Um StreamingReader dedicado lê pastas de trabalho .xlsx linha por linha via um callback, permitindo que arquivos grandes sejam processados sem carregar a planilha inteira na memória.

go.mod não declara dependências externas — a biblioteca é construída inteiramente sobre a biblioteca padrão do Go. Ela tem licença MIT, está hospedada no GitHub e é instalada com um único comando go get; sem cgo, sem bibliotecas nativas do Office e sem pacotes de sistema para configurar. Para a família de produtos empresariais, veja Aspose.Cells — Enterprise Product Family.

Ler e Escrever Arquivos Excel

  • Acesso a células: Leia e escreva valores com Cells().Get(ref) / Cells().Set(ref, value).
  • Fórmulas: Cell.SetFormula/GetFormula armazenam uma string de fórmula na célula — avaliada pelo Excel ou LibreOffice ao abrir, não pela biblioteca no momento da gravação.
  • Interop CSV: Workbook.ExportToCSV/ImportFromCSV e Worksheet.ToCSV/FromCSV convertem entre XLSX e CSV.
  • Leitura em streaming: StreamingReader.ProcessRows transmite uma planilha linha por linha via um callback, para processamento de arquivos grandes sem carregar toda a planilha na memória.
  • Proteção por senha: Workbook.SetPassword/VerifyPassword protegem e verificam senhas da pasta de trabalho.

Onde Aspose.Cells FOSS Pode Ser Usado

  • Data pipelines: Exportar resultados de consultas ao banco de dados diretamente para XLSX ou CSV.
  • Report generation: Construir relatórios Excel com estilo a partir de um serviço backend em Go.
  • Large-file processing: Transmitir planilhas com milhares de linhas usando StreamingReader em vez de carregá-las totalmente na memória.
  • ETL workflows: Ler planilhas de entrada, transformar dados e gravar planilhas de saída.
  • CI/CD automation: Gerar artefatos de planilhas dentro de pipelines de construção baseados em Go e contêineres Docker.

Estilização, Validação de Dados e Tabelas

  • Objetos de estilo: Agrupe Font (name, size, bold, italic, color), Fill (type, color), Alignment (horizontal, vertical, wrap text) e Border (top/bottom/left/right, color) em um Style reutilizável, aplicado com Cell.SetStyle.
  • Validação de dados: Worksheet.AddDataValidation anexa regras de validação de lista e intervalo de número inteiro, cada uma com um título de erro personalizado, mensagem e estilo de erro.
  • Tabelas: Worksheet.AddTable/GetTable criam um intervalo Table estruturado com uma linha de cabeçalho opcional e um estilo de tabela nomeado.
  • Imagens: Worksheet.AddPicture incorpora uma imagem Picture com posicionamento SetAnchor(row, col).

Experiência do desenvolvedor

Aspose.Cells FOSS for Go instala com um único comando go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. go.mod não tem entradas require — não há dependências externas para analisar ou vendor.

A interface API foi projetada intencionalmente compacta: Workbook, Worksheet, Cells, Cell, Style e um conjunto de tipos de suporte cobrem a criação de planilhas, estilização, validação e I/O CSV/streaming. O código-fonte tem licença MIT e está hospedado no GitHub.

Criar um Workbook e Escrever Células

Instale com go get, crie uma Workbook, acesse a primeira Worksheet e escreva valores diretamente nas células através da coleção Cells() antes de salvar.

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

Adicionar Regras de Validação de Dados

Anexe uma validação do tipo lista (um menu suspenso de valores permitidos) e uma validação de intervalo de número inteiro a duas colunas diferentes, cada uma com seu próprio título e mensagem de erro.

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 Grandes Pastas de Trabalho Linha a Linha

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

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

Perguntas Frequentes

Qual é o modelo de licenciamento para Aspose.Cells FOSS for Go?

Aspose.Cells FOSS for Go é lançado sob a Licença MIT, que permite uso comercial e de código aberto.

Posso usá-lo em produtos comerciais?

Sim. A Licença MIT permite uso comercial sem obrigação de divulgar seu próprio código-fonte, desde que o aviso de direitos autorais original seja mantido.

Como faço para instalar Aspose.Cells FOSS for Go?

Adicione-o como uma dependência de módulo Go com go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26. Requer Go 1.24 ou posterior.

Existem dependências externas?

Não. go.mod declara nenhuma entrada require — a biblioteca é construída inteiramente sobre a biblioteca padrão do Go.

Posso processar pastas de trabalho grandes sem carregá-las totalmente na memória?

Sim. StreamingReader.ProcessRows lê uma planilha linha por linha por meio de um callback, evitando um carregamento completo na memória.

  

Recursos de Suporte e Aprendizado

 Português