Introdução

Além de criar e estilizar pastas de trabalho, a maior parte do código de planilhas do dia a dia passa seu tempo lendo e gravando valores de células, anexando fórmulas e movendo dados entre XLSX e CSV. Aspose.Cells FOSS for Go cobre os três através dos tipos Workbook e Cells.

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 percorre a leitura/gravação de células, fórmulas, conversão CSV e remoção de células.

Recursos Principais

Criar uma Pasta de Trabalho e Escrever Células

NewWorkbook() retorna uma pasta de trabalho com uma planilha já presente. Escreva valores com Cells().Set(ref, value):

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

ws.Cells().Set("A1", "Item")
ws.Cells().Set("B1", "Category")
ws.Cells().Set("C1", "Price")
ws.Cells().Set("A2", "Widget A")
ws.Cells().Set("B2", "Gadgets")
ws.Cells().Set("C2", 12.99)

wb.Save("inventory.xlsx")

Ler Células de Volta

Cells().Get(ref) devolve o *Cell para uma referência junto com um erro se a referência for inválida:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
ws.Cells().Set("C2", 12.99)

cell, err := ws.Cells().Get("C2")
if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}
fmt.Printf("C2 = %v\n", cell.Value)

Use Cells().All() para enumerar todas as células preenchidas na coleção quando precisar iterar sobre a planilha inteira.

Adicionar uma Fórmula

Cell.SetFormula armazena uma string de fórmula em uma célula. Crie a célula primeiro com Set, depois anexe a fórmula — a fórmula é avaliada pelo Excel ou LibreOffice ao abrir, não pela biblioteca:

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

ws.Cells().Set("D2", nil)
cell, _ := ws.Cells().Get("D2")
cell.SetFormula("C2*2")

Conversão CSV

Workbook.ExportToCSV grava um índice de planilha especificado em um arquivo CSV com o delimitador de sua escolha; Workbook.ImportFromCSV lê um arquivo CSV em uma planilha nomeada:

wb := cells_foss.NewWorkbook()

if err := wb.ExportToCSV(0, "inventory.csv", ','); err != nil {
	fmt.Printf("Error exporting: %v\n", err)
	return
}

Remover uma Célula

Cells().Remove(ref) limpa o valor de uma célula:

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
ws.Cells().Set("A2", "Widget A")

if err := ws.Cells().Remove("A2"); err != nil {
	fmt.Printf("Error removing cell: %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 — construa uma pequena tabela de valores e exporte-a para CSV:

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", "Item")
	ws.Cells().Set("B1", "Price")
	ws.Cells().Set("A2", "Widget A")
	ws.Cells().Set("B2", 12.99)

	if err := wb.ExportToCSV(0, "inventory.csv", ','); err != nil {
		fmt.Printf("Error exporting: %v\n", err)
		return
	}
	fmt.Println("Exported inventory.csv")
}

Formatos suportados

FormatoExtensãoLerEscrever
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, nenhuma taxa de tempo de execução e nenhum requisito 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.

Começando

Recursos Relacionados