Célula

O RichTextRun define as propriedades do texto formatado.

type RichTextRun struct {
    Font *Font
    Text string
}

O HyperlinkOpts é usado para especificar as propriedades opcionais de hiperlink, como o texto de exibição e a dica de tela.

type HyperlinkOpts struct {
    Display *string
    Tooltip *string
}

O FormulaOpts é usado para especificar tipos de fórmulas especiais na função SetCellFormula.

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

Definir o valor de uma célula

func (f *Arquivo) SetCellValue(planilha, célula string, valor interface{}) error

Define o valor de uma célula com base no nome da planilha e nas coordenadas da célula fornecidos. Essa função é segura para goroutines. As coordenadas especificadas não devem estar na primeira linha da tabela e caracteres no plural devem ser usados para configuração de texto.

Tipos de dados suportados
int
int8
int16
int32
int64
uint
uint8
uint16
uint32
uint64
float32
float64
string
[]byte
time.Duration
time.Time
bool
nil

Por favor, note que esta função define o valor de uma célula do tipo time.Time com o formato numérico m/d/yy h:mm por padrão e você pode alterar essa configuração usando SetCellStyle. Se precisar definir datas Excel especiais que não possam ser representadas pelo tipo time.Time da linguagem Go, como 0 de janeiro de 1900 ou 29 de fevereiro de 1900, defina o valor da célula como 0 ou 60 e, em seguida, defina com um estilo que tenha um formato de data.

Definir valor booleano

func (f *Arquivo) SetCellBool(planilha, célula string, valor bool) error

Define o valor de uma célula booleana com base no nome da planilha e nas coordenadas da célula fornecidos.

Definir valor de string padrão

func (f *Arquivo) SetCellDefault(planilha, célula, valor string) error

Define o valor de uma célula de string com base no nome da planilha e nas coordenadas da célula, e os caracteres não estarão sujeitos a filtragem de caracteres especiais.

Definir inteiro

func (f *Arquivo) SetCellInt(planilha, célula string, valor int) error

Define o valor de uma célula inteira com base no nome da planilha e nas coordenadas da célula fornecidos.

Definir ponto flutuante

func (f *Arquivo) SetCellFloat(planilha, célula string, valor float64, precisão, tamanhoBit int) error

Define o valor de uma célula de ponto flutuante com base no nome da planilha, coordenadas da célula, valor de ponto flutuante, precisão da parte fracionária do ponto flutuante e o tipo do ponto flutuante.

Definir valor de string

func (f *Arquivo) SetCellStr(planilha, célula, valor string) error

Define o valor de uma célula de string com base no nome da planilha e nas coordenadas da célula, os caracteres estarão sujeitos à filtragem de caracteres especiais e o comprimento acumulado da string não deve exceder 32767, caracteres em excesso serão ignorados.

Definir Estilo da Célula

func (f *File) SetCellStyle(sheet, hCell, vCell string, styleID int) error

Define o valor de uma célula com base no nome da planilha, coordenadas da célula e índice de estilo fornecido. Esta função é segura para thread. O índice de estilo pode ser obtido por meio da função NewStyle. Observe que o diagonalDown e o diagonalUp dentro da mesma área de coordenadas precisam manter cores consistentes. SetCellStyle irá substituir o estilo existente da célula sem empilhar ou mesclar os estilos.

  • Exemplo 1: Definir estilo de borda para a célula D7 na planilha nomeada 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)

Definir estilo de borda para uma célula

As quatro bordas da célula D7 são definidas com diferentes estilos e cores, que estão relacionadas aos parâmetros passados para a função NewStyle. Para definir estilos diferentes, consulte a documentação deste capítulo.

  • Exemplo 2: Definir estilo de gradiente para a célula D7 na planilha nomeada 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)

Definir estilo de gradiente para uma célula

A célula D7 é preenchida com cores de gradiente, que estão relacionadas aos parâmetros passados para a função NewStyle. Para definir estilos diferentes, consulte a documentação deste capítulo.

  • Exemplo 3: Definir preenchimento de cor sólida para a célula D7 na planilha nomeada 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)

Definir preenchimento de cor sólida para uma célula

A célula D7 é preenchida com uma cor sólida.

  • Exemplo 4: Definir espaçamento de caracteres e ângulo de rotação para a célula D7 na planilha nomeada Planilha1:
