Einführung in Go-Variablen

Einführung

Warum benötigen wir Variablen in Programmiersprachen? Das ist eine sehr alte Frage. So wie wir uns merken können, dass die URL von LabEx labex.io lautet, müssen sich auch Computerprogramme bestimmte Daten für ihre Verwendung merken.

Variablen dienen dazu, einen Datenwert darzustellen. In diesem Abschnitt untersuchen Sie, wie Variablen in der Sprache Go verwendet werden.

Wichtige Lernpunkte:

• Variablendeklaration
• Variableninitialisierung
• Variablenverwendung
• Lebensdauer von Variablen
• Konstanten

Was ist eine Variable?

In diesem Schritt lernen Sie, welche Daten Variablen darstellen und welche Regeln Go für ihre Namen und Typen vorgibt.

Was ist eine Variable? Einfach ausgedrückt ist eine Variable ein Container, in dem ein veränderlicher Datenwert gespeichert wird.

In kompilierten Sprachen wie Go ist der Typ einer Variable festgelegt.

Was bedeutet es, dass der Typ einer Variable festgelegt ist?

Das bedeutet, dass eine Variable nur Daten eines einzigen Typs enthalten kann. Anders gesagt: Die in dem Variablencontainer gespeicherten Elemente haben einen festen Typ.

Wenn eine Variable Obst aufnehmen soll, darf sie nur Obst enthalten. Sobald der Container Obst enthalten hat, kann er nicht zum Aufbewahren von Keksen verwendet werden. Im Code bedeutet das, dass einer Variable nicht zwei Datenwerte unterschiedlichen Typs zugewiesen werden können.

Veränderbarkeit von Variablen

Wie der Name bereits sagt, kann sich der Wert einer Variable ändern, solange der neue Wert den für ihren Typ zulässigen Bereich nicht überschreitet.

Für Variablen gelten in Go die folgenden Regeln:

• Der Name muss aus Buchstaben, Ziffern und Unterstrichen bestehen.
• Der Bezeichner darf nicht mit einer Ziffer beginnen.
• Der Bezeichner darf kein reserviertes Schlüsselwort sein. Reservierte Schlüsselwörter anzeigen
• Bei Variablennamen wird zwischen Groß- und Kleinschreibung unterschieden. Es wird jedoch nicht empfohlen, zwei Variablen mit demselben Namen nur durch unterschiedliche Groß- und Kleinschreibung voneinander zu unterscheiden.

Allgemeine Deklarationsmethode

In diesem Schritt lernen Sie, wie Sie mit dem Schlüsselwort var eine typisierte Variable deklarieren.

In Go wird für die allgemeine Variablendeklaration das Schlüsselwort var verwendet.

Die Deklarationsform lautet var identifier type. Das bedeutet:

var variableName variableType.

Welche Variablentypen werden in Go häufig verwendet?

Da die Variablentypen nicht im Mittelpunkt dieses Abschnitts stehen, werden hier nur die drei häufigsten Typen aufgeführt.

Weitere Typen werden in den folgenden Kursen erklärt.

Wie deklarieren wir eine Variable?

Deklarieren Sie nun eine Ganzzahlvariable mit dem Namen a.

var a int

Wie können Sie sich diese Schreibweise merken? Sagen Sie sich im Kopf:

Define a variable named `a`, which is of type int.

Anders als in vielen herkömmlichen Programmiersprachen steht der Variablentyp in Go nach dem Variablennamen.

Dadurch lässt sich der Code leichter von links nach rechts lesen. Außerdem wird die verschachtelte Leselogik der Sprache C vermieden. Weitere Informationen finden Sie in der offiziellen Dokumentation.

Welchen Namen sollten wir einer Variable geben?

Ein guter Variablenname sollte klar erkennen lassen, welche Bedeutung die Variable hat.

Achten Sie beim Benennen von Variablen auf eine aussagekräftige Schreibweise und vermeiden Sie Abkürzungen.

Hier stellen wir kurz die grundlegende Methode der Variablenbenennung vor: die CamelCase-Schreibweise.

Bei der CamelCase-Schreibweise werden Groß- und Kleinbuchstaben gemischt verwendet, um eine Variable zu benennen. Das erste Wort beginnt mit einem Kleinbuchstaben, und der erste Buchstabe jedes weiteren Wortes wird großgeschrieben.

Beispiel: currentDate. Das erste Wort current beginnt mit einem Kleinbuchstaben, während das zweite Wort Date mit einem Großbuchstaben beginnt.

Auf diese Weise ist leicht zu erkennen, dass die Variable das aktuelle Datum darstellt.

