Lernen von Golang-Variablen und Konstanten

1. Variablen und Konstanten

In Golang sind Variablen und Konstanten zwei grundlegende Konzepte, die eine sehr wichtige Rolle in einem Programm spielen.

• Eine Variable ist ein benannter Bezeichner, der Daten in einem Programm speichert. In Golang wird das var-Schlüsselwort verwendet, um Variablen zu deklarieren.
• Eine Konstante ist ein Bezeichner, dessen Wert im Programm nicht geändert werden kann. In Golang wird das const-Schlüsselwort verwendet, um Konstanten zu deklarieren.

2. Deklaration und Initialisierung von Golang-Variablen

2.1 Deklaration und Zuweisung einer einzelnen Variablen

In der Go-Sprache wird das var-Schlüsselwort verwendet, um eine Variable mit dem Format var Variablenname Typ zu deklarieren. Nach der Deklaration kann der Variable im nachfolgenden Code ein Wert zugewiesen werden, oder sie kann direkt bei der Deklaration initialisiert werden. Zum Beispiel:

var alter int // Deklariere eine Integer-Variable Alter
alter = 25    // Weise der Variable einen Wert zu

var name string = "Alice" // Deklariere und initialisiere die Variable Name

2.2 Deklaration mehrerer Variablen

Die Go-Sprache unterstützt die gleichzeitige Deklaration mehrerer Variablen, was den Code knapper machen kann. Die Massendeklaration erfolgt in der Regel am Anfang einer Funktion oder auf Paketebene. Zum Beispiel:

var (
    vorname, nachname string
    alter             int
)

vorname = "John"
nachname = "Doe"
alter = 30

In der oben genannten Massendeklaration werden vorname und nachname als Strings deklariert, während alter eine Ganzzahl ist.

2.3 Typinferenz und kurze Variabledeklaration

In der Go-Sprache ist es nicht immer erforderlich, den Typ der Variablen explizit anzugeben. Wenn bei der Deklaration einer Variable ein Initialisierungsausdruck bereitgestellt wird, kann Go den Typ der Variablen ableiten. Dies wird als Typinferenz bezeichnet. Die kurze Variabledeklaration unter Verwendung von := kann die Anweisung zur Deklaration und Initialisierung von Variablen basierend auf der Typrückschluss vereinfachen. Zum Beispiel:

stadt := "Berlin"  // Verwende kurze Variabledeklaration, um gleichzeitig die Stadt zu deklarieren und zu initialisieren
land := "Deutschland" // Das Land wird als String-Typ inferiert

Es ist wichtig zu beachten, dass kurze Variabledeklarationen nur innerhalb von Funktionen verwendet werden können und nicht auf globaler Ebene.

2.4 Deklaration von Variablen außerhalb von Funktionen

Variablen, die außerhalb von Funktionen deklariert werden, haben einen Paketebene-Geltungsbereich. Diese Variablen sind im gesamten Paket sichtbar und zugänglich. Zum Beispiel:

var globaleVar string = "Ich bin global" // Deklaration einer globalen Variablen

func druckeGlobaleVar() {
    fmt.Println(globaleVar) // Zugriff auf die globale Variable innerhalb der Funktion
}

Globale Variablen können zwischen beliebigen Funktionen innerhalb des Pakets geteilt werden, sollten jedoch sorgfältig verwendet werden, um potenzielle Namenskonflikte und unklare Referenzen zu vermeiden.

Tipp: Ein grundlegendes Verständnis des Funktionscodes hier ist ausreichend, ausführliche Erläuterungen zu Funktionen werden in späteren Abschnitten bereitgestellt.

3. Grundlegende Datentypen und Nullwerte

3.1 Grundlegende Datentypen in Golang

In der Go-Sprache bietet jeder Variablentyp explizite Semantik und Verhaltensmerkmale. Hier sind einige gängige grundlegende Datentypen:

• int, int8, int16, int32, int64: Unterschiedliche Bereich von Ganzzahlen
• uint, uint8, uint16, uint32, uint64: Vorzeichenlose Ganzzahlen
• float32, float64: Gleitkommazahlen
• bool: Boolesche Werte (true oder false)
• string: Zeichenfolgen

3.2 Konzept der Nullwerte

In der Go-Sprache werden Variablen nach der Deklaration automatisch auf ihren Nullwert initialisiert. Der Nullwert bezieht sich auf den Standardwert des entsprechenden Typs, wenn eine Variable nicht explizit initialisiert wird. Dies ist in einigen anderen Sprachen nicht üblich, aber in Go stellt dies sicher, dass alle Variablen immer einen gültigen Anfangswert haben. Hier sind die Nullwerte für jeden grundlegenden Datentyp:

• Der Nullwert für eine Ganzzahl ist 0
• Der Nullwert für eine Gleitkommazahl ist 0.0
• Der Nullwert für ein Booleschen Wert ist false
• Der Nullwert für eine Zeichenfolge ist eine leere Zeichenfolge ""

Zum Beispiel:

var i int     // Nullwert ist 0
var f float64 // Nullwert ist 0.0
var b bool    // Nullwert ist false
var s string  // Nullwert ist ""

