Hoe constanten in Golang te gebruiken

Wat is Constant of Const in Golang ? Dit is wat u moet weten over het gebruik van constanten in Go .

Zoals de naam al aangeeft, betekent constant vast. Hetzelfde geldt voor programmeertalen: zodra de waarde van een constante is gedefinieerd, kan deze niet meer worden gewijzigd. Er kunnen alle basisgegevenstypen van constante bestaan, zoals een geheel getal, een dynamische constante, een tekenconstante of een tekenreeks.

Hoe te declareren: Constanten worden gedeclareerd zoals variabelen, maar gebruiken het trefwoord const als voorvoegsel om constanten met een specifiek gegevenstype te declareren. Constanten kunnen niet worden gedeclareerd met de syntaxis “: = ”.

Bijvoorbeeld:

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

Resultaat:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Dingen die u moet weten over constanten in Golang

Numerieke constanten zonder type en met type

Getypte constanten gedragen zich als onveranderlijke variabelen die alleen met dezelfde typen kunnen interacteren. Typeloze constanten gedragen zich als letterlijke constanten die met soortgelijke typen kunnen interacteren. Constanten kunnen in Go met of zonder type worden gedeclareerd. De volgende voorbeelden tonen getypte en niet-getypte, benoemde en niet-benoemde numerieke constanten.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Hier is de lijst met constanten in Go Language:

• Constanten (gehele constanten, dynamische constanten, complexe constanten)
• Reeks tekens
• Booleaanse constante

Getalconstante

Numerieke constanten zijn waarden met een hoge precisie. Omdat Go een statisch getypeerde taal is, zijn bewerkingen die numerieke typen combineren niet toegestaan. Je kunt niet toevoegen float64aan int, of zelfs int32aan int. Het is echter nog steeds geldig om 1e6*time.Secondof math.Exp(1)of zelfs te schrijven 1<>. In Go gedragen constanten zich, in tegenstelling tot variabelen, als gewone getallen.

Er zijn drie typen numerieke constanten:

1. geheel getal
2. drijvende komma
3. complex

Gehele constante:

• Het voorvoegsel specificeert de basis: 0x of 0X voor hexadecimaal, 0 voor octaal en niets voor decimaal.
• Een integer-literal kan ook een suffix hebben dat een combinatie is van U (hoofdletter) en L (kleine letter), respectievelijk voor unsigned en long .
• Het kan een decimale, octale of hexadecimale constante zijn.
• Een int kan een geheel getal van maximaal 64 bits opslaan, soms zelfs minder.

Hier zijn enkele voorbeelden van gehele getallen constanten:

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

Complexe constanten:

Complexe constanten werken op een vergelijkbare manier als drijvende-kommaconstanten. Het is een geordend paar of reëel paar van gehele getallen constanten (of parameters). Constanten worden gescheiden door komma's en getallenparen worden tussen haakjes geplaatst. De eerste constante is het reële deel, de tweede constante is het imaginaire deel. Een complexe constante, COMPLEX*8, gebruikt 8 bytes aan opslagruimte.

Bijvoorbeeld:

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

Dynamische typeconstante:

• Reële getalconstanten bestaan ​​uit een geheel deel, een decimaal deel, een breukdeel en een exponentdeel.
• Kan worden weergegeven als een reële constante in decimale of exponentiële vorm.
• Als het in decimale vorm wordt uitgedrukt, moet het een decimaal punt, een exponent of beide bevatten.
• En als het in exponentiële vorm wordt uitgedrukt, moet het een geheel deel, een breukdeel of beide bevatten.

Bijvoorbeeld:

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

Reeks tekens

• Go ondersteunt twee typen tekenreeksliteralen, namelijk ” ”dubbele aanhalingstekens en ‘ ‘omgekeerde aanhalingstekens.
• +Strings kunnen worden samengevoegd met de en operatoren +=.
• Strings bevatten tekens die lijken op letterlijke tekens: gewone tekens, escape-reeksen en universele tekens. En dit is een personage zonder stijl.
• De nulwaarde van het type string is een lege string, die kan worden weergegeven door ” ”of ”in letterlijke waarden.
• Alle stringtypen kunnen worden vergeleken met behulp van operatoren zoals ==, !=en (om vergelijkbare typen te vergelijken)

Syntaxis:

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

Bijvoorbeeld:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

In deze gevallen zijn alle drie de beweringen hetzelfde, dat wil zeggen dat ze geen specifiek type hebben.

Bijvoorbeeld:

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

Resultaat:

GFG Quantrimang!
true
false

Tijdcomplexiteit: O(1)
Hulpruimte: O(1)

Booleaanse constante

Booleaanse constanten lijken op tekenreeksconstanten. Er worden dezelfde regels toegepast als bij tekenreeksconstanten. Het enige verschil is dat het twee const zonder type trueen heeft 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) 
}

Resultaat:

true
true

Tijdcomplexiteit: O(1)
Hulpruimte: O(1)

Constanten in Go: Go heeft teken-, tekenreeks-, Booleaanse en numerieke constanten. Const declareert een constante waarde. Een bewering constkan voorkomen wanneer er een variabele is en kan dus rekenkundige bewerkingen uitvoeren zonder vaste precisie.

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

Resultaat:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Tijdcomplexiteit: O(1)
Hulpruimte: O(1)

Als u meerdere constanten tegelijk wilt definiëren, kunt u dit doen met behulp van een blok haakjes, zoals hieronder weergegeven.

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

Resultaat:

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