GoLang: O que são constantes em Go e como usá-las?

Uma constante é uma constante e é constantemente a mesma.

Pegue?

Ok, isso não está claro o suficiente, especialmente quando se trata de uma linguagem de programação. Deixe-me colocar desta forma: uma vez definida uma constante, seu valor não pode ser alterado.

Mas espere, não defina valores assim:

var A  int = 10

Você certamente quer.

Mas se você definisse A dessa forma, também poderia alterar o valor de A. Aqui está um exemplo:

package main
import ("fmt")

func main() {
  var A int = 1
  fmt.Println(A)
  A = 2
  fmt.Println(A)

}

O que fizemos acima foi definir a variável A como um número inteiro e defini-la como 1. Imprima A e você obterá 1 na saída. Depois disso, redefinimos A como 2 e, adivinhe… 2 é a saída.

Alteramos o valor de uma variável.

Mas e se você quisesse ter certeza de que isso não aconteceria?

Eu sei o que você está pensando. Apenas certifique-se de nunca alterar A no seu código. Mas o que acontece quando seu código fica muito grande ou talvez você esteja colaborando no código e deseja garantir que A nunca seja diferente de 1? Em outras palavras, você deseja que essa variável seja somente leitura.

Para isso, você precisa de uma constante.

Na linguagem de programação Go, as constantes são declaradas usando o const palavra-chave.

As constantes podem ter valores de caracteres, strings, booleanos e numéricos. Você pode definir uma única constante ou defini-las em um bloco de colchetes.

Primeiro, deixe-me mostrar como definir uma constante inteira e o que acontece se você tentar alterá-la. Lembra do nosso aplicativo de exemplo acima? Vou usar isso, mas definirei A como uma constante com a instrução:

const A int = 1

Vamos inserir isso em nosso aplicativo de exemplo assim:

package main
import ("fmt")

const A int = 1

func main() {
  fmt.Println(A)
  A = 2
  fmt.Println(A)

}

Se você executar o código acima, verá o seguinte erro:

./constant.go:9:3: não é possível atribuir a A (nem endereçável nem uma expressão de índice de mapa)

O erro indica claramente que A não é endereçável (somente leitura).

Huzzah, constantes.

Isso não significa que você não pode usar a constante. Por exemplo:

package main
import ("fmt")

const A int = 1

func main() {
  fmt.Println(A)
  var B int = (A + 1)
  fmt.Println(B)

}

A saída acima seria:

1
2

Como isso aconteceu? Não alteramos A, apenas adicionamos a ele, então A permaneceu somente leitura e definimos uma nova variável com B.

Então, a diferença é:

const A int = 1 vs. var A int = 1

A primeira é uma constante, enquanto a última é uma definição de variável regular.

Mas e as cordas? Você também pode definir uma string com const. Desta vez definiremos nossas constantes em um bloco (em vez de uma de cada vez). Nossas constantes são definidas assim:

const (
      FirstConstant string = "Hello,"
      SecondConstant string = "New Stack!"
)

Isso é bastante simples. Vamos imprimir as strings em nossa função principal assim:

func main() {
   fmt.Println(FirstConstant, SecondConstant)
}

Todo o nosso programa é assim:

package main
import "fmt"

const (
      FirstConstant string = "Hello,"
      SecondConstant string = "New Stack!"
)

func main() {
   fmt.Println(FirstConstant, SecondConstant)
}

Se executarmos esse aplicativo, a saída seria:

Olá nova pilha

Agora, vamos tentar alterar uma dessas constantes. Fazemos isso dentro do nosso main() assim:

FirstConstant = "Yo"
SecondConstant = "New Stack"

Nosso aplicativo inteiro é assim:

package main
import "fmt"

const (
    FirstConstant string = "Hello"
    SecondConstant string = "New Stack"
)

func main() {
    fmt.Println(FirstConstant, SecondConstant)

     FirstConstant = "Yo"
     SecondConstant = "New Stack"
}

Se executarmos o procedimento acima, obteremos os seguintes erros:

./replace.go:14:6: não é possível atribuir a FirstConstant (nem endereçável nem uma expressão de índice de mapa)
./replace.go:15:6: não é possível atribuir a SecondConstant (nem endereçável nem uma expressão de índice de mapa)

Ele captou as constantes e sabia que não poderiam ser alteradas. Melhor ainda, não importa onde você usa a constante no seu código, uma vez definida, ela não pode ser alterada.

Você também pode declarar constantes dentro função principal(). Na verdade, você pode declará-los antes e dentro dele. Aqui está um exemplo:

package main

import (
    "fmt"
    "math"
)

const A string = "New Stack Math"

func main() {
    fmt.Println(A)

    const B = 1000
    const C = 2e10 / B

    fmt.Println(C)
    fmt.Println(int64(C))
    fmt.Println(math.Cos(B))
}

Aqui está o que fizemos:

• Definiu uma string para A que é “New Stack Math”
• Definiu uma constante para B que é 1000
• Definiu uma constante para C que é um número muito grande dividido por B
• Impresso C
• C impresso como um número inteiro de 64 bits
• Imprimiu o cosseno de B

A saída do código acima seria:

Nova pilha matemática
2e+07
2.000.000
0,5623790762907029

Isso é uma matemática séria do New Stack, meus amigos e, em cada caso, nenhuma de nossas constantes pode ser alterada.

E isso, meus amigos, é o que são as constantes Go e como você as usa. Este recurso se tornará seu amigo quando você precisar declarar algo que não pode ser alterado em nenhum lugar do seu código.

A postagem GoLang: O que são constantes em Go e como você as usa? apareceu primeiro em The New Stack.