Diese Schreibweise wird im Allgemeinen für wichtige und häufig verwendete Variablen verwendet. Temporäre Variablen können Sie vereinfachen, solange dadurch keine Namenskonflikte entstehen.

Deklaration mehrerer Variablen

In diesem Schritt lernen Sie, wie Sie mehrere Variablen gemeinsam deklarieren.

Deklarieren Sie nun drei Variablen:

var a int // Declare an integer variable named a
var b int // Declare an integer variable named b
var c int // Declare an integer variable named c

Aufmerksame Lernende haben vielleicht bemerkt, dass alle drei Variablen a, b, c den Typ int haben.

In diesem Fall können Sie die Variablennamen mit einem Komma verbinden und dadurch Code einsparen.

var a, b, c int // Declare three variables a, b, c as integers

Was aber, wenn die drei Variablen unterschiedliche Typen haben?

var a int    // Declare an integer variable named a
var b string // Declare a string variable named b
var c bool   // Declare a boolean variable named c

Eine ähnliche Situation kennen Sie vielleicht vom Importieren von Paketen. Mehrere Pakete mit unterschiedlichen Namen müssen gemeinsam importiert werden. Dafür können Sie eine ähnliche Schreibweise verwenden:

var (
    a int
    b string
    c bool
)

Beachten Sie, dass diese an das Importieren von Paketen erinnernde Deklarationsform im Allgemeinen zum Definieren globaler Variablen verwendet wird.

Standardinitialisierung

In diesem Schritt untersuchen Sie die Standardwerte, die Go Variablen zuweist.

In Go erhalten alle Variablen bei ihrer Deklaration einen Anfangswert. Untersuchen Sie nun, welche Anfangswerte Variablen erhalten.

Erstellen Sie im Verzeichnis ~/project eine Datei namens varExercise.go.

touch ~/project/varExercise.go

Schreiben Sie den folgenden Code in die Datei:

package main

import "fmt"