f.SetCellValue("Planilha1", "D7", "Estilo")
style, err := f.NewStyle(&excelize.Style{
    Alignment: &excelize.Alignment{
        Horizontal:      "centro",
        Recuo:           1,
        JustificarÚltimaLinha: true,
        OrdemLeitura:    0,
        RecuoRelativo:   1,
        Reduzirajuste:   true,
        RotaçãoTexto:    45,
        Vertical:        "",
        QuebrarTexto:    true,
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Planilha1", "D7", "D7", style)

Definir espaçamento de caracteres e ângulo de rotação

  • Exemplo 5: As datas e horas 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 de hora para a célula D7 na planilha denominada Sheet1:
f.SetCellValue("Sheet1", "D7", 42920,5)
f.SetColWidth("Sheet1", "D", "D", 13)
estilo, err := f.NewStyle(&excelize.Style{NumFmt: 22})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Sheet1", "D7", "D7", estilo)

Definir formato de hora para a célula

A célula D7 é definida com um formato de hora. Observe que quando a largura da célula é muito estreita para exibir o conteúdo completo, ela será exibida como ####. Você pode ajustar a largura da coluna arrastando ou chamando a função SetColWidth para definir a largura da coluna para um tamanho apropriado para exibição normal.

  • Exemplo 6: Defina a fonte, tamanho da fonte, cor e estilo em itálico para a célula D7 na planilha denominada Sheet1:
f.SetCellValue("Sheet1", "D7", "Excel")
estilo, err := f.NewStyle(&excelize.Style{
    Font: &excelize.Font{
        Negrito:   true,
        Itálico: true,
        Família: "Times New Roman",
        Tamanho:   36,
        Cor:  "777777",
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Sheet1", "D7", "D7", estilo)

Definir fonte, tamanho da fonte, cor e estilo em itálico para a célula

  • Exemplo 7: Bloquear e ocultar a célula D7 na planilha denominada Sheet1:
estilo, err := f.NewStyle(&excelize.Style{
    Proteção: &excelize.Protection{
        Oculto: true,
        Bloqueado: true,
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Sheet1", "D7", "D7", estilo)

Para bloquear ou ocultar células, proteja a planilha. Na guia "Revisão", clique em "Proteger Planilha".


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

Defina o hyperlink para uma célula com base na planilha, coordenadas da célula, recurso de link e tipo de recurso fornecidos. O tipo de recurso inclui dois tipos: endereço de link externo Externo e link de posição interna dentro da pasta de trabalho Localização. O número máximo de hyperlinks em cada planilha é limitado a 65530. Este método apenas define o hyperlink para a célula sem afetar o valor da célula. Se precisar definir o valor da célula, defina-o separadamente por meio de funções como SetCellStyle ou SetSheetRow.

  • Exemplo 1: Adicionar um link externo à célula A3 na planilha denominada Sheet1:
exibição, dica := "https://github.com/xuri/excelize", "Excelize no GitHub"
if err := f.SetCellHyperLink("Sheet1", "A3",
    "https://github.com/xuri/excelize", "Externo", excelize.HyperlinkOpts{
        Exibição: &exibição,
        Dica: &dica,
    }); err != nil {
    fmt.Println(err)
}
// Definir estilo de fonte e sublinhado para a célula
estilo, err := f.NewStyle(&excelize.Style{
    Fonte: &excelize.Fonte{Cor: "1265BE", Sublinhado: "simples"},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Sheet1", "A3", "A3", estilo)
  • Exemplo 2: Adicionar um link de localização à célula A3 na planilha denominada Sheet1:
err := f.SetCellHyperLink("Sheet1", "A3", "Sheet1!A40", "Localização")

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

Defina o formato de texto rico para a célula especificada com base na planilha, coordenadas da célula e formato de texto rico fornecidos.

Por exemplo, defina o formato de texto rico para a célula A1 na planilha chamada Planilha1:

Definir Formato de Texto Rico


```go
pacote principal

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.SetRowHeight("Planilha1", 1, 35); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetColWidth("Planilha1", "A", "A", 44); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetCellRichText("Planilha1", "A1", []excelize.RichTextRun{
        {
            Text: "em negrito",
            Font: &excelize.Font{
                Negrito:   true,
                Cor:  "2354E8",
                Familia: "Times New Roman",
            },
        },
        // ... (Outras execuções de texto rico)
    }); err != nil {
        fmt.Println(err)
        return
    }
    // ... (Outras configurações de estilo de célula e salvamento)
}

func (f *File) GetCellRichText(planilha, célula string) ([]RichTextRun, error)

Obtenha o formato de texto rico da célula especificada com base na planilha e coordenadas da célula fornecidas.

func (f *File) GetCellValue(planilha, célula string, opts ...Opções) (string, error)

Obtenha o valor da célula especificada com base na planilha e coordenadas da célula, e o valor de retorno será convertido para o tipo string. Se o formato da célula puder ser aplicado ao valor da célula, o valor aplicado será retornado; caso contrário, o valor original será retornado. Os valores de todas as células dentro de uma área mesclada são iguais. Esta função é segura para concorrência.

func (f *File) GetCellType(planilha, célula string) (TipoCélula, error)

Obtenha o tipo de dados da célula especificada com base na planilha e coordenadas da célula fornecidas.

func (f *File) GetCols(planilha string, opts ...Opções) ([][]string, error)

Recupere os valores de todas as células na planilha especificada por coluna e retorne-os na forma de uma matriz bidimensional, com os valores das células convertidos 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, para recuperar e iterar por todos os valores das células na planilha chamada Planilha1 por coluna:

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

func (f *File) GetRows(planilha string, opts ...Opções) ([][]string, error)

Recupere os valores de todas as células na planilha especificada por linha e retorne-os na forma de uma matriz bidimensional, com os valores das células convertidos 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 recupera linhas com células contendo valores ou fórmulas. As células vazias no final de uma linha serão ignoradas, e o número de células em cada linha pode variar.

Por exemplo, para recuperar e iterar por todos os valores das células na planilha chamada Planilha1 por linha:

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

func (f *File) GetCellHyperLink(planilha, célula string) (bool, string, error)

Recupere o hiperlink da célula especificada com base na planilha e coordenadas da célula fornecidas. Se a célula contiver um hiperlink, ele retornará `true` e o endereço do link; caso contrário, retornará `false` e um endereço de link vazio.

Por exemplo, para recuperar o hiperlink da célula nas coordenadas `H6` na planilha chamada `Sheet1`:

```go
link, target, err := f.GetCellHyperLink("Sheet1", "H6")

func (f *File) GetCellStyle(planilha, célula string) (int, error)

Recupere o índice de estilo da célula especificada com base na planilha e coordenadas da célula fornecidas, e o índice recuperado pode ser usado como parâmetro ao chamar a função SetCellStyle para definir o estilo da célula.

func (f *File) MergeCell(planilha, célulaH, célulaV string) error

Junte as células na região de coordenadas da célula fornecida na planilha. Apenas o valor da célula superior esquerda na região mesclada será mantido, e os valores das outras células serão ignorados. Por exemplo, mesclar as células na região D3:E9 na planilha chamada Sheet1:

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

Se a região de coordenadas da célula fornecida se sobrepõe a células mescladas existentes, as células mescladas existentes serão removidas.

func (f *File) UnmergeCell(planilha string, célulaH, célulaV string) error

Desagrupe as células na região de coordenadas da célula fornecida na planilha. Por exemplo, desagrupar as células na região D3:E9 na planilha chamada Sheet1:

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

Se a região de coordenadas da célula fornecida contiver várias células mescladas, todas as células mescladas serão desagrupadas.

Obtenha a região de coordenadas e valores de todas as células mescladas na planilha fornecida.

func (f *File) GetMergeCells(planilha string) ([]MergeCell, error)

func (m *MergeCell) GetCellValue() string

GetCellValue retorna o valor da célula mesclada.

func (m *MergeCell) GetStartAxis() string

GetStartAxis retorna a coordenada da célula superior esquerda da região de células mescladas, por exemplo, C2.

func (m *MergeCell) GetEndAxis() string

GetEndAxis retorna a coordenada da célula inferior direita da região de células mescladas, por exemplo, D4.

func (f *File) AddComment(planilha string, comentário Comment) error

Adicione um comentário à planilha, coordenadas da célula e parâmetros de estilo (informações do autor e texto). As informações do autor têm um comprimento máximo de 255 caracteres, e o comprimento máximo do conteúdo de texto é de 32512 caracteres. Caracteres além dessa faixa serão ignorados. Por exemplo, adicione um comentário à célula Sheet1!$A$3:

Adicionar um comentário em um documento do Excel

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

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

Obtenha todos os comentários de células na planilha fornecida.

func (f *File) DeleteComment(planilha, célula string) error

Exclua o comentário na planilha e coordenada da célula fornecidas. Por exemplo, exclua o comentário na célula Sheet1!$A$30:

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