Célula

RichTextRun mapeia diretamente as configurações da execução de rich text.

type RichTextRun struct {
    Font *Font
    Text string
}

HyperlinkOpts pode ser passado para SetCellHyperlink definir atributos de hiperlink opcionais (por exemplo, texto a ser exibido e texto de dica de tela).

type HyperlinkOpts struct {
    Display *string
    Tooltip *string
}

FormulaOpts pode ser passado para SetCellFormula para usar outros tipos de fórmula.

type FormulaOpts struct {
    Type *string // Tipo de fórmula
    Ref  *string // Referência de fórmula compartilhada
}

Definir valor da célula

func (f *File) SetCellValue(sheet, cell string, value interface{}) error

SetCellValue fornece uma função para definir o valor de uma célula. Esta função é segura para simultaneidade. As coordenadas especificadas não devem estar na primeira linha da tabela; um número complexo pode ser definido com uma string de texto. Veja a seguir os tipos de dados suportados:

Observe que o formato de data padrão é m/d/yy h:mm do valor do tipo time.Time. Você pode definir o formato dos números pela função SetCellStyle. Se você precisar definir a data especializada no Excel como 0 de janeiro de 1900 ou 29 de fevereiro de 1900, esses horários não podem ser representados no tipo de dados time.Time da linguagem Go. Defina o valor da célula como número 0 ou 60 e, em seguida, crie e vincule o estilo de formato numérico de data e hora para a célula.

Definir valor booleano

func (f *File) SetCellBool(sheet, cell string, value bool) error

SetCellBool fornece uma função para definir o valor do tipo bool de uma célula por determinado nome de planilha, referência de célula e valor de célula.

Definir valor RAW

func (f *File) SetCellDefault(sheet, cell, value string) error

SetCellDefault fornece uma função para definir o valor do tipo string de uma célula como formato padrão sem escapar da célula.

Definir valor inteiro

func (f *File) SetCellInt(sheet, cell string, value int64) error

SetCellInt fornece uma função para definir o valor do tipo int64 de uma célula por determinado nome de planilha, referência de célula e valor de célula.

Definir valor inteiro sem sinal

func (f *File) SetCellUint(sheet, cell string, value uint64) error

SetCellUint fornece uma função para definir o valor do tipo de dados inteiro não assinado de uma célula por determinado nome de planilha, referência de célula e valor de célula.

Definir valor de ponto flutuante

func (f *File) SetCellFloat(sheet, cell string, value float64, precision, bitSize int) error

SetCellFloat define um valor de ponto flutuante em uma célula. O parâmetro precision especifica quantas casas decimais serão mostradas após o decimal, enquanto -1 é um valor especial que usará quantas casas decimais forem necessárias para representar o número. bitSize é 32 ou 64 dependendo se float32 ou float64 foi originalmente usado para o valor.

Definir valor da string

func (f *File) SetCellStr(sheet, cell, value string) error

SetCellStr fornece uma função para definir o valor do tipo string de uma célula. O número total de caracteres que uma célula pode conter 32767 caracteres.

Definir estilo de célula

func (f *File) SetCellStyle(sheet, topLeftCell, bottomRightCell string, styleID int) error

SetCellStyle fornece uma função para adicionar atributos de estilo para células por determinado nome de planilha, referência de intervalo e ID de estilo. Esta função é segura para simultaneidade. Os índices de estilo podem ser obtidos com a função NewStyle. Observe que as bordas do tipo diagonalDown e diagonalUp devem usar a mesma cor no mesmo intervalo. SetCellStyle substituirá os estilos existentes na célula, não anexará ou mesclará o estilo com os estilos existentes.

• Exemplo 1, crie bordas da célula D7 em Planilha1:

