Constantes da Linguagem Go

Como o nome sugere CONSTANTS” sãoA implicação é fixa, assim como em linguagens de programação, ou seja, uma vez definido o valor da constante, não pode ser modificado. As constantes podem ter qualquer tipo de dados básicos, como constantes inteiras, constantes de ponto flutuante, constantes de caractere ou literais de string.

Como declarar?
Constantes são declaradas como variáveis, mas usamconst Palavras-chave como prefixo para declarar constantes com tipos específicos. Não pode usar:=Declaração de sintaxe.

package main
import "fmt"
const PI=　3.14
func main() {
　　　　const GFG= "w3codebox"
　　　　fmt.Println("Olá", GFG)
　　　　fmt.Println("Feliz", PI, "Dia")
　　　　const Correto= verdadeiro
　　　　fmt.Println("Go regras?", Correto)
}

Saída:

Olá w3codebox
Feliz　3.14　Dia
Go regras? verdadeiro

constantes numéricas não tipificadas e tipificadas:
O funcionamento das constantes tipificadas é como variáveis imutáveis que podem interagir apenas com o mesmo tipo, enquanto o funcionamento das constantes não tipificadas é como literals que podem interagir com tipos semelhantes. Constantes numéricas tipificadas e não tipificadas podem ser declaradas com ou sem tipo no Go. O exemplo a seguir mostra constantes numéricas tipificadas e não tipificadas nomeadas e não nomeadas.

const untypedInteger　123
const untypedFloating typed　123.12
const typedInteger int　123
const typedFloatingPoint float64　　=　123.12

A seguir está a lista de constantes no idioma Go:

• constantes numéricas (constantes inteiras, constantes de ponto flutuante, constantes de número complexo)

• literais de strings

• constantes booleanas

constantes numéricas:
constantes numéricas sãovalores de alta precisãoGo é uma linguagem de tipo estático, não permitindo operações mistas entre tipos de números. Você não pode adicionarfloat64adicionar aintmesmo que não possa adicionarint32adicionar paraintEmbora, escrever1e6 * time.Second oumath.Exp(1)até mesmo 1 <<('\ t'+ 2.0） todos são válidos. No Go, as constantes são diferentes das variáveis, e seu comportamento é semelhante ao de números normais.

constantes numéricas podem ser3espécies, ou seja, inteiros, números de ponto flutuante, números complexos

constantes inteiras:

• prefixo especifica a base: hexadecimal é 0x ou 0X, octal é 0, decimal é 0.

• Os literais de número inteiro também podem tersufixoque são combinações de U (maiusculo) e L (maiusculo), respectivamente, representando inteiro sem sinal e inteiro longo.

• pode serconstantes decimais, octais ou hexadecimais。

• um int pode armazenar até64bits de inteiro, às vezes menos.

A seguir estãoconstantes inteirasalguns exemplos：

85　　　　　　　　　/*　decimal　*/
0213　　　　　　　/*　octal　*/
0x4b　　　　　　　/*　hexadecimal　*/
30　　　　　　　　　/*　int　*/
30u　　　　　　　　/*　unsigned int　*/
30l　　　　　　　　/*　long　*/
30ul　　　　　　　/*　unsigned long　*/
212　　　　　　　　　/*　Válido　*/
215u　　　　　　　　/*　Válido　*/
0xFeeL　　　　　　/*　Válido　*/
078　　　　　　　　　/*　não permitido:8não é um número octal　*/
032UU　　　　　　　/*　não permitido: não pode repetir sufixo　*/

constante de número complexo:
O comportamento da constante de número complexo é muito semelhante ao da constante de ponto flutuante. É constante inteira (ou parâmetro) depar ordenado ou par de números reaise a constante é separada por vírgula, e o par está entre parênteses. O primeiro número é o parte real, e o segundo número é a parte imaginária. Constante de número complexo COMPLEX * 8usado8bytesespaço de armazenamento.

(0.0, 0.0) (-123.456E+30,　987.654E-29)

constantes de tipo flutuante:

• constantes de ponto flutuante têm umparte inteira, um ponto decimal, uma parte decimal e uma parte exponencial。

• pode ser representado em forma decimal ou exponencial.

• Emborarepresentados em forma decimal, deve conter ponto decimal, exponencial ou ambos.

• e ao usarExponencialNa forma de representação, deve incluir parte inteira, parte decimal ou ambas.

Aqui estão exemplos de constantes de tipos de ponto flutuante:

3.14159　　　　　　　/*　Válido　*/
314159E-5L　　　　/*　Válido　*/
510E　　　　　　　　　　/*　Inválido: índice incompleto　*/
210f　　　　　　　　　　/*　Inválido: não há decimal ou exponencial　*/
.e55　　　　　　　　　　/*　Inválido: falta inteiro ou fração　*/

Literais de strings

• O Go suporta dois tipos de strings literais, ou seja, "" (estilo de aspas duplas) e "" (estilo de crase).

• As strings podemconcatenaçãousando+e+ =Operadores.

• As strings contêm caracteres semelhantes aos literais de caracteres: caracteres puros, sequências de escape e caracteres genéricos, que são não tipados.

• O valor zero do tipo de string é uma string vazia, que pode ser representada usando ou como texto literal. " " ''

• usando==, !=e (usados para comparar tipos iguais) entre outros operadores，Tipos de strings comparáveis

Sintaxe

type _string struct {
　　　　elements　*byte　//　Elementos de bytes
　　　　len int　　　//Tamanho de bytes
}

Exemplos de strings literais:
"hello, w3codebox"

"hello, \

w3codebox"

"hello, " "geeks" "forgeeks"

Aqui, todas as três declarações acima são semelhantes, ou seja, elas não têm nenhum tipo específico.
Exemplo:

package main
import "fmt"
func main() {
　　　　const A = "GFG"
　　　　var B = "w3codebox"
　　　　
　　　　//Juntar strings
　　　　var helloWorld = A+　" "　+　B
　　　　helloWorld　+= "!"
　　　　fmt.Println(helloWorld)　
　　　　
　　　　//Comparação de strings
　　　　fmt.Println(A == "GFG")　　　
　　　　fmt.Println(B < A)　
}

Saída:

GFG w3codebox!
true
false

Constantes booleanas:
As constantes booleanas são semelhantes às constantes de string. Elas aplicam as mesmas regras que as constantes de string, a diferença é que elas possuem dois constantes não tipados true e false.

package main
import "fmt"
const Pi =　3.14
func main() {
　　　　const trueConst = true
　　　　type myBool bool
　　　　var defaultBool = trueConst　　　　　　　//　Permitido
　　　　var customBool myBool = trueConst　//　Permitido
　　　　//　　defaultBool = customBool　//　Não permitido
　　　　fmt.Println(defaultBool)
　　　　fmt.Println(customBool)
}

Saída:

true
true