Wie Variablen und Konstanten in Go verwendet werden

Variablen sind ein wichtiges Programmierkonzept, das zu beherrschen ist. Sie sind Symbole, die für einen Wert stehen, den Sie in einem Programm verwenden.

Dieses Tutorial behandelt einige Grundlagen und Best Practices für die Verwendung von Variablen in den Go-Programmen, die Sie erstellen.

Variablen verstehen

In technischer Hinsicht ist eine Variable die Zuweisung eines Speicherorts zu einem Wert, der an einen symbolischen Namen oder Bezeichner gebunden ist. Wir verwenden den Variablennamen, um auf diesen gespeicherten Wert in einem Computerprogramm zu verweisen.

Man kann sich eine Variable als Etikett vorstellen, auf dem ein Name steht und das man an einen Wert bindet.

Nehmen wir an, wir haben eine Ganzzahl, 1032049348, und wir möchten sie in einer Variablen speichern, anstatt die lange Zahl immer wieder neu einzugeben. Um dies zu erreichen, können wir einen leicht zu merkenden Namen verwenden, wie die Variable i. Um einen Wert in einer Variablen zu speichern, verwenden wir die folgende Syntax:

i := 1032049348

Man kann sich diese Variable wie ein Etikett vorstellen, das an den Wert gebunden ist.

Das Etikett trägt den Variablennamen i und ist an den Integer-Wert 1032049348 gebunden.

Der Ausdruck i := 1032049348 ist eine Deklarations- und Zuweisungsanweisung, die aus mehreren Teilen besteht:

• der Variablenname (i)
• die kurze Variablendeklarationszuweisung (:=)
• Der Wert, der dem Variablennamen (1032049348)
• zugeordnet wird, der von Go inferierte Datentyp (int)

Wir werden später sehen, wie man den Typ im nächsten Abschnitt explizit setzt.

Zusammen bilden diese Teile die Anweisung, die die Variable i gleich dem Wert der ganzen Zahl 1032049348 setzt.

Sobald wir eine Variable gleich einem Wert setzen, initialisieren wir oder erstellen diese Variable. Sobald wir das getan haben, sind wir bereit, die Variable anstelle des Wertes zu verwenden.

Sobald wir i gleich dem Wert von 1032049348 gesetzt haben, können wir i anstelle der ganzen Zahl verwenden, also lassen Sie uns das ausdrucken:

package main

import "fmt"

func main() {
	i := 1032049348
	fmt.Println(i)
}

Output
1032049348

Wir können auch schnell und einfach Mathematik mit Variablen durchführen. Mit i := 1032049348 können wir den ganzzahligen Wert 813 mit der folgenden Syntax subtrahieren:

fmt.Println(i - 813)

Output
1032048535

In diesem Beispiel führt Go die Mathematik für uns durch, indem es 813 von der Variable i subtrahiert, um die Summe 1032048535 zurückzugeben.

Wenn es um Mathematik geht, können Variablen gleich dem Ergebnis einer mathematischen Gleichung gesetzt werden. Sie können auch zwei Zahlen addieren und den Wert der Summe in der Variable x speichern:

x := 76 + 145

Sie haben vielleicht bemerkt, dass dieses Beispiel wie Algebra aussieht. In der gleichen Weise, wie wir Buchstaben und andere Symbole verwenden, um Zahlen und Mengen in Formeln und Gleichungen darzustellen, sind Variablen symbolische Namen, die den Wert eines Datentyps repräsentieren. Für korrekte Go-Syntax müssen Sie sicherstellen, dass Ihre Variable auf der linken Seite jeder Gleichung steht.

Lassen Sie uns x ausdrucken:

package main

import "fmt"

func main() {
	x := 76 + 145
	fmt.Println(x)
}

Output
221

Go hat den Wert 221 zurückgegeben, weil die Variable x auf die Summe von 76 und 145 gesetzt wurde.

Variablen können jeden Datentyp repräsentieren, nicht nur ganze Zahlen:

s := "Hello, World!"
f := 45.06
b := 5 > 9 // Ein boolescher Wert gibt entweder true oder false zurück
array := [4]string{"item_1", "item_2", "item_3", "item_4"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}

Wenn Sie eine dieser Variablen ausgeben, gibt Go das zurück, wozu die Variable äquivalent ist. Lassen Sie uns mit der Zuweisungsanweisung für den Datentyp slice von Zeichenketten arbeiten:

package main