style, err := f.NewStyle(&excelize.Style{
    Border: []excelize.Border{
        {Type: "left", Color: "0000FF", Style: 3},
        {Type: "top", Color: "00FF00", Style: 4},
        {Type: "bottom", Color: "FFFF00", Style: 5},
        {Type: "right", Color: "FF0000", Style: 6},
        {Type: "diagonalDown", Color: "A020F0", Style: 8},
        {Type: "diagonalUp", Color: "A020F0", Style: 8},
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

As quatro bordas da célula D7 são definidas com diferentes estilos e cores. Isso está relacionado aos parâmetros ao chamar a função NewStyle. Você precisa definir estilos diferentes para consultar a documentação desse capítulo.

• Exemplo 2, definindo o estilo de gradiente para a célula D7 da planilha chamada Planilha1:

style, err := f.NewStyle(&excelize.Style{
    Fill: excelize.Fill{Type: "gradient", Color: []string{"FFFFFF", "E0EBF5"}, Shading: 1},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

A célula D7 é definida com o preenchimento de cor do efeito gradiente. O efeito de preenchimento gradiente está relacionado ao parâmetro quando a função NewStyle é chamada. Você precisa definir estilos diferentes para consultar a documentação deste capítulo.

• Exemplo 3, defina um preenchimento sólido para a célula D7 chamada Planilha1:

style, err := f.NewStyle(&excelize.Style{
    Fill: excelize.Fill{Type: "pattern", Color: []string{"E0EBF5"}, Pattern: 1},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

A célula D7 é definida com um preenchimento sólido.

• Exemplo 4, defina o espaçamento dos caracteres e o ângulo de rotação para a célula D7 chamada Planilha1:

f.SetCellValue("Planilha1", "D7", "Estilo")
style, err := f.NewStyle(&excelize.Style{
    Alignment: &excelize.Alignment{
        Horizontal:      "center",
        Indent:          1,
        JustifyLastLine: true,
        ReadingOrder:    0,
        RelativeIndent:  1,
        ShrinkToFit:     true,
        TextRotation:    45,
        Vertical:        "",
        WrapText:        true,
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

• Exemplo 5, a data e hora no Excel são representadas por números reais, por exemplo 2017/7/4 12:00:00 PM pode ser representado pelo número 42920.5. Defina o formato da hora para a célula D7 da planilha chamada Planilha1:

f.SetCellValue("Planilha1", "D7", 42920.5)
f.SetColWidth("Planilha1", "D", "D", 13)
style, err := f.NewStyle(&excelize.Style{NumFmt: 22})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

A célula D7 está definida para o formato de hora. Observe que quando a largura da célula com o formato de hora aplicado for muito estreita para ser totalmente exibida, ela será exibida como ####, você pode arrastar e soltar a largura da coluna ou definir a coluna para o tamanho apropriado chamando o comando Função SetColWidth para torná-la exibição normal.

• Exemplo 6, definindo a fonte, o tamanho da fonte, a cor e o estilo de inclinação para a célula da planilha D7 chamada Planilha1:

f.SetCellValue("Planilha1", "D7", "Excel")
style, err := f.NewStyle(&excelize.Style{
    Font: &excelize.Font{
        Bold:   true,
        Italic: true,
        Family: "Times New Roman",
        Size:   36,
        Color:  "777777",
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

• Exemplo 7, bloqueando e ocultando a célula D7 da planilha chamada Planilha1:

style, err := f.NewStyle(&excelize.Style{
    Protection: &excelize.Protection{
        Hidden: true,
        Locked: true,
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

Para bloquear uma célula ou ocultar uma fórmula, proteja a planilha. Na aba “Revisão”, clique em “Proteger Planilha”.

Definir hiperlink

func (f *File) SetCellHyperLink(sheet, cell, link, linkType string, opts ...HyperlinkOpts) error

SetCellHyperLink fornece uma função para definir hiperlinks de células por determinado nome de planilha e endereço URL do link. LinkType define dois tipos de hiperlinks External para o site ou Location para mover para uma das células desta pasta de trabalho. O limite máximo de hiperlinks em uma planilha é 65530. Esta função é usada apenas para definir o hiperlink da célula e não afeta o valor da célula. Se você precisar definir o valor da célula, use outras funções como SetCellStyle ou SetSheetRow. Abaixo está um exemplo de link externo.

• Exemplo 1, adicionando um link externo à célula A3 da planilha chamada Planilha1:

display, tooltip := "https://github.com/xuri/excelize", "Excelize on GitHub"
if err := f.SetCellHyperLink("Planilha1", "A3",
    "https://github.com/xuri/excelize", "External", excelize.HyperlinkOpts{
        Display: &display,
        Tooltip: &tooltip,
    }); err != nil {
    fmt.Println(err)
}
// Set the font and underline style for the cell
style, err := f.NewStyle(&excelize.Style{
    Font: &excelize.Font{Color: "1265BE", Underline: "single"},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "A3", "A3", style)

• Exemplo 2, adicionando um link de localização interno à célula A3 chamada Planilha1:

err := f.SetCellHyperLink("Planilha1", "A3", "Planilha1!A40", "Location")

Definir rich text da célula

func (f *File) SetCellRichText(sheet, cell string, runs []RichTextRun) error

SetCellRichText fornece uma função para definir uma célula com rich text por determinada planilha.

Por exemplo, defina rich text na célula A1 da planilha chamada Planilha1:

package main

import (
    "fmt"

    "github.com/xuri/excelize/v2"
)

func main() {
    f := excelize.NewFile()
    defer func() {
        if err := f.Close(); err != nil {
            fmt.Println(err)
        }
    }()
    if err := f.SetSheetName("Sheet1", "Planilha1"); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetRowHeight("Planilha1", 1, 35); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetColWidth("Planilha1", "A", "A", 48); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetCellRichText("Planilha1", "A1", []excelize.RichTextRun{
        {
            Text: "texto em negrito",
            Font: &excelize.Font{
                Bold:   true,
                Color:  "2354E8",
                Family: "Times New Roman",
            },
        },
        {
            Text: " e ",
            Font: &excelize.Font{
                Family: "Times New Roman",
            },
        },
        {
            Text: "itálico ",
            Font: &excelize.Font{
                Bold:   true,
                Color:  "E83723",
                Italic: true,
                Family: "Times New Roman",
            },
        },
        {
            Text: "com cor e família de fontes,",
            Font: &excelize.Font{
                Bold:   true,
                Color:  "2354E8",
                Family: "Times New Roman",
            },
        },
        {
            Text: "\r\nltexto grande com ",
            Font: &excelize.Font{
                Size:  14,
                Color: "AD23E8",
            },
        },
        {
            Text: "tachado",
            Font: &excelize.Font{
                Color:  "E89923",
                Strike: true,
            },
        },
        {
            Text: " sobrescrito",
            Font: &excelize.Font{
                Color:     "DBC21F",
                VertAlign: "superscript",
            },
        },
        {
            Text: " e ",
            Font: &excelize.Font{
                Size:      14,
                Color:     "AD23E8",
                VertAlign: "baseline",
            },
        },
        {
            Text: "sublinhado",
            Font: &excelize.Font{
                Color:     "23E833",
                Underline: "single",
            },
        },
        {
            Text: " subscrito.",
            Font: &excelize.Font{
                Color:     "017505",
                VertAlign: "subscript",
            },
        },
    }); err != nil {
        fmt.Println(err)
        return
    }
    style, err := f.NewStyle(&excelize.Style{
        Alignment: &excelize.Alignment{
            WrapText: true,
        },
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetCellStyle("Planilha1", "A1", "A1", style); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SaveAs("Pasta1.xlsx"); err != nil {
        fmt.Println(err)
    }
}

Obtenha rich text de célula

func (f *File) GetCellRichText(sheet, cell string) ([]RichTextRun, error)

GetCellRichText fornece uma função para obter o rich text das células de uma determinada planilha.

Obtenha o valor da célula

func (f *File) GetCellValue(sheet, cell string, opts ...Options) (string, error)

GetCellValue fornece uma função para obter o valor formatado da célula por determinado nome da planilha e referência de célula na planilha. O valor de retorno é convertido para o tipo string. Esta função é segura para simultaneidade. Se o formato da célula puder ser aplicado ao valor de uma célula, o valor aplicado será retornado, caso contrário, o valor original será retornado. Os valores de todas as células serão iguais em um intervalo mesclado.

Obtenha o tipo de célula

func (f *File) GetCellType(sheet, cell string) (CellType, error)

GetCellType fornece uma função para obter o tipo de dados da célula por meio do nome da planilha e da referência da célula no arquivo de planilha.

Obtenha todos os valores das células por colunas

func (f *File) GetCols(sheet string, opts ...Options) ([][]string, error)

GetCols obtém o valor de todas as células por colunas da planilha com base no nome da planilha fornecido, retornado como um array bidimensional, onde o valor da célula é convertido para o tipo string. Se o formato da célula puder ser aplicado ao valor da célula, o valor aplicado será usado, caso contrário, o valor original será usado.

Por exemplo, obtenha e percorra o valor de todas as células por colunas em uma planilha chamada Planilha1:

cols, err := f.GetCols("Planilha1")
if err != nil {
    fmt.Println(err)
    return
}
for _, col := range cols {
    for _, rowCell := range col {
        fmt.Print(rowCell, "\t")
    }
    fmt.Println()
}

Obtenha todos os valores das células por linhas

func (f *File) GetRows(sheet string, opts ...Options) ([][]string, error)

GetRows retorna todas as linhas de uma planilha por determinado nome de planilha, retornado como um array bidimensional, onde o valor da célula é convertido para o tipo string. Se o formato da célula puder ser aplicado ao valor da célula, o valor aplicado será usado, caso contrário, o valor original será usado. GetRows buscou as linhas com células de valor ou fórmula, as células continuamente em branco no final de cada linha serão ignoradas, portanto, o comprimento de cada linha pode ser inconsistente.

Por exemplo, obtenha e percorra o valor de todas as células por linhas em uma planilha chamada Planilha1:

rows, err := f.GetRows("Planilha1")
if err != nil {
    fmt.Println(err)
    return
}
for _, row := range rows {
    for _, colCell := range row {
        fmt.Print(colCell, "\t")
    }
    fmt.Println()
}

Obter células com hiperlink

func (f *File) GetHyperLinkCells(sheet, linkType string) ([]string, error)

GetHyperLinkCells retorna referências de células que contêm hiperlinks em um nome de planilha e tipo de link fornecidos. O parâmetro opcional linkType é usado para um tipo de link específico, os valores opcionais são External para links de sites, Location para mover para uma das células desta pasta de trabalho, None para nenhum link. Se linkType estiver vazio, ele retornará todos os hiperlinks na planilha.

Obter hiperlink

func (f *File) GetCellHyperLink(sheet, cell string) (bool, string, error)

GetCellHyperLink obtém um hiperlink de célula com base no nome da planilha e na referência de célula fornecidos. Se a célula tiver um hiperlink, ela retornará true e o endereço do link, caso contrário retornará false e um endereço de link vazio.

Por exemplo, obtenha um hiperlink para uma célula H6 em uma planilha chamada Planilha1:

link, target, err := f.GetCellHyperLink("Planilha1", "H6")

Obtenha índice de estilo

func (f *File) GetCellStyle(sheet, cell string) (int, error)

O índice de estilo de célula é obtido a partir do nome da planilha e da referência de célula fornecidos, e o índice obtido pode ser usado como parâmetro para chamar a função SetCellStyle ao copiar o estilo de célula.

Mesclar células

func (f *File) MergeCell(sheet, topLeftCell, bottomRightCell string) error

MergeCell fornece uma função para mesclar células por referência de intervalo e nome de planilha. A mesclagem de células mantém apenas o valor da célula superior esquerda e descarta os outros valores. Por exemplo, mescle células na área D3:E9 em uma planilha chamada Planilha1:

err := f.MergeCell("Planilha1", "D3", "E9")

Se você criar uma célula mesclada que se sobreponha a outra célula mesclada existente, as células mescladas que já existem serão removidas.

Desfazer a mesclagem de células

func (f *File) UnmergeCell(sheet, topLeftCell, bottomRightCell string) error

UnmergeCell fornece uma função para desfazer a mesclagem de uma determinada referência de intervalo. Por exemplo, desmembrar a área D3:E9 em Planilha1:

err := f.UnmergeCell("Planilha1", "D3", "E9")

Atenção: as áreas sobrepostas também não serão mescladas.

Obtenha células mescladas

func (f *File) GetMergeCells(sheet string, withoutValues ...bool) ([]MergeCell, error)

GetMergeCells fornece uma função para obter todas as células mescladas de uma planilha específica. Se o parâmetro withoutValues for definido como true, ele não retornará os valores das células mescladas, apenas a referência do intervalo. Por exemplo, obtenha todas as células mescladas em Sheet1:

mergeCells, err := f.GetMergeCells("Sheet1")

Se você quiser obter células mescladas sem valores de célula, use o seguinte código:

mergeCells, err := f.GetMergeCells("Sheet1", true)

Obtenha o valor da célula mesclada

func (m *MergeCell) GetCellValue() string

GetCellValue retorna o valor da célula mesclada.

Obtenha a referência da célula superior esquerda do intervalo mesclado

func (m *MergeCell) GetStartAxis() string

GetStartAxis retorna a referência de célula superior esquerda do intervalo mesclado, por exemplo: C2.

Obtenha a referência da célula inferior direita do intervalo mesclado

func (m *MergeCell) GetEndAxis() string

GetEndAxis retorna a referência de célula inferior direita do intervalo mesclado, por exemplo: D4.

Obtenha células de imagem

func (f *File) GetPictureCells(sheet string) ([]string, error)

GetPictureCells retorna todas as referências de células de imagem em uma planilha por um nome de planilha específico.

Adicionar comentário

func (f *File) AddComment(sheet string, comment Comment) error

O método AddComment permite adicionar comentários em uma planilha, especificando o índice da planilha, a célula e o formato (como autor e texto). Observe que o comprimento máximo do autor é 255 e o comprimento máximo do texto é 32512, e cada célula pode conter apenas um comentário. Um erro será retornado se um comentário for adicionado a uma célula que já contenha um comentário. Por exemplo, para adicionar um comentário em Planilha1!$A$3:

err := f.AddComment("Planilha1", excelize.Comment{
    Cell:   "A3",
    Author: "Excelize",
    Paragraph: []excelize.RichTextRun{
        {Text: "Excelize: ", Font: &excelize.Font{Bold: true}},
        {Text: "Este é um comentário."},
    },
})

Obter comentário

func (f *File) GetComments(sheet string) ([]Comment, error)

GetComments recupera todos os comentários em uma planilha por determinado nome de planilha.

Excluir comentário

func (f *File) DeleteComment(sheet, cell string) error

DeleteComment fornece o método para excluir comentários em uma planilha por determinado nome de planilha. Por exemplo, exclua o comentário em Sheet1!$A$30:

err := f.DeleteComment("Sheet1", "A30")

Adicionar erros ignorados

func (f *File) AddIgnoredErrors(sheet, rangeRef string, ignoredErrorsType IgnoredErrorsType) error

AddIgnoredErrors fornece o método para ignorar erro para um intervalo de células. Por exemplo: ignorar erro "número armazenado como texto" em Sheet1 para intervalo de células D15 C18:D19:

err := f.AddIgnoredErrors("Sheet1", "D15 C18:D19", excelize.IgnoredErrorsNumberStoredAsText)

Definir fórmula de célula

func (f *File) SetCellFormula(sheet, cell, formula string, opts ...FormulaOpts) error

SetCellFormula fornece uma função para definir a fórmula na célula de acordo com o nome da planilha fornecido e as configurações da fórmula da célula. O resultado da célula da fórmula pode ser calculado quando a planilha é aberta pelo aplicativo Office Excel ou pode usar a função CalcCellValue também pode obter o valor calculado da célula. Se o aplicativo Excel não calcular a fórmula automaticamente quando a pasta de trabalho for aberta, chame UpdateLinkedValue após definir as funções da fórmula da célula.

• Exemplo 1, defina a fórmula normal =SUM(A1,B1) para a célula A3 em Planilha1:

err := f.SetCellFormula("Planilha1", "A3", "SUM(A1,B1)")

• Exemplo 2, defina a fórmula 1;2;3 de matriz constante vertical unidimensional (matriz de coluna) para a célula A3 em Planilha1:

err := f.SetCellFormula("Planilha1", "A3", "{1;2;3}")

• Exemplo 3, defina a fórmula de array constante horizontal unidimensional (matriz de linha) "a","b","c" para a célula A3 em Planilha1:

err := f.SetCellFormula("Planilha1", "A3", "{\"a\",\"b\",\"c\"}")

• Exemplo 4, defina a fórmula de matriz de constante bidimensional {1,2;"a","b"} para a célula A3 no Planilha1:

formulaType, ref := excelize.STCellFormulaTypeArray, "A3:A3"
err := f.SetCellFormula("Planilha1", "A3", "{1,2;\"a\",\"b\"}",
    excelize.FormulaOpts{Ref: &ref, Type: &formulaType})

• Exemplo 5, defina a fórmula de matriz de intervalo A1:A2 para a célula A3 em Planilha1:

formulaType, ref := excelize.STCellFormulaTypeArray, "A3:A3"
err := f.SetCellFormula("Planilha1", "A3", "A1:A2",
    excelize.FormulaOpts{Ref: &ref, Type: &formulaType})

• Exemplo 6, defina a fórmula compartilhada =A1+B1 para as células C1:C5 na Planilha1, C1 é a célula mestre:

formulaType, ref := excelize.STCellFormulaTypeShared, "C1:C5"
err := f.SetCellFormula("Planilha1", "C1", "A1+B1",
    excelize.FormulaOpts{Ref: &ref, Type: &formulaType})

• Exemplo 7, defina a fórmula da tabela =SUM(Tabela1[[A]:[B]]) para a célula C2 no Planilha1:

package main

import (
    "fmt"

    "github.com/xuri/excelize/v2"
)

func main() {
    f := excelize.NewFile()
    defer func() {
        if err := f.Close(); err != nil {
            fmt.Println(err)
        }
    }()
    if err := f.SetSheetName("Sheet1", "Planilha1"); err != nil {
        fmt.Println(err)
        return
    }
    for idx, row := range [][]interface{}{{"A", "B", "C"}, {1, 2}} {
        if err := f.SetSheetRow("Planilha1", fmt.Sprintf("A%d", idx+1), &row); err != nil {
            fmt.Println(err)
            return
        }
    }
    if err := f.AddTable("Planilha1",
        &excelize.Table{
            Range:     "A1:C2",
            Name:      "Tabela1",
            StyleName: "TableStyleMedium2",
        }); err != nil {
        fmt.Println(err)
        return
    }
    formulaType := excelize.STCellFormulaTypeDataTable
    if err := f.SetCellFormula("Planilha1", "C2", "SUM(Tabela1[[A]:[B]])",
        excelize.FormulaOpts{Type: &formulaType}); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SaveAs("Pasta1.xlsx"); err != nil {
        fmt.Println(err)
    }
}

Obtenha a fórmula da célula

func (f *File) GetCellFormula(sheet, cell string) (string, error)

GetCellFormula fornece uma função para obter fórmulas de células por determinado nome de planilha e referência de célula na planilha.

Calcular o valor da célula

func (f *File) CalcCellValue(sheet, cell string, opts ...Options) (string, error)

CalcCellValue fornece uma função para obter o valor calculado da célula. Este recurso está atualmente em processamento funcional. Cálculo iterativo, interseção implícita, interseção explícita, fórmula de matriz, fórmula de tabela e algumas outras fórmulas não são suportadas atualmente.

Fórmulas suportadas: