Como usar constantes em Golang

O que é constante ou const em Golang ? Aqui está o que você precisa saber sobre o uso de constantes em Go .

Como o nome sugere, constante significa fixo. O mesmo vale para linguagens de programação, ou seja, uma vez definido o valor de uma constante, ele não pode mais ser modificado. Pode haver qualquer tipo de dado básico de constante, como constante inteira, constante dinâmica, constante de caractere ou string.

Como declarar: Constantes são declaradas como variáveis, mas usam a palavra-chave const como prefixo para declarar constantes com um tipo de dado específico. Constantes não podem ser declaradas usando a sintaxe “: = ”.

Por exemplo:

package main

import "fmt"

const PI = 3.14

func main() 
{
	const GFG = "Quantrimang"
	fmt.Println("Hello", GFG)

	fmt.Println("Happy", PI, "Day")

	const Correct= true
	fmt.Println("Go rules?", Correct)
}

Resultado:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Coisas que você precisa saber sobre constantes em Golang

Constantes numéricas sem tipo e com tipo

Constantes tipadas se comportam como variáveis ​​imutáveis ​​que só podem interagir com os mesmos tipos, e constantes sem tipo se comportam como constantes literais que podem interagir com tipos semelhantes. Constantes podem ser declaradas com ou sem tipo em Go. Os exemplos a seguir mostram constantes numéricas digitadas e não digitadas, nomeadas e não nomeadas.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Aqui está a lista de constantes na linguagem Go:

• Constantes (constantes inteiras, constantes dinâmicas, constantes complexas)
• Sequência de caracteres
• constante booleana

Constante numérica

Constantes numéricas são valores com alta precisão. Como Go é uma linguagem estaticamente tipada, ela não permite operações que combinem tipos numéricos. Você não pode adicionar float64a int, ou mesmo int32a int. Entretanto, ainda é válido escrever 1e6*time.Secondor math.Exp(1)ou even 1<>. Em Go, constantes, diferentemente de variáveis, se comportam como números regulares.

As constantes numéricas são de três tipos:

1. inteiro
2. ponto flutuante
3. complexo

Constante inteira:

• O prefixo especifica a base: 0x ou 0X para hexadecimal, 0 para octal e nada para decimal.
• Um literal inteiro também pode ter um sufixo que é uma combinação de U (maiúscula) e L (minúscula), para unsigned e long, respectivamente.
• Pode ser uma constante decimal, octal ou hexadecimal.
• Um int pode armazenar até um inteiro de 64 bits e, às vezes, menos.

Aqui estão alguns exemplos de constantes inteiras:

85 /* thập phân */
0213 /* bát phân */
0x4b /* thập lục phân */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
212 /* Hợp lệ */
215u /* Hợp lệ */
0xFeeL /* Hợp lệ */
078 /* Không hợp lệ: 8 không phải là chữ số bát phân */
032UU /* Không hợp lệ: không thể lặp lại hậu tố */

Constantes complexas:

Constantes complexas funcionam de forma muito semelhante às constantes de ponto flutuante. É um par ordenado ou par real de constantes inteiras (ou parâmetros). E as constantes são separadas por vírgulas, e os pares de números são colocados entre parênteses. A primeira constante é a parte real, e a segunda constante é a parte imaginária. Uma constante complexa, COMPLEX*8, usa 8 bytes de armazenamento.

Por exemplo:

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

Constante de tipo dinâmico:

• As constantes de números reais têm uma parte inteira, uma parte decimal, uma parte fracionária e uma parte expoente.
• Pode ser representado como uma constante real em forma decimal ou exponencial.
• Quando expresso em forma decimal, deve incluir um ponto decimal, um expoente ou ambos.
• E quando expresso em forma exponencial, deve incluir uma parte inteira, uma parte fracionária ou ambas.

Por exemplo:

3.14159 /* Hợp lệ */
314159E-5L /* Hợp lệ */
510E /* Không hợp lệ: số mũ không đầy đủ */
210f /* Không hợp lệ: không có số thập phân hoặc số mũ */
.e55 /* Không hợp lệ: thiếu số nguyên hoặc phân số */

Sequência de caracteres

• Go suporta dois tipos de literais de string, ou seja, ” ”(estilo aspas duplas) e ‘ ‘(estilo aspas invertidas).
• Strings podem ser concatenadas com os operadores +e +=.
• Strings contêm caracteres semelhantes a caracteres literais: caracteres simples, sequências de escape e caracteres universais. E esse é um personagem sem estilo.
• O valor zero dos tipos de string é a string vazia, que pode ser representada por ” ”ou ”em literais.
• Todos os tipos de string podem ser comparados usando operadores como ==, !=e (para comparar tipos semelhantes)

Sintaxe:

kiểu _string struct {
các phần tử *byte // các byte cơ bản
len int // số byte
}

Por exemplo:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

Aqui, todas as três afirmações são iguais, ou seja, elas não têm nenhum tipo específico.

Por exemplo:

package main

import "fmt"

func main()
{
	const A = "GFG"
	var B = "GeeksforGeeks"
	
	// Chuỗi Concat.
	var helloWorld = A+ " " + B
	helloWorld += "!"
	fmt.Println(helloWorld) 
	
	// Chuỗi so sánh.
	fmt.Println(A == "GFG") 
	fmt.Println(B < a)="">

Resultado:

GFG Quantrimang!
true
false

Complexidade de tempo: O(1)
Espaço auxiliar: O(1)

constante booleana

Constantes booleanas são semelhantes às constantes de string. Aplica as mesmas regras das constantes de string. A única diferença é que ele tem duas const sem tipo truee false.

package main

import "fmt"

const Pi = 3.14

func main() 
{
	const trueConst = true
	
	// Định nghĩa kiểu bằng từ khóa type
	type myBool bool 
	var defaultBool = trueConst // được phép
	var customBool myBool = trueConst // được phép
	
	// defaultBool = customBool // không được phép
	fmt.Println(defaultBool)
	fmt.Println(customBool) 
}

Resultado:

true
true

Complexidade de tempo: O(1)
Espaço auxiliar: O(1)

Constantes em Go: Go tem constantes de caracteres, strings, booleanas e numéricas. Const declara um valor constante. Uma instrução constpode ocorrer quando há uma variável e, portanto, executar operações aritméticas sem nenhuma precisão fixa.

// Minh họa hằng số bằng cách dùng go.
package main

import (
	"fmt"
	"math"
)

const s string = "Quantrimang"

func main() {
	fmt.Println(s)

	const n = 5

	const d = 3e10 / n
	fmt.Println(d)

	fmt.Println(int64(d))

	fmt.Println(math.Sin(n))
}

Resultado:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Complexidade de tempo: O(1)
Espaço auxiliar: O(1)

Se você quiser definir várias constantes de uma vez, poderá fazer isso usando um bloco de parênteses, como mostrado abaixo.

package main

import "fmt"

const (
	GFG	 = "Quantrimang"
	Correct = true
	Pi	 = 3.14
)

// Hàm chính
func main() {

	fmt.Println("value of GFG : ", GFG)

	fmt.Println("value of Correct : ", Correct)

	fmt.Println("value of Pi : ", Pi)
}

Resultado:

value of GFG :  Quantrimang
value of Correct :  true
value of Pi :  3.14