import "fmt"

func main() {
	slice := []string{"one", "two", "three"}
	fmt.Println(slice)
}

Output
[one two three]

Wir haben den Slice-Wert []string{"one", "two", "three"} der Variable slice zugewiesen und dann die Funktion fmt.Println verwendet, um diesen Wert auszugeben, indem wir slice aufgerufen haben.

Variablen funktionieren, indem sie einen kleinen Speicherbereich in Ihrem Computer reservieren, der spezifizierte Werte akzeptiert, die dann mit diesem Bereich verbunden sind.

Variablen deklarieren

In Go gibt es mehrere Möglichkeiten, eine Variable zu deklarieren, und in einigen Fällen mehr als eine Möglichkeit, genau dieselbe Variable und denselben Wert zu deklarieren.

Wir können eine Variable namens i vom Datentyp int ohne Initialisierung deklarieren. Das bedeutet, dass wir einen Platz zum Speichern eines Werts deklarieren, ihn aber nicht mit einem Anfangswert versehen:

var i int

Dadurch wird eine Variable namens i vom Datentyp int deklariert.

Wir können den Wert mithilfe des Gleichheitsoperators (=) initialisieren, wie im folgenden Beispiel:

var i int = 1

In Go werden beide Formen der Deklaration als lange Variablendeklarationen bezeichnet.

Wir können auch eine kurze Variablendeklaration verwenden:

i := 1

In diesem Fall haben wir eine Variable namens i und einen Datentyp int. Wenn wir keinen Datentyp angeben, wird Go den Datentyp ableiten.

Mit den drei Möglichkeiten, Variablen zu deklarieren, hat die Go-Community die folgenden Idiome übernommen:

• Verwende nur die lange Form, var i int, wenn du die Variable nicht initialisierst.

• Verwende die kurze Form, i := 1, bei der Deklaration und Initialisierung.

• Wenn du nicht möchtest, dass Go deinen Datentyp ableitet, aber dennoch eine kurze Variablendeklaration verwenden willst, kannst du deinen Wert in deinem gewünschten Typ mit der folgenden Syntax einschließen:

i := int64(1)

Es gilt nicht als idiomatisch in Go, die lange Variablendeklarationsform zu verwenden, wenn wir den Wert initialisieren:

var i int = 1

Es ist eine gute Praxis, der Art und Weise zu folgen, wie die Go-Community Variablen typischerweise deklariert, damit andere deine Programme nahtlos lesen können.

Zero Werte

Alle integrierbaren Typen haben einen Wert von Null. Jeder zugewiesene Variable ist auch dann verwendbar, wenn sie nie einem Wert zugewiesen wird. Wir können die Nullwerte für folgende Typen sehen:

package main

import "fmt"

func main() {
	var a int
	var b string
	var c float64
	var d bool

	fmt.Printf("var a %T = %+v\n", a, a)
	fmt.Printf("var b %T = %q\n", b, b)
	fmt.Printf("var c %T = %+v\n", c, c)
	fmt.Printf("var d %T = %+v\n\n", d, d)
}

Output
var a int =  0
var b string = ""
var c float64 = 0
var d bool = false

Wir haben das Verb %T im fmt.Printf Statement verwendet. Dies sagt der Funktion, dass sie den datentyp des Variablen ausgeben soll.

In Go ist es, weil alle Werte einen null Wert haben, so dass wir keine undefiniert Werte wie in anderen Sprachen haben können. Beispielsweise könnten in manchen anderen Sprachen ein boolean zwischen undefined, true und false sein, was zu drei Statusstufen der Variable führen kann. In Go können wir aber nicht mehr als zwei Statusstufen für eine boolesche Variable haben.

Namensregeln für Variablen: Regeln und Stil

Die Namensgebung von Variablen ist sehr flexibel, aber es gibt einige Regeln zu beachten:

• Variablennamen müssen nur ein Wort sein (also keine Spaces).
• Variablennamen bestehen nur aus Buchstaben, Ziffern und Unterscores (_).
• Variablennamen können nicht mit einem Zahl beginnen.

Nach diesen Regeln werfen wir einen Blick sowohl auf gültige als auch ungültige Variablennamen:

Beachten Sie außerdem, dass Variablennamen case-sensitiv sind. Diese Namen userName, USERNAME, UserName und uSERnAME sind alle völlig unterschiedliche Variablen. Es ist eine bewährte Methode, ähnliche Variablennamen innerhalb eines Programms zu vermeiden, um sicherzustellen, dass Sie und Ihre Mitarbeiter – sowohl aktuell als auch zukünftig – Ihre Variablen klar unterscheiden können.

