1. Produtos
  2.   Planilha
  3.   GO
  4.   Excelize  

Excelize  

 
 

Biblioteca Go de código aberto para planilhas

Leia, crie, mescle e filtre dados em arquivos de planilha Excel XLSX / XLSM / XLTM por meio da API Go.

Excelize é uma biblioteca Go pura de código aberto que fornece funcionalidade para leitura e gravação de arquivos de planilha do Microsoft Excel XLSX / XLSM / XLTM. Os desenvolvedores podem ler e escrever documentos de planilha gerados pelo Microsoft Excel™ 2007 e posterior dentro de seus próprios aplicativos. A biblioteca é muito fácil de usar e suporta a leitura de grandes arquivos de planilhas. Ele forneceu uma API de streaming para gerar ou ler dados de uma planilha com grandes quantidades de dados.

A biblioteca oferece suporte completo a vários recursos importantes relacionados à manipulação e processamento de arquivos de planilha do Excel, como leitura e gravação de arquivos do Excel, trabalho com intervalos de células, gerenciamento de linhas do Excel, adição de comentários, mesclagem de células, cópia de linhas, formatação condicional, inserção de textos, gerenciamento de tabelas em arquivos do Excel, adicione imagens, adicione novas planilhas e muito mais.

Previous Next

Introdução ao Excelize

A maneira recomendada de instalar o Excelize é do GitHub, use o seguinte comando para uma instalação mais rápida.

Instalar por meio do comando GitHub

 go get github.com/360EntSecGroup-Skylar/excelize 

Gerar arquivo Excel XLSX via biblioteca Go

O Excelize permite que os programadores gerem uma planilha Excel XLSX dentro de seus próprios aplicativos Go. Depois de criar a planilha, você também pode criar uma nova planilha, definir o valor de uma célula, definir o número de linhas e colunas, definir uma planilha ativa da pasta de trabalho e muito mais. Você também pode atribuir um nome a uma planilha e salvar o arquivo no caminho de sua escolha, definir o tipo de fonte e o tamanho do texto para uma planilha criada. 

Criar arquivo LS do Excel via Go API

package main
import (
    "fmt"
    "github.com/xuri/excelize/v2"
)
func main() {
    f := excelize.NewFile()
    // Create a new sheet.
    index := f.NewSheet("Sheet2")
    // Set value of a cell.
    f.SetCellValue("Sheet2", "A2", "Hello world.")
    f.SetCellValue("Sheet1", "B2", 100)
    // Set active sheet of the workbook.
    f.SetActiveSheet(index)
    // Save spreadsheet by the given path.
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}

Inserir gráfico em um arquivo XLSX

Gráficos do Excel são representações visuais de dados de uma planilha que podem transmitir mais compreensão dos dados resumindo grandes quantidades de dados em uma pequena seção de sua planilha. Os gráficos permitem que os usuários exibam visualmente os dados em diferentes formatos, como Barra, Coluna, Pizza, Linha, Área ou Radar, etc. A biblioteca Excelize suporta a geração de gráficos, bem como o controle com apenas algumas linhas de código dentro de seus próprios aplicativos. Permite construir gráficos com base em dados de uma planilha ou gerar gráficos sem nenhum dado.

Adicionar Gráfico para Excel Planilha File via Go API

package main
import (
    "fmt"
    "github.com/xuri/excelize/v2"
)
func main() {
    categories := map[string]string{
        "A2": "Small", "A3": "Normal", "A4": "Large",
        "B1": "Apple", "C1": "Orange", "D1": "Pear"}
    values := map[string]int{
        "B2": 2, "C2": 3, "D2": 3, "B3": 5, "C3": 2, "D3": 4, "B4": 6, "C4": 7, "D4": 8}
    f := excelize.NewFile()
    for k, v := range categories {
        f.SetCellValue("Sheet1", k, v)
    }
    for k, v := range values {
        f.SetCellValue("Sheet1", k, v)
    }
    if err := f.AddChart("Sheet1", "E1", `{
        "type": "col3DClustered",
        "series": [
        {
            "name": "Sheet1!$A$2",
            "categories": "Sheet1!$B$1:$D$1",
            "values": "Sheet1!$B$2:$D$2"
        },
        {
            "name": "Sheet1!$A$3",
            "categories": "Sheet1!$B$1:$D$1",
            "values": "Sheet1!$B$3:$D$3"
        },
        {
            "name": "Sheet1!$A$4",
            "categories": "Sheet1!$B$1:$D$1",
            "values": "Sheet1!$B$4:$D$4"
        }],
        "title":
        {
            "name": "Fruit 3D Clustered Column Chart"
        }
    }`); err != nil {
        fmt.Println(err)
        return
    }
    // Save spreadsheet by the given path.
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}

