Grundlagen der Go-Konstanten

Einführung

In den vorangegangenen Lektionen haben wir uns mit Variablen in Go beschäftigt. In dieser Lektion werden wir das Konzept der Konstanten untersuchen, wie man sie verwendet und warum sie wichtig sind. Tauchen wir ein in die Welt der Konstanten.

Wissenspunkte:

Was sind Konstanten?
Deklaration von Konstanten
Der iota-Konstantengenerator
Verwendung von Konstanten

Was sind Konstanten?

Einfach ausgedrückt ist eine Konstante ein Wert, der deklariert wird und während der Programmausführung nicht mehr verändert werden kann. Konstanten ermöglichen es dem Compiler, ihre Werte bereits vor der Programmausführung, also während der Kompilierungsphase, zu kennen.

Konstantendeklarationen können spezifische Werte zugewiesen werden. Ihre Syntax ähnelt der von Variablen, aber sobald ein Konstantenwert deklariert ist, bleibt er unveränderlich.

Konstanten sind immer dann nützlich, wenn Sie einen Wert festlegen möchten, der sich niemals ändern darf, wie zum Beispiel eine Webadresse oder ein mathematischer Fixwert wie π (Pi).

Deklaration von Konstanten

Die Deklaration von Konstanten erfolgt ähnlich wie bei Variablen. Das Schlüsselwort var wird dabei durch das Schlüsselwort const ersetzt.

Hinweis: Konstanten müssen bereits bei der Deklaration einen Wert zugewiesen bekommen.

In Go müssen alle Variablen nach ihrer Definition verwendet werden, aber Konstanten bilden hier eine Ausnahme. Selbst wenn sie nicht verwendet werden, löst dies keinen Fehler aus.

Die Syntax für die Deklaration einer Konstante sieht wie folgt aus:

const name [type] = value

name ist der Name der deklarierten Konstante. type ist der Datentyp, der jedoch weggelassen werden kann, da Go diesen automatisch ableiten kann (Type Inference). Der Wert am Ende ist der der Konstante zugewiesene Wert.

Beachten Sie, dass nur die folgenden Typen für Konstantendeklarationen zulässig sind:

Ganzzahl-Typen (Integer)
Gleitkomma-Typen (Floating-point)
Komplexe Typen (Complex)
Boolesche Typen (Boolean)
String-Typen

Schauen wir uns ein Beispiel an. Erstellen Sie eine neue Datei namens const.go im Verzeichnis ~/project:

touch ~/project/const.go

Geben Sie den folgenden Code in const.go ein:

package main

import "fmt"

// Deklaration einer einzelnen Konstante
const labex string = "LabEx" // explizite Angabe des Typs als string
const labs = "LABS"    // wird vom Compiler automatisch als string erkannt

// Deklaration mehrerer Konstanten
const (
    hangzhou, chengdu = "HANGZHOU", "CHENGDU"
    monday, tuesday, wednesday = "MONDAY", "TUESDAY", "WEDNESDAY"
)

func main() {
    fmt.Printf("The type of labex is: %T, and its value is %s\n", labex, labex)
    fmt.Printf("The type of labs is: %T, and its value is %s\n", labs, labs)

    fmt.Println()

    fmt.Println(hangzhou, chengdu)
    fmt.Println(monday, tuesday, wednesday)
}

go run ~/project/const.go

Nach Ausführung des Programms sieht die Ausgabe wie folgt aus:

The type of labex is: string, and its value is LabEx
The type of labs is: string, and its value is LABS

HANGZHOU CHENGDU
MONDAY TUESDAY WEDNESDAY

Hier demonstrieren wir die Deklaration einzelner und mehrerer Konstanten. Bei der Deklaration mehrerer Konstanten empfiehlt es sich, Klammern zu verwenden.

In diesem Programm haben wir nur String-Konstanten gezeigt. Konstanten können jedoch auch andere Typen wie Ganzzahlen oder Booleans annehmen.

Wenn Sie mehrere Konstanten in Klammern deklarieren, gilt: Falls eine Konstante nicht initialisiert wird, erbt sie den Wert der vorangegangenen Konstante.

Geben Sie den folgenden Code in const.go ein:

package main

import "fmt"

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday
    friday
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

Die Ausgabe lautet:

MONDAY TUESDAY WEDNESDAY WEDNESDAY WEDNESDAY

In diesem Fall haben thursday und friday keine expliziten Werte. Gemäß den Regeln von Go passiert Folgendes:

