Come usare le costanti in Golang

Cosa significa Constant o Const in Golang ? Ecco cosa devi sapere sull'uso delle costanti in Go .

Come suggerisce il nome, costante significa fisso. Lo stesso vale per i linguaggi di programmazione: una volta definito il valore di una costante, non è più possibile modificarlo ulteriormente. Può trattarsi di qualsiasi tipo di dato di base costante, come costante intera, costante dinamica, costante carattere o stringa.

Come dichiarare: le costanti vengono dichiarate come le variabili, ma utilizzano la parola chiave const come prefisso per dichiarare costanti con un tipo di dati specifico. Le costanti non possono essere dichiarate utilizzando la sintassi “: = ”.

Per esempio:

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

Risultato:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Cose da sapere sulle costanti in Golang

Costanti numeriche senza tipo e con tipo

Le costanti tipizzate si comportano come variabili immutabili che possono interagire solo con gli stessi tipi, mentre le costanti senza tipo si comportano come costanti letterali che possono interagire con tipi simili. In Go le costanti possono essere dichiarate con o senza tipo. Gli esempi seguenti mostrano costanti numeriche tipizzate e non tipizzate, denominate e non denominate.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Ecco l'elenco delle costanti nel linguaggio Go:

• Costanti (costanti intere, costanti dinamiche, costanti complesse)
• Stringa di caratteri
• costante booleana

Numero costante

Le costanti numeriche sono valori con elevata precisione. Poiché Go è un linguaggio staticamente tipizzato, non consente operazioni che combinano tipi numerici. Non è possibile aggiungere float64a int, o persino int32a int. Tuttavia, è ancora valido scrivere 1e6*time.Secondo math.Exp(1)o anche 1<>. In Go, le costanti, a differenza delle variabili, si comportano come numeri normali.

Le costanti numeriche sono di tre tipi:

1. intero
2. virgola mobile
3. complesso

Costante intera:

• Il prefisso specifica la base: 0x o 0X per esadecimale, 0 per ottale e niente per decimale.
• Un letterale intero può anche avere un suffisso che è una combinazione di U (maiuscolo) e L (minuscolo), rispettivamente per "unsigned" e "long" .
• Può essere una costante decimale, ottale o esadecimale.
• Un int può memorizzare fino a un numero intero di 64 bit e talvolta anche di meno.

Ecco alcuni esempi di costanti intere:

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ố */

Costanti complesse:

Le costanti complesse funzionano in modo molto simile alle costanti in virgola mobile. È una coppia ordinata o una coppia reale di costanti intere (o parametri). Le costanti sono separate da virgole e le coppie di numeri sono inserite tra parentesi. La prima costante è la parte reale, la seconda costante è la parte immaginaria. Una costante complessa, COMPLEX*8, utilizza 8 byte di spazio di archiviazione.

Per esempio:

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

Costante di tipo dinamico:

• Le costanti dei numeri reali sono composte da una parte intera, una parte decimale, una parte frazionaria e una parte esponente.
• Può essere rappresentato come una costante reale in forma decimale o esponenziale.
• Se espresso in forma decimale, deve includere un punto decimale, un esponente o entrambi.
• E quando espresso in forma esponenziale, deve includere una parte intera, una parte frazionaria o entrambe.

Per esempio:

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ố */

Stringa di caratteri

• Go supporta due tipi di stringhe letterali, ovvero ” ”(stile con virgolette doppie) e ‘ ‘(stile con virgolette inverse).
• Le stringhe possono essere concatenate con gli operatori +and +=.
• Le stringhe contengono caratteri simili ai caratteri letterali: caratteri semplici, sequenze di escape e caratteri universali. E questo è un personaggio senza stile.
• Il valore zero dei tipi stringa è la stringa vuota, che può essere rappresentata da ” ”o ”in valori letterali.
• Tutti i tipi di stringa possono essere confrontati utilizzando operatori come ==, !=e (per confrontare tipi simili)

Sintassi:

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

Per esempio:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

In questo caso, tutte e tre le affermazioni sono identiche, ovvero non hanno alcun tipo specifico.

Per esempio:

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)="">

Risultato:

GFG Quantrimang!
true
false

Complessità temporale: O(1)
Spazio ausiliario: O(1)

costante booleana

Le costanti booleane sono simili alle costanti stringa. Applica le stesse regole delle costanti stringa. L'unica differenza è che ha due const senza 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) 
}

Risultato:

true
true

Complessità temporale: O(1)
Spazio ausiliario: O(1)

Costanti in Go: Go ha costanti di caratteri, stringhe, booleane e numeriche. Const dichiara un valore costante. Un'istruzione constpuò verificarsi quando è presente una variabile e quindi eseguire operazioni aritmetiche senza alcuna precisione fissa.

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

Risultato:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Complessità temporale: O(1)
Spazio ausiliario: O(1)

Se si desidera definire più costanti contemporaneamente, è possibile farlo utilizzando un blocco di parentesi come mostrato di seguito.

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

Risultato:

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