Criando tabela dinâmica em arquivo do Excel

O Excelize oferece a capacidade de criar uma tabela dinâmica dentro de uma planilha do Excel com facilidade. As tabelas dinâmicas são um dos recursos mais poderosos do Microsoft Excel. É uma ferramenta poderosa para calcular, resumir e analisar seus dados em uma planilha do Excel. Você pode criar uma tabela dinâmica simples usando a função AddPivotTable. Além disso, você pode atribuir ou editar facilmente a fonte de dados a uma tabela dinâmica.

Gerar PivotTable no arquivo Excel dentro de Go Apps

func main() {
    f := excelize.NewFile()
    // Create some data in a sheet
    month := []string{"Jan", "Feb", "Mar", "Apr", "May",
        "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}
    year := []int{2017, 2018, 2019}
    types := []string{"Meat", "Dairy", "Beverages", "Produce"}
    region := []string{"East", "West", "North", "South"}
    f.SetSheetRow("Sheet1", "A1", &[]string{"Month", "Year", "Type", "Sales", "Region"})
    for row := 2; row < 32; row++ {
        f.SetCellValue("Sheet1", fmt.Sprintf("A%d", row), month[rand.Intn(12)])
        f.SetCellValue("Sheet1", fmt.Sprintf("B%d", row), year[rand.Intn(3)])
        f.SetCellValue("Sheet1", fmt.Sprintf("C%d", row), types[rand.Intn(4)])
        f.SetCellValue("Sheet1", fmt.Sprintf("D%d", row), rand.Intn(5000))
        f.SetCellValue("Sheet1", fmt.Sprintf("E%d", row), region[rand.Intn(4)])
    }
    if err := f.AddPivotTable(&excelize.PivotTableOptions{
        DataRange:       "Sheet1!$A$1:$E$31",
        PivotTableRange: "Sheet1!$G$2:$M$34",
        Rows: []excelize.PivotTableField{
            {Data: "Month", DefaultSubtotal: true}, {Data: "Year"}},
        Filter: []excelize.PivotTableField{
            {Data: "Region"}},
        Columns: []excelize.PivotTableField{
            {Data: "Type", DefaultSubtotal: true}},
        Data: []excelize.PivotTableField{
            {Data: "Sales", Name: "Summarize", Subtotal: "Sum"}},
        RowGrandTotals: true,
        ColGrandTotals: true,
        ShowDrill:      true,
        ShowRowHeaders: true,
        ShowColHeaders: true,
        ShowLastColumn: true,
    }); err != nil {
        fmt.Println(err)
    }
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}

Adicionar imagens a planilhas XLSX

A biblioteca Excelize fornece funcionalidade para adicionar imagens a uma planilha Excel XLSX com apenas algumas linhas de comandos Go. Você também pode modificar as imagens de acordo com suas necessidades. Você pode inserir uma imagem com dimensionamento e também com suporte para impressão.

Adicionar Imagem para Excel Planilha File via Go API

package main
import (
    "fmt"
    _ "image/gif"
    _ "image/jpeg"
    _ "image/png"
    "github.com/xuri/excelize/v2"
)
func main() {
    f, err := excelize.OpenFile("Book1.xlsx")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer func() {
        // Close the spreadsheet.
        if err := f.Close(); err != nil {
            fmt.Println(err)
        }
    }()
    // Insert a picture.
    if err := f.AddPicture("Sheet1", "A2", "image.png", ""); err != nil {
        fmt.Println(err)
    }
    // Insert a picture to worksheet with scaling.
    if err := f.AddPicture("Sheet1", "D2", "image.jpg",
        `{"x_scale": 0.5, "y_scale": 0.5}`); err != nil {
        fmt.Println(err)
    }
    // Insert a picture offset in the cell with printing support.
    if err := f.AddPicture("Sheet1", "H2", "image.gif", `{
        "x_offset": 15,
        "y_offset": 10,
        "print_obj": true,
        "lock_aspect_ratio": false,
        "locked": false
    }`); err != nil {
        fmt.Println(err)
    }
    // Save the spreadsheet with the origin path.
    if err = f.Save(); err != nil {
        fmt.Println(err)
    }
}
 Português