Obwohl Variablen case-sensitiv sind, hat die Schreibweise des ersten Buchstabens einer Variablen in Go eine besondere Bedeutung. Wenn eine Variable mit einem Großbuchstaben beginnt, ist diese Variable außerhalb des deklarierten Pakets zugänglich (oder exportiert). Beginnt eine Variable mit einem Kleinbuchstaben, ist sie nur innerhalb des deklarierten Pakets verfügbar.

var Email string
var password string

Email beginnt mit einem Großbuchstaben und kann von anderen Paketen aus aufgerufen werden. password beginnt mit einem Kleinbuchstaben und ist nur innerhalb des deklarierten Pakets zugänglich.

In Go ist es üblich, sehr knappe (oder kurze) Variablennamen zu verwenden. Wenn man zwischen userName und user für eine Variable wählen muss, wäre es idiomatisch, user zu wählen.

Der Gültigkeitsbereich spielt auch eine Rolle bei der Kürze des Variablennamens. Die Regel besagt, dass je kleiner der Gültigkeitsbereich, in dem die Variable existiert, desto kürzer der Variablenname sein sollte:

names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
	fmt.Printf("index: %d = %q\n", i, n)
}

Wir verwenden die Variable names in einem größeren Kontext, daher ist es üblich, ihr einen aussagekräftigeren Namen zu geben, um sich zu merken, was sie im Programm bedeutet. Allerdings verwenden wir die Variablen i und n sofort in der nächsten Codezeile und danach nicht mehr… Dadurch wird einem Leser des Codes nicht unklar, wo die Variablen verwendet werden oder was sie bedeuten.

Als nächstes behandeln wir einige Hinweise zum Variablenschutz. Der Stil besteht darin, MixedCaps oder mixedCaps anstelle von Unterstrichen für mehrteilige Namen zu verwenden.

Das Wichtigste beim Stil ist Konsistenz und dass das Team, mit dem Sie arbeiten, sich auf den Stil einigt.

Neuzuweisung von Variablen

Wie der Begriff „Variable“ nahelegt, können wir Go-Variablen leicht ändern. Das bedeutet, dass wir einem zuvor zugewiesenen Variablen einen anderen Wert zuordnen können. Die Möglichkeit der Neuzuweisung ist nützlich, weil wir im Laufe eines Programms möglicherweise benutzergenerierte Werte in bereits initialisierten Variablen akzeptieren müssen. Wir müssen die Zuweisung möglicherweise auch auf etwas ändern, das zuvor definiert wurde.

Das Wissen, dass wir eine Variable leicht neu zuweisen können, kann nützlich sein, wenn man an einem großen Programm arbeitet, das jemand anders geschrieben hat, und es ist nicht klar, welche Variablen bereits definiert sind.

Weisen wir der Variable i vom Typ int den Wert 76 zu und danach einen neuen Wert von 42:

package main

import "fmt"

func main() {
	i := 76
	fmt.Println(i)

	i = 42
	fmt.Println(i)
}

Output
76
42

Dieses Beispiel zeigt, dass wir der Variable i zunächst einen Integer-Wert zuweisen können und sie dann erneut zuweisen, diesmal mit dem Wert 42.

Da Go eine typisierte Sprache ist, können wir keinen Typ einem anderen zuweisen. Zum Beispiel können wir nicht den Wert "Sammy" einer Variable vom Typ int zuweisen:

i := 72
i = "Sammy"

Der Versuch, unterschiedliche Typen einander zuzuweisen, führt zu einem Compile-Time-Fehler:

Output
cannot use "Sammy" (type string) as type int in assignment

Go lässt uns nicht zu, einen Variablennamen mehr als einmal zu verwenden:

var s string
var s string

Output
s redeclared in this block

Wenn wir versuchen, die kurze Variablendeklaration mehr als einmal für denselben Variablennamen zu verwenden, erhalten wir ebenfalls einen Kompilierungsfehler. Das kann aus Versehen passieren, daher ist es hilfreich, zu verstehen, was die Fehlermeldung bedeutet:

i := 5
i := 10

Output
no new variables on left side of :=

Ähnlich wie bei der Variablendeklaration verbessert die Überlegung bei der Benennung deiner Variablen die Lesbarkeit deines Programms für dich und andere, wenn du es in der Zukunft wieder aufgreifen.

