So verwenden Sie Konstanten in Golang

Was ist eine Konstante oder Const in Golang ? Hier erfahren Sie, was Sie über die Verwendung von Konstanten in Go wissen müssen .

Wie der Name schon sagt, bedeutet Konstante fest. In Programmiersprachen bedeutet dies, dass der Wert einer Konstanten, sobald er definiert ist, nicht mehr geändert werden kann. Konstanten können beliebige grundlegende Datentypen sein, z. B. Ganzzahlkonstanten, dynamische Konstanten, Zeichenkonstanten oder Zeichenfolgen.

Deklaration: Konstanten werden wie Variablen deklariert, verwenden jedoch das Schlüsselwort const als Präfix, um eine Konstante mit einem bestimmten Datentyp zu deklarieren. Konstanten können nicht mit der Syntax „: = “ deklariert werden.

Zum Beispiel:

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

Ergebnis:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Wissenswertes über Konstanten in Golang

Numerische Konstanten ohne Typ und mit Typ

Typisierte Konstanten funktionieren wie unveränderliche Variablen, die nur mit demselben Typ interagieren können, und untypisierte Konstanten funktionieren wie Literalkonstanten, die mit ähnlichen Typen interagieren können. Konstanten können in Go mit oder ohne Typ deklariert werden. Hier sind Beispiele für typisierte und untypisierte, benannte und unbenannte numerische Konstanten.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Hier ist die Liste der Konstanten in der Sprache Go:

• Konstanten (Ganzzahlkonstanten, dynamische Konstanten, komplexe Konstanten)
• Zeichenfolge
• Boolesche Konstante

Zahlenkonstante

Numerische Konstanten sind hochpräzise Werte. Da Go eine statisch typisierte Sprache ist, sind Operationen, die numerische Typen kombinieren , nicht zulässig. Sie können weder float64, intnoch int32...int1e6*time.Secondmath.Exp(1)1<>

Es gibt drei Typen numerischer Konstanten:

1. ganze Zahl
2. Gleitkomma
3. Komplex

Ganzzahlige Konstante:

• Das Präfix gibt die Basis an: 0x oder 0X für Hexadezimal, 0 für Oktal und nichts für Dezimal.
• Ein Integer-Literal kann auch ein Suffix haben, das eine Kombination aus U (Großbuchstabe) und L (Kleinbuchstabe) für „unsigned“ bzw. „long“ ist.
• Es kann sich um eine dezimale, oktale oder hexadezimale Konstante handeln.
• Ein int kann bis zu 64-Bit-Ganzzahlen speichern, manchmal auch weniger.

Hier sind einige Beispiele für Integer-Konstanten:

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

Komplexe Konstanten:

Eine komplexe Konstante funktioniert sehr ähnlich wie eine Gleitkommakonstante. Sie ist ein geordnetes Paar oder eine reelle Zahl einer ganzzahligen Konstante (oder eines Parameters). Die Konstanten sind durch Kommas getrennt, und das Zahlenpaar ist in Klammern eingeschlossen. Die erste Konstante ist der Realteil, die zweite der Imaginärteil. Eine komplexe Konstante, COMPLEX*8, benötigt 8 Byte Speicherplatz.

Zum Beispiel:

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

Dynamische Typkonstante:

• Reelle Zahlenkonstanten haben einen ganzzahligen Teil, einen Dezimalteil, einen Bruchteil und einen Exponententeil.
• Kann als reelle Konstante in Dezimal- oder Exponentialform dargestellt werden.
• Bei der Angabe in Dezimalform muss ein Dezimalpunkt, ein Exponent oder beides enthalten sein.
• Und wenn es in Exponentialform ausgedrückt wird, muss es einen ganzzahligen Teil, einen Bruchteil oder beides enthalten.

Zum Beispiel:

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

Zeichenfolge

• Go unterstützt zwei Arten von Zeichenfolgenliteralen, nämlich ” ”(Anführungszeichenstil) und ‘ ‘(Anführungszeichenstil).
• +Zeichenfolgen können mit den Operatoren und verkettet werden +=.
• Zeichenfolgen enthalten dieselben Zeichen wie Literalzeichen: einfache Zeichen, Escape-Sequenzen und universelle Zeichen. Und dies ist ein Zeichen ohne Typ.
• Der Nullwert von Zeichenfolgentypen ist die leere Zeichenfolge, die durch ” ”oder ”in Literalen dargestellt werden kann.
• Alle Zeichenfolgentypen können mit Operatoren wie und verglichen werden ==( !=um ähnliche Typen zu vergleichen).

Syntax:

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

Zum Beispiel:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

Hier sind alle drei Anweisungen gleich, das heißt, sie haben keinen bestimmten Typ.

Zum Beispiel:

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

Ergebnis:

GFG Quantrimang!
true
false

Zeitliche Komplexität: O(1)
Hilfsspeicher: O(1)

Boolesche Konstante

Boolesche Konstanten ähneln String-Konstanten. Sie folgen denselben Regeln wie String-Konstanten. Der einzige Unterschied besteht darin, dass sie zwei Nicht-Typ-Konstanten haben, trueund 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) 
}

Ergebnis:

true
true

Zeitliche Komplexität: O(1)
Hilfsspeicher: O(1)

Konstanten in Go: Go kennt Zeichen-, String-, Boolesche und numerische Konstanten. Const deklariert einen konstanten Wert. Eine Anweisung, die constbei Vorhandensein einer Variable auftreten kann und somit Rechenoperationen ohne feste Genauigkeit ausführt.

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

Ergebnis:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Zeitliche Komplexität: O(1)
Hilfsspeicher: O(1)

Wenn Sie mehrere Konstanten gleichzeitig definieren möchten, können Sie dies mithilfe eines Klammerblocks tun, wie unten gezeigt.

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

Ergebnis:

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