thursday übernimmt den Wert von wednesday.
friday übernimmt ebenfalls den Wert von wednesday.

Dieses Verhalten ermöglicht zwar einen sehr kompakten Code, kann aber zu unerwarteten Ergebnissen führen, wenn man sich dessen nicht bewusst ist.

Wenn Sie möchten, dass thursday und friday eigene Werte haben, müssen Sie diese explizit zuweisen:

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday  = "THURSDAY"
    friday    = "FRIDAY"
)

Dies führt zur erwarteten Ausgabe:

MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY

Der iota-Konstantengenerator

Anstatt Konstanten einzeln zu deklarieren, können wir iota verwenden, um sie blockweise zu definieren. Schauen wir uns ein Beispiel an. Schreiben Sie den folgenden Code in die Datei const.go:

package main

import "fmt"

const (
    monday    = iota // Startwert ist 0
    tuesday   = iota // erhöht sich jedes Mal um 1
    wednesday = iota
    thursday  = iota
    friday    = iota
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

Die Ausgabe lautet:

0 1 2 3 4

Bei der Verwendung von iota ist der Initialwert 0, und er erhöht sich für jedes nachfolgende Element um 1.

Sobald das erste Element deklariert ist, müssen die folgenden Konstanten nicht mehr explizit mit iota zugewiesen werden. Der folgende Code funktioniert ebenfalls einwandfrei:

package main

import "fmt"

const (
    monday    = iota // 0
    tuesday          // 1
    wednesday        // 2
    thursday         // 3
    friday           // 4
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

Was ist, wenn wir einen bestimmten Wert überspringen möchten? In diesem Fall können wir den Unterstrich (_) verwenden. Der folgende Code überspringt die Konstante für Mittwoch:

package main

import "fmt"

const (
    monday  = iota // 0
    tuesday        // 1
    _
    thursday // 3
    friday   // 4
)

func main() {
    fmt.Println(monday, tuesday, thursday, friday)
}

go run ~/project/const.go

Wie Sie sehen können, sieht die Ausgabe so aus:

0 1 3 4

Der iota-Operator kann auch für arithmetische Operationen verwendet werden. Geben Sie den folgenden Code in const.go ein:

package main

import "fmt"

const (
    a = iota     // 0
    b = iota * 3 // 1 * 3
    c = iota + 4 // 2 + 4
)

const (
    B  = 1 << (iota * 10) // entspricht 1 << (0 * 10)
    KB                    // 1024
    MB                    // 1048576
)

func main() {
    fmt.Println(a, b, c)
    fmt.Println(B, KB, MB)
}

go run ~/project/const.go

Die Ausgabe lautet:

0 3 6
1 1024 1048576

Im ersten Block der Konstantendeklarationen nutzen wir iota für einfache Berechnungen.

Im zweiten Block verwenden wir iota zusammen mit dem Linksschiebe-Operator <<, um die Werte von 1 KB und 1 MB in Bezug auf Byte (B) auszudrücken. Zum Beispiel entspricht 1 KB dem Wert 1024B und 1 MB entspricht 1024 * 1024, also 1048576B.

Quiz

Lassen Sie uns das Gelernte festigen. Erstellen Sie eine neue Datei namens iota.go und verwenden Sie iota sowie Konstanten, um die Werte von 1GB und 1TB in Byte (B) auszugeben.

Anforderungen:

Geben Sie die umgerechneten Zahlen nicht direkt als Text aus. Verwenden Sie iota für die Umrechnung.
Die Datei iota.go muss sich im Verzeichnis ~/project befinden.

Hinweis: Sie können sich am Code aus dem Abschnitt "iota" orientieren.

Das erforderliche Ausgabeformat ist wie folgt:

1GB is equal to 1073741824B
1TB is equal to 1099511627776B

Zusammenfassung

Lassen Sie uns Revue passieren lassen, was wir in dieser Lektion gelernt haben:

Konstanten können nach ihrer Deklaration nicht mehr verändert werden.
Konstanten werden mit dem Schlüsselwort const deklariert.
Bei der Deklaration mehrerer Konstanten ist die Verwendung von Klammern vorzuziehen.
Der iota-Konstantengenerator kann für Aufzählungen (Enumerations) verwendet werden.
iota kann auch innerhalb arithmetischer Operationen eingesetzt werden.

In dieser Lektion haben wir die Grundlagen von Konstanten kennengelernt und den iota-Generator eingeführt. Strings, Ganzzahlen, Gleitkommazahlen und Konstanten bilden die Basis-Datentypen in Go.