Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

Constantes são muito comuns e bastante utilizadas, para quem está iniciando pode parecer confuso por elas serem semelhantes a variáveis. A principal diferença das constantes é que elas são definitivas, uma vez criada o valor não é mais alterado, como o próprio nome diz: constante.

Como funciona em Go?

Em Go as constantes são criadas na compilação do código. Uma expressão comum é dizer que é em "tempo de compilação". Enquanto as variáveis são criadas em tempo de execução (runtime). Por esse motivo as constantes só podem ser dos tipos básicos do Go: strings, números, caracteres e booleanos.

Para saber mais: https://go.dev/doc/effective_go#constants

Criando constantes

Vamos ao primeiro exemplo:

package main

import "fmt"

const (
    appName    = "go_basico"
    serverPort = 3000
)

func main() {
    fmt.Println(appName, serverPort)
}

Você também pode criar dessa forma:

package main

import "fmt"

const appName    = "go_basico"
const serverPort = 3000

func main() {
    fmt.Println(appName, serverPort)
}

Agrupando constantes

O interessante é que você agrupe suas constantes, combinando valores que sejam relacionados, isso vai deixar o código bastante simples. Por exemplo, vamos imaginar que nós temos um produto e que ele possui dois atributos: cor e status
Esses dois atributos possuem valores limitados, um conjunto de constantes:

package main

import "fmt"

// conjunto de cores
const (
    vermelho = "#ff0000"
    verde    = "#00ff00"
    azul     = "#0000ff"
)

// conjunto de status do produto
const (
    rascunho  = 1
    publicado = 2
    congelado = 3
    deletado  = 4
)

func main() {
    fmt.Println(vermelho, azul, verde)
    fmt.Println(rascunho, publicado, congelado, deletado)
}

Conjuntos de constantes

Se você já teve contato com outras linguagens é possível que esteja se perguntando se não poderíamos ter feito isso com
enums. A resposta é sim e não.

• Sim, porque Go possui o conceito de tipos enumerados.
• Não, porque em Go você não tem uma palavra reservada para criar enum.

Eu convido você que está lendo, a refletir um pouco sobre isso, algumas vezes nós podemos acabar caindo em armadilhas de se prender a nomes como enum e esquecer o que eles são em sua essência.

Bom, o que nós precisamos fazer é definir um tipo customizado para os nossos conjuntos:

type cor string
type status int

Futuramente teremos post sobre tipos e tipos customizados

package main

import (
    "fmt"
)

type cor string

const (
    vermelho cor = "#ff0000"
    verde    cor = "#00ff00"
    azul     cor = "#0000ff"
)

type status int

const (
    rascunho  status = 1
    publicado status = 2
    congelado status = 3
    deletado  status = 4
)

func main() {
    fmt.Println(vermelho, azul, verde)
    fmt.Println(rascunho, publicado, congelado, deletado)
}

Utilizando iota

Para conjuntos numéricos, como o nosso conjunto de status, temos a opção de usar a palavra reservada iota, ela vai gerar valores sequenciais automaticamente:

package main

import "fmt"

type cor string

const (
    vermelho cor = "#ff0000"
    verde    cor = "#00ff00"
    azul     cor = "#0000ff"
)

type status int

const (
    //por padrão iota inicia em 0
    rascunho status = iota + 1
    publicado
    congelado
    deletado
)

func main() {
    fmt.Println(vermelho, azul, verde)
    fmt.Println(rascunho, publicado, congelado, deletado)
}

Resumo

• Constantes são declaradas com a palavra reservada const.
• Constantes são criadas em tempo de compilação.
• Agrupar constantes em conjuntos contextualizados simplifica o código.
• Go possuí tipos enumerados.
• A palavra reservada iota pode simplificar seu código.