Das Verständnis des Konzepts der Nullwerte ist sehr wichtig, da es den Entwicklern helfen kann, das Verhalten der Variableninitialisierung zu verstehen und dazu verwendet werden kann, null-Pointer oder nicht initialisierte Fehler zu verhindern.

4. Geltungsbereich von Variablen

4.1 Lokale Variablen

Lokale Variablen sind Variablen, die innerhalb einer Funktion definiert sind, und sie können nur innerhalb dieser Funktion zugegriffen werden. Auch die Funktionsparameter gehören zu den lokalen Variablen. Von dem Moment an, an dem sie erstellt werden, bis die Funktion vollständig ausgeführt ist, verschwinden lokale Variablen. Jedes Mal, wenn eine Funktion aufgerufen wird, werden lokale Variablen neu erstellt.

func lokaleVariablenBeispiel() {
    var lokaleVariable int = 10 // Dies ist eine lokale Variable
    fmt.Println(lokaleVariable)
}

func main() {
    lokaleVariablenBeispiel() // Ausgabe: 10
    // fmt.Println(lokaleVariable) // Dies führt zu einem Kompilierungsfehler, da lokaleVariable hier nicht sichtbar ist
}

In dem obigen Beispiel kann lokaleVariable nur innerhalb der Funktion lokaleVariablenBeispiel zugegriffen werden.

4.2 Globale Variablen

Globale Variablen sind Variablen, die außerhalb von Funktionen definiert sind und in jeder Datei innerhalb des gleichen Pakets zugegriffen werden können. Wenn Sie globale Variablen in anderen Paketen verwenden möchten, muss der Variablennamen gemäß den Zugriffssteuerungsregeln von Go mit einem Großbuchstaben beginnen.

package main

import "fmt"

var globaleVariable int = 20 // Dies ist eine globale Variable

func main() {
    fmt.Println(globaleVariable) // Ausgabe: 20
    globaleÄndern()
    fmt.Println(globaleVariable) // Ausgabe: 30
}

func globaleÄndern() {
    globaleVariable = 30 // Ändere den Wert der globalen Variable
}

In diesem Beispiel ist globaleVariable sowohl in der Funktion main als auch in der Funktion globaleÄndern sichtbar.

5 Deklaration und Verwendung von Konstanten

5.1 Das const-Schlüsselwort

Wir verwenden das const-Schlüsselwort, um Konstanten zu definieren. Konstanten sind Werte, die nicht geändert werden können, und sobald sie definiert sind, kann ihr Wert nicht geändert werden. Konstanten können jeden grundlegenden Datentyp wie Ganzzahlen, Gleitkommazahlen, Booleans oder Zeichenketten haben.

const Pi = 3.14 // Deklariere eine Gleitkommakonstante
const StrKonst string = "Hallo, Welt!" // Deklariere eine Zeichenkettenkonstante

func main() {
    fmt.Println(Pi)
    fmt.Println(StrKonst)
}

5.2 Aufzählungskonstanten

Die Go-Sprache hat keinen spezifischen Aufzählungstyp, aber Sie können das Schlüsselwort iota verwenden, um Aufzählungen zu erreichen. Innerhalb eines const-Blocks wird bei jeder zusätzlichen Konstantendeklaration der Wert von iota um 1 erhöht.

const (
    Sonntag = iota  // 0
    Montag         // 1
    Dienstag        // 2
    Mittwoch      // 3
    Donnerstag       // 4
    Freitag         // 5
    Samstag       // 6
)

func main() {
    fmt.Println(Sonntag)    // Ausgabe: 0
    fmt.Println(Samstag)  // Ausgabe: 6
}

Der obige Code deklariert eine Aufzählung für die Wochentage, wobei iota innerhalb des const-Blocks bei 0 initialisiert wird und für jede weitere Deklaration um 1 erhöht wird.

5.3 Gültigkeitsbereich von Konstanten

Der Gültigkeitsbereich von Konstanten ist ähnlich wie bei Variablen. Wenn eine Konstante innerhalb einer Funktion definiert ist, ist ihr Gültigkeitsbereich auf diese Funktion beschränkt. Wenn eine Konstante außerhalb einer Funktion (global) definiert ist, ist ihr Gültigkeitsbereich das gesamte Paket, und wenn der erste Buchstabe groß geschrieben ist, kann sie in anderen Paketen zugriffen werden.

Die Verwaltung des Gültigkeitsbereichs von Konstanten hilft dabei, die globale Gültigkeit zu reduzieren und die Programmpflege und Lesbarkeit zu verbessern.

const GlobaleKonst = "Dies ist eine globale Konstante"

func main() {
    const LokaleKonst = "Dies ist eine lokale Konstante"
    fmt.Println(GlobaleKonst)  // Dies ist gültig
    fmt.Println(LokaleKonst)   // Dies ist gültig
}

func eineAndereFunktion() {
    // fmt.Println(LokaleKonst) // Dies führt zu einem Kompilierungsfehler: LokaleKonst ist in dieser Funktion nicht sichtbar
    fmt.Println(GlobaleKonst)  // Dies ist gültig
}

In diesem Beispiel kann LokaleKonst nur innerhalb der Funktion main zugegriffen werden, während GlobaleKonst im gesamten Paket zugänglich ist.