Mehrfachzuweisung

Go ermöglicht uns auch, mehrere Werte mehreren Variablen in derselben Zeile zuzuweisen. Jeder dieser Werte kann einen anderen Datentyp haben:

j, k, l := "shark", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)

Output
shark
2.05
15

In diesem Beispiel wurde der Variable j der String "shark" zugewiesen, der Variable k der Float 2.05 und der Variable l der Integer 15.

Dieser Ansatz, mehrere Variablen mehreren Werten in einer Zeile zuzuweisen, kann die Anzahl der Zeilen in Ihrem Code reduzieren. Es ist jedoch wichtig, die Lesbarkeit des Codes nicht aufgrund weniger Zeilen zu beeinträchtigen.

Globale und Lokale Variablen

Bei der Verwendung von Variablen in einem Programm ist es wichtig, den Variablenumfang im Auge zu behalten. Der Umfang einer Variablen bezieht sich auf die bestimmten Stellen, an denen sie innerhalb des Codes eines gegebenen Programms zugänglich ist. Das bedeutet, dass nicht alle Variablen in allen Teilen eines gegebenen Programms zugänglich sind – einige Variablen sind global und einige sind lokal.

Globale Variablen existieren außerhalb von Funktionen. Lokale Variablen existieren innerhalb von Funktionen.

Schauen wir uns globale und lokale Variablen in Aktion an:

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global

Hier verwenden wir `var g = "global"`, um eine globale Variable außerhalb der Funktion zu erstellen. Dann definieren wir die Funktion `printLocal()`. Innerhalb der Funktion wird eine lokale Variable namens `l` zugewiesen und dann ausgegeben. Das Programm endet mit dem Aufruf von `printLocal()` und dem anschließenden Ausgeben der globalen Variable `g`.

Da `g` eine globale Variable ist, können wir in `printLocal()` darauf verweisen. Lassen Sie uns das vorherige Programm ändern, um dies zu tun:

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
	fmt.Println(g)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global
global

Wir beginnen mit der Deklaration einer globalen Variable `g`, `var g = "global"`. In der `main`-Funktion rufen wir die Funktion `printLocal` auf, die eine lokale Variable `l` deklariert und ausgibt, `fmt.Println(l)`. Dann gibt `printLocal` die globale Variable `g` aus, `fmt.Println(g)`. Obwohl `g` nicht innerhalb von `printLocal` definiert wurde, konnte es immer noch aufgrund seiner Deklaration in einem globalen Bereich zugegriffen werden. Schließlich gibt die `main`-Funktion auch `g` aus.

Versuchen wir nun, die lokale Variable außerhalb der Funktion aufzurufen:

package main

import "fmt"

var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	fmt.Println(l)
}

Output
undefined: l

Man kann eine lokale Variable nicht außerhalb der Funktion verwenden, in der sie zugewiesen ist. Wenn Sie dies versuchen, erhalten Sie beim Kompilieren einen `undefined`-Fehler.

Schauen wir uns ein weiteres Beispiel an, in dem wir denselben Variablennamen für eine globale und eine lokale Variable verwenden:

package main

import "fmt"

var num1 = 5

func printNumbers() {
	num1 := 10
	num2 := 7  

	fmt.Println(num1)
	fmt.Println(num2)
}

func main() {
	printNumbers()
	fmt.Println(num1)
}

Output
10
7
5

In diesem Programm haben wir die Variable num1 zweimal deklariert. Zuerst haben wir num1 im globalen Gültigkeitsbereich deklariert, var num1 = 5, und dann erneut im lokalen Gültigkeitsbereich der printNumbers-Funktion, num1 := 10. Wenn wir num1 aus dem main-Programm ausgeben, sehen wir den Wert 5 ausgegeben. Dies liegt daran, dass main nur die globale Variablendeklaration sieht. Wenn wir jedoch num1 aus der printNumbers-Funktion ausgeben, sieht sie die lokale Deklaration und gibt den Wert 10 aus. Obwohl printNumbers eine neue Variable namens num1 erstellt und ihr den Wert 10 zugewiesen hat, wirkt sich dies nicht auf die globale Instanz von num1 mit dem Wert 5 aus.