func main() {
    var a int
    var b string
    var c bool
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Führen Sie den Code selbst aus und prüfen Sie, ob die Ausgabe mit der folgenden Tabelle übereinstimmt.

go run varExercise.go

Die Anfangswerte der Typen sind wie folgt zusammengefasst:

Explizite Initialisierung

In diesem Schritt initialisieren Sie Variablen explizit und weisen ihnen anschließend neue Werte zu.

Da Go den Typ einer Variable anhand ihres Anfangswerts bestimmen kann: Können wir den Standardwert oder den Wert einer bereits deklarierten Variable ändern?

var a int = 1
var b string = "labex"
var c bool = true

a = 233
b = "labex"
c = false

Wie oben gezeigt, müssen Sie nach der Variablendeklaration lediglich = und anschließend einen Anfangswert hinzufügen, der mit dem Variablentyp kompatibel ist. Um den Wert zu ändern, schreiben Sie den Variablennamen gefolgt von = und einem weiteren Wert desselben Typs.

Ändern Sie die Datei varExercise.go:

package main

import "fmt"

func main() {
    // Declare and initialize
    var a int = 1
    var b string = "labex"
    var c bool = true

    // Print the variables
    fmt.Println("Before modification:")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)

    // Modify the variables
    a = 233
    b = "labex"
    c = false

    // Print the modified variables
    fmt.Println("After modification:")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Nach der Ausführung des Codes erhalten Sie folgende Ausgabe:

$ go run varExercise.go
Before modification:
1
labex
true
After modification:
233
labex
false

Führen Sie den Code selbst aus und ändern Sie die Anfangswerte.

Wir haben bereits erwähnt, dass der einer Variable zugewiesene Anfangswert denselben Typ wie die Variablendeklaration haben muss. Was geschieht, wenn die Typen unterschiedlich sind?

Weisen Sie beispielsweise der Variable a den String "labex" als Anfangswert zu:

package main

import "fmt"

func main() {
    var a int = "labex"
    fmt.Println(a)
}

Führen Sie den Code aus:

$ go run varExercise.go
## command-line-arguments
./varExercise.go:6:12: cannot use "labex" (type untyped string) as type int in assignment

Wie die Ausgabe zeigt, können Sie einer Variable vom Typ int keinen String wie "labex" zuweisen. Go ist eine stark typisierte kompilierte Sprache, daher kann der Code nicht kompiliert werden.

Typdeklaration durch Inferenz

In diesem Schritt deklarieren Sie lokale Variablen mithilfe der Typinferenz und des Operators :=.

Da Go den Typ einer Variable anhand ihres Anfangswerts bestimmen kann: Lässt sich die Typdeklaration vereinfachen, indem wir die explizite Angabe des Typs weglassen?

package main

import "fmt"

func main() {
    // var a int = 1
    var a = 1 // Type is inferred
    fmt.Println(a)
}

Jetzt müssen Sie nicht einmal mehr das Schlüsselwort var verwenden, um eine Variable zu definieren.

Diese Methode zum Deklarieren und Initialisieren einer Variable kann auch mit der Deklaration mehrerer Variablen kombiniert werden:

a, b, c := 0, 0, 0
// Declare variables a, b, c as integers and assign 0 to each variable.

Alternativ können Sie die Variablen mit Werten unterschiedlicher Typen initialisieren:

a, b, c := 0, "", true
// Declare variables a, b, c as integer, string, and boolean, respectively.

Für jede Variable auf der linken Seite von := muss auf der rechten Seite ein entsprechender Anfangswert vorhanden sein.

Die Kurzdeklaration ist sehr praktisch. Beachten Sie jedoch, dass := keine Zuweisungsoperation ist. Es handelt sich um eine für Go typische Methode, mit der lokale Variablen innerhalb einer Funktion deklariert und initialisiert werden. Der Variablentyp wird automatisch anhand des Ausdrucks abgeleitet.

Manchmal schreiben wir den folgenden Code:

func main() {
    a := 1
    println(a)
    a := 2
    println(a)
}

Der Compiler meldet einen Fehler, weil die Variable a erneut deklariert wurde. Wenn der Code jedoch folgendermaßen geschrieben wird:

func main() {
    a := 1
    if true {
        a := 2
        println(a) // Output: 2
    }
    println(a) // Output: 1
}

Entsteht diese Ausgabe, weil sich die Variable a mit dem Wert 1 und die Variable a mit dem Wert 2 nicht im selben Variablen-Gültigkeitsbereich befinden, also nicht innerhalb derselben geschweiften Klammern. Daher behandelt der Compiler sie als zwei unterschiedliche Variablen.

Der Compiler weist Sie nicht auf diesen Fehler hin, aber die Ausgabe ist möglicherweise unerwartet.

In Go gilt folgende Regel:

Jede Anweisung außerhalb einer Funktion muss mit einem Schlüsselwort beginnen (var, func usw.).

Daher kann die Kurzdeklaration nur zum Deklarieren lokaler Variablen verwendet werden, nicht zum Deklarieren globaler Variablen.

Was ist also eine globale und was ist eine lokale Variable?

Damit kommen wir zum Konzept der Lebensdauer von Variablen. Dieses wird im nächsten Abschnitt erklärt.

Variablen-Gültigkeitsbereich

In diesem Schritt vergleichen Sie die Gültigkeitsbereiche lokaler Variablen, globaler Variablen und formaler Parameter.

Der Variablen-Gültigkeitsbereich bezeichnet den Bereich, in dem eine Variable in einem Programm wirksam ist, also verwendet werden kann.

Sie haben sicher bemerkt, dass der Code nicht kompiliert wird, wenn Sie eine Variable deklarieren, sie aber nicht verwenden.

Beim Kompilieren prüft Go also, ob jede Variable verwendet wurde, das heißt, ob sie innerhalb ihres Gültigkeitsbereichs verwendet wurde.

Je nach Position ihrer Deklaration können wir Variablen einfach in drei Typen einteilen:

• Variablen, die innerhalb einer Funktion definiert werden, heißen lokale Variablen.
• Variablen, die außerhalb einer Funktion definiert werden, heißen globale Variablen.
• Variablen, die innerhalb einer Funktionsdefinition angegeben werden, heißen formale Parameter.

Lokale Variablen

Die meisten Variablen, die wir in diesem Abschnitt definieren, sind lokale Variablen:

package main

import "fmt"

func main() { // Function body
    var a int = 1 // Local variable
    fmt.Println(a)
}

Lokale Variablen werden innerhalb des Funktionskörpers definiert, etwa a innerhalb der Funktion main. Der Gültigkeitsbereich der Variable a ist auf die Funktion main beschränkt.

Wenn die Variable in der Funktion main nicht verwendet wird, meldet der Compiler außerdem einen Fehler.

Globale Variablen

Sie können jedoch auch eine globale Variable definieren.

package main

import "fmt"

var a int = 1 // Global variable
func main() { // Function body
    fmt.Println(a)
}

Globale Variablen werden außerhalb des Funktionskörpers definiert. Ihr Gültigkeitsbereich umfasst das gesamte Programm. Auch wenn sie in keiner Funktion aufgerufen werden, meldet der Compiler keinen Fehler.

Überlegen Sie, warum globale Variablen auch dann keinen Fehler verursachen, wenn sie nicht aufgerufen werden.

Details zu formalen Parametervariablen werden in den folgenden Kursen zu Funktionen erklärt.

Lebensdauer von Variablen

In diesem Schritt lernen Sie, wie lange Variablen zugänglich bleiben und warum eine Variable im selben Gültigkeitsbereich nicht erneut deklariert werden kann.

Vögel, die davonfliegen, verbergen die Spannweite. Listige Hasen sterben, und Hunde werden schmoren. – Aufzeichnungen des Großen Historikers

Wenn eine Variable ihre Aufgabe erfüllt hat, sollte sie zerstört werden, um den Speicherverbrauch zu verringern.

• Globale Variablen: Die Lebensdauer einer globalen Variable entspricht der gesamten Laufzeit des Programms. Wenn das Programm beendet wird, wird die globale Variable aus dem Speicher entfernt.
• Lokale Variablen: Wenn es keine Möglichkeit mehr gibt, auf eine Variable zuzugreifen, wird der von ihr belegte Speicher zurückgewonnen.

Dieses Design ist entscheidend für die hohe Leistung und die effiziente Speichernutzung von Go.

Während der Lebensdauer einer Variable kann sie nicht erneut deklariert werden.

Schreiben Sie Folgendes in varExercise.go:

package main

import "fmt"

func main() {
    var a int = 1 // Local variable, lifetime is limited to the entire main function
    var a int = 2 // Redefinition
    fmt.Println(a)
}

Führen Sie den Code aus:

go run varExercise.go

Sie sehen folgende Fehlermeldung:

./varExercise.go:7:9: a redeclared in this block
previous declaration at ./varExercise.go:6:9

Der Compiler teilt uns mit, dass a erneut definiert wurde.

Konstanten

In diesem Schritt deklarieren Sie Konstanten und bestimmen, welche Ausdrücke gültige konstante Werte sind.

Viele Dinge im Leben sind wie Konstanten. Wir können sie wahrnehmen, aber nicht verändern.

Wenn sich eine Variable während der gesamten Laufzeit des Programms nicht ändert, sollten Sie sie als Konstante definieren.

Konstanten ähneln Variablen stark. Sie können sie sich sogar als Variablen mit unveränderlichen Werten vorstellen.

Beim Deklarieren einer Konstante müssen Sie lediglich das Schlüsselwort var durch das Schlüsselwort const ersetzen.

const Pi = 3.14159 // Using type inference initialization

Erstellen Sie im Verzeichnis ~/project eine Datei namens constExercise.go.

touch ~/project/constExercise.go

Was geschieht, wenn wir versuchen, eine Konstante zu ändern?

package main

import "fmt"

func main() {
    const Pi = 3.14159
    Pi = 2 // Error: cannot assign to Pi
    fmt.Println(Pi)
}

Führen Sie den Code aus.

$ go run constExercise.go
## command-line-arguments
./constExercise.go:7:8: cannot assign to Pi

Der Compiler teilt uns mit, dass der Wert von Pi nicht erneut zugewiesen werden kann.

Bei der Deklaration einer Konstante müssen Sie einen Anfangswert angeben.

Der einer Konstante zugewiesene Anfangswert muss außerdem zur Kompilierungszeit feststehen.

Rückgabewerte benutzerdefinierter Funktionen gelten in Go nicht als zur Kompilierungszeit feststehend.

var a int = 1
// Value is fixed, declaration is valid.
const Pi = 3.14159
// The calculated value is also fixed, the declaration is valid.
const c = 1 / Pi
// Fixed return value from built-in function is valid.
const le = len("labex")
// The return value of the user-defined function is not fixed, the declaration is invalid.
const le = getLen("labby")
// `a` is a variable value that is not fixed, the declaration is invalid.
const k = a

Ob eine Konstantendeklaration gültig ist, lässt sich in der folgenden Tabelle zusammenfassen:

Zusammenfassung

Wiederholen wir, was Sie in diesem Lab gelernt haben:

• Möglichkeiten zum Deklarieren von Variablen
• Möglichkeiten zum Initialisieren von Variablen
• Das Konzept der Lebensdauer von Variablen
• Die Verwendung von Konstanten und die Frage, ob ihre Deklarationen gültig sind

In diesem Lab haben wir die grundlegende Verwendung von Variablen in Go wiederholt, Möglichkeiten zum Deklarieren und Verwenden von Variablen in verschiedenen Situationen gezeigt und Konstanten vorgestellt.