Cum să folosiți constantele în Golang

Ce este Constant sau Const în Golang ? Iată ce trebuie să știți despre utilizarea constantelor în Go .

După cum sugerează și numele, constant înseamnă fix. Același lucru este valabil și în limbajele de programare, adică, odată ce valoarea unei constante este definită, aceasta nu mai poate fi modificată. Poate exista orice tip de date de bază de constantă, cum ar fi constantă întreagă, constantă dinamică, constantă de caractere sau șir.

Cum se declară: constantele sunt declarate ca variabile, dar se utilizează cuvântul cheie const ca prefix pentru a declara constante cu un anumit tip de date. Constantele nu pot fi declarate folosind sintaxa „: = ”.

De exemplu:

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

Rezultat:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Lucruri de știut despre constantele din Golang

Constante numerice fără tip și cu tip

Constantele tipizate se comportă ca variabile imuabile care pot interacționa numai cu aceleași tipuri, iar constantele fără tip se comportă ca niște constante literale care pot interacționa cu tipuri similare. Constantele pot fi declarate cu sau fără tip în Go. Următoarele exemple arată constante numerice tastate și netipizate, denumite și nenumite.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Iată lista constantelor din Go Language:

• Constante (constante întregi, constante dinamice, constante complexe)
• Șir de caractere
• constantă booleană

Constanta numerica

Constantele numerice sunt valori cu mare precizie. Deoarece Go este un limbaj tipizat static, nu permite operațiuni care combină tipuri numerice. Nu puteți adăuga float64la int, sau chiar int32la int. Cu toate acestea, este încă valabil să scrieți 1e6*time.Secondsau math.Exp(1)chiar 1<>. În Go, constantele, spre deosebire de variabile, se comportă ca numere obișnuite.

Constantele numerice sunt de trei tipuri:

1. întreg
2. virgulă flotantă
3. complex

Constanta intreaga:

• Prefixul specifică baza: 0x sau 0X pentru hexazecimal, 0 pentru octal și nimic pentru zecimal.
• Un literal întreg poate avea, de asemenea, un sufix care este o combinație de U (majuscule) și L (minuscule), pentru nesemnat și, respectiv, lung .
• Poate fi o constantă zecimală, octală sau hexazecimală.
• Un int poate stoca până la un număr întreg pe 64 de biți și uneori mai puțin.

Iată câteva exemple de constante întregi:

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

Constante complexe:

Constantele complexe funcționează foarte similar cu constantele în virgulă mobilă. Este o pereche ordonată sau o pereche reală de constante întregi (sau parametri). Și constantele sunt separate prin virgule, iar perechile de numere sunt plasate în paranteze. Prima constantă este partea reală, iar a doua constantă este partea imaginară. O constantă complexă, COMPLEX*8, utilizează 8 octeți de stocare.

De exemplu:

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

Constanta de tip dinamic:

• Constantele numere reale au o parte întreagă, o parte zecimală, o parte fracțională și o parte exponent.
• Poate fi reprezentat ca o constantă reală în formă zecimală sau exponențială.
• Când este exprimat sub formă zecimală, trebuie să includă un punct zecimal, un exponent sau ambele.
• Și atunci când este exprimat în formă exponențială, trebuie să includă o parte întreagă, o parte fracțională sau ambele.

De exemplu:

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

Șir de caractere

• Go acceptă două tipuri de literale șir, adică ” ”(stil ghilimele duble) și ‘ ‘(stilul ghilimelelor înapoi).
• Șirurile pot fi concatenate cu operatorii +și +=.
• Șirurile de caractere conțin caractere similare cu caracterele literale: caractere simple, secvențe de escape și caractere universale. Și acesta este un personaj fără stil.
• Valoarea zero a tipurilor de șir este șirul gol, care poate fi reprezentat prin ” ”sau ”în literale.
• Toate tipurile de șir pot fi comparate folosind operatori precum ==și !=(pentru a compara tipuri similare)

Sintaxă:

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

De exemplu:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

Aici, toate cele trei afirmații sunt aceleași, adică nu au niciun tip specific.

De exemplu:

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

Rezultat:

GFG Quantrimang!
true
false

Complexitatea timpului: O(1)
Spațiu auxiliar: O(1)

constantă booleană

Constantele booleene sunt similare cu constantele șir. Se aplică aceleași reguli ca și constantele șir. Singura diferență este că are două const fără tip trueși 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) 
}

Rezultat:

true
true

Complexitatea timpului: O(1)
Spațiu auxiliar: O(1)

Constante în Go: Go are constante de caractere, șir, booleene și numerice. Const declară o valoare constantă. O declarație constpoate apărea atunci când există o variabilă și, astfel, poate efectua operații aritmetice fără nicio precizie fixă.

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

Rezultat:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Complexitatea timpului: O(1)
Spațiu auxiliar: O(1)

Dacă doriți să definiți mai multe constante simultan, puteți face acest lucru folosind un bloc de paranteze, așa cum se arată mai jos.

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

Rezultat:

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