Bei der Arbeit mit Variablen müssen Sie auch berücksichtigen, welche Teile Ihres Programms Zugriff auf die einzelnen Variablen benötigen; entsprechend eine globale oder lokale Variable verwenden. In Go-Programmen werden Sie feststellen, dass lokale Variablen typischerweise häufiger vorkommen.

Konstanten

Konstanten sind wie Variablen, mit dem Unterschied, dass sie einmal deklariert nicht mehr verändert werden können. Konstanten sind nützlich, um einen Wert zu definieren, der in Ihrem Programm mehrfach verwendet wird, aber nicht geändert werden sollte.

Zum Beispiel, wenn wir den Steuersatz für ein Einkaufswagen-System deklarieren wollten, könnten wir eine Konstante verwenden und dann die Steuer in verschiedenen Bereichen unseres Programms berechnen. Irgendwann in der Zukunft, wenn der Steuersatz sich ändert, müssen wir diesen Wert nur an einer Stelle in unserem Programm ändern. Wenn wir eine Variable verwendet hätten, besteht die Möglichkeit, dass wir den Wert irgendwo in unserem Programm versehentlich ändern könnten, was zu einer falschen Berechnung führen würde.

Um eine Konstante zu deklarieren, können wir die folgende Syntax verwenden:

const shark = "Sammy"
fmt.Println(shark)

Output
Sammy

Wenn wir versuchen, eine Konstante nach ihrer Deklaration zu ändern, erhalten wir einen Fehler zur Kompilierzeit:

Output
cannot assign to shark

Konstanten können untypisiert sein. Dies kann nützlich sein, wenn man mit Zahlen wie ganzzahligen Datentypen arbeitet. Wenn die Konstante untypisiert ist, wird sie explizit konvertiert, während typisierte Konstanten dies nicht tun. Schauen wir uns an, wie wir Konstanten verwenden können:

package main

import "fmt"

const (
	year     = 365
	leapYear = int32(366)
)

func main() {
	hours := 24
	minutes := int32(60)
	fmt.Println(hours * year)    
	fmt.Println(minutes * year)   
	fmt.Println(minutes * leapYear)
}

Output
8760
21900
21960

Wenn Sie eine Konstante mit einem Typ deklarieren, wird sie genau diesen Typ haben. Hier, als wir die Konstante leapYear deklarieren, definieren wir sie als Datentyp int32. Daher ist sie eine typisierte Konstante, was bedeutet, dass sie nur mit int32 Datentypen arbeiten kann. Die Konstante year, die wir ohne Typ deklarieren, wird als untypisiert betrachtet. Aufgrund dessen kann sie mit jedem ganzzahligen Datentyp verwendet werden.

Als hours definiert wurde, wurde inferred, dass es vom Typ int war, weil wir ihm keinen Typ explizit gegeben haben, hours := 24. Als wir minutes deklarierten, haben wir es explizit als int32 deklariert, minutes := int32(60).

Lassen Sie uns nun jede Berechnung durchgehen und erklären, warum sie funktioniert:

hours * year

In diesem Fall ist hours ein int, und years ist untypisiert. Wenn das Programm kompiliert wird, wird years explizit in einen int umgewandelt, was die Multiplikationsoperation ermöglicht.

minutes * year

In diesem Fall ist minutes ein int32, und year ist untypisiert. Wenn das Programm kompiliert wird, wird years explizit in einen int32 umgewandelt, was die Multiplikationsoperation ermöglicht.

minutes * leapYear

In diesem Fall ist minutes ein int32, und leapYear ist eine typisierte Konstante vom Typ int32. Dieses Mal hat der Compiler nichts zu tun, da beide Variablen bereits vom gleichen Typ sind.

Wenn wir versuchen, zwei Typen zu multiplizieren, die typisiert sind und nicht kompatibel sind, wird das Programm nicht kompilieren:

fmt.Println(hours * leapYear)

Output
invalid operation: hours * leapYear (mismatched types int and int32)

In diesem Fall wurde hours als int abgeleitet, und leapYear wurde explizit als int32 deklariert. Da Go eine typisierte Sprache ist, sind ein int und ein int32 für mathematische Operationen nicht kompatibel. Um sie zu multiplizieren, müsste man eine in einen int32 oder einen int umwandeln.

Schlussfolgerung

In diesem Tutorial haben wir einige der häufigen Anwendungsfälle von Variablen in Go betrachtet. Variablen sind ein wichtiger Baustein der Programmierung und fungieren als Symbole, die für den Wert eines Datentyps stehen, den wir in einem Programm verwenden.