TOC

Verwendung von Variablen und Konstanten in Go

Variables sind ein wichtiges Programmierkonzept, das beherrscht werden muss. Dies sind Symbole, die für einen Wert stehen, den Sie in einem Programm verwenden.

In diesem Lernprogramm werden verschiedene Grundlagen und bewährte Methoden für die Verwendung in den von Ihnen erstellten Go-Programmen behandelt.

Variablen verstehen

In technischer Hinsicht weist eine Variable einem Wert, der mit einem symbolischen Namen oder einer symbolischen Kennung verknüpft ist, einen Speicherort zu. Wir verwenden den Variablennamen, um auf diesen gespeicherten Wert in einem Computerprogramm zu verweisen.

Wir können uns eine Variable als Bezeichnung vorstellen, auf der ein Name steht, den Sie mit einem Wert verknüpfen.

Variables in Go

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 Namen verwenden, der leicht zu merken ist, wie die Variablei. Um einen Wert in einer Variablen zu speichern, verwenden wir die folgende Syntax: 

i := 1032049348

Wir können uns diese Variable wie ein Label vorstellen, das an den Wert gebunden ist.

Go Variable Example

Auf dem Label steht der Variablennamei und ist an den ganzzahligen Wert1032049348 gebunden.

Der Ausdrucki := 1032049348 ist eine Deklarations- und Zuweisungsanweisung, die aus wenigen Teilen besteht:

  • der Variablenname (i)

  • die Zuweisung der kurzen Variablendeklaration (:=)

  • der Wert, der an den Variablennamen gebunden wird (1032049348)

  • der durch Go (int)
    abgeleitete Datentyp

Wir werden später im nächsten Abschnitt sehen, wie der Typ explizit festgelegt wird.

Zusammen bilden diese Teile die Anweisung, die die Variablei gleich dem Wert der Ganzzahl1032049348 setzt.

Sobald wir eine Variable gleich einem Wert setzen, erstellen wirinitialize oder erstellen diese Variable. Sobald wir das getan haben, können wir die Variable anstelle des Werts verwenden.

Sobald wiri gleich dem Wert von1032049348 gesetzt haben, können wiri anstelle der Ganzzahl verwenden. Drucken wir es also aus: 

package main

import "fmt"

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

Wir können auch schnell und einfach mit Variablen rechnen. Miti := 1032049348 können wir den ganzzahligen Wert813 mit der folgenden Syntax subtrahieren: 

fmt.Println(i - 813)
Output1032048535

In diesem Beispiel rechnet Go für uns und subtrahiert 813 von der Variableni, um die Summe1032048535 zurückzugeben.

Apropos Mathematik: Variablen können dem Ergebnis einer mathematischen Gleichung gleichgesetzt werden. Sie können auch zwei Zahlen addieren und den Wert der Summe in der Variablenx speichern: 

x := 76 + 145

Möglicherweise haben Sie bemerkt, dass dieses Beispiel der Algebra ähnelt. So 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 darstellen. Für eine korrekte Go-Syntax müssen Sie sicherstellen, dass sich Ihre Variable auf der linken Seite von Gleichungen befindet.

Lassen Sie unsx drucken: 

package main

import "fmt"

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

Go gab den Wert221 zurück, da die Variablex gleich der Summe von76 und145 gesetzt wurde.

Variablen können jeden Datentyp darstellen, nicht nur ganze Zahlen: 

s := "Hello, World!"
f := 45.06
b := 5 > 9 // A Boolean value will return either true or false
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 drucken, gibt Go zurück, was dieser Variablen entspricht. Arbeiten wir mit der Zuweisungsanweisung für den Datentyp der Zeichenfolgeslice: 

package main

import "fmt"

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

Wir haben der Variablenslice den Slice-Wert von[]string{"one", "two", "three"} zugewiesen und dann die Funktionfmt.Println verwendet, um diesen Wert durch Aufrufen vonslice auszudrucken.

Variablen arbeiten, indem sie einen kleinen Speicherbereich in Ihrem Computer ausschneiden, der festgelegte Werte akzeptiert, die dann diesem Speicherbereich zugeordnet werden.

Variablen deklarieren

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

Wir können eine Variable namensi vom Datentypint ohne Initialisierung deklarieren. Dies bedeutet, dass wir ein Leerzeichen deklarieren, um einen Wert zu setzen, ihm jedoch keinen Anfangswert geben: 

var i int

Dadurch wird eine Variable erstellt, die alsi vom Datentypint deklariert ist.

Wir können den Wert mit dem Operator gleich (=) initialisieren, wie im folgenden Beispiel: 

var i int = 1

In Go heißen beide Deklarationsformenlong variable declarations.

Wir können auchshort variable declaration verwenden: 

i := 1

In diesem Fall haben wir eine Variable namensi und einen Datentyp vonint. Wenn wir keinen Datentyp angeben, leitet Go den Datentyp ab.

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

  • Verwenden Sie nur die Langformvar i int, wenn Sie die Variable nicht initialisieren.

  • Verwenden Sie beim Deklarieren und Initialisieren die Kurzformi := 1.

  • Wenn Sie nicht möchten, dass Go Ihren Datentyp herleitet, aber dennoch eine kurze Variablendeklaration verwenden möchten, können Sie Ihren Wert mit der folgenden Syntax in den gewünschten Typ einschließen: 

i := int64(1)

Es wird in Go nicht als idiomatisch angesehen, das lange Variablendeklarationsformular zu verwenden, wenn der Wert initialisiert wird: 

var i int = 1

Es hat sich bewährt, zu befolgen, wie die Go-Community normalerweise Variablen deklariert, damit andere Benutzer Ihre Programme nahtlos lesen können.

Nullwerte

Alle eingebauten Typen haben einen Nullwert. Jede zugewiesene Variable kann verwendet werden, auch wenn ihr nie ein Wert zugewiesen wurde. Wir können die Nullwerte für die folgenden 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)
}
Outputvar a int =  0
var b string = ""
var c float64 = 0
var d bool = false

Wir haben das Verb%T in der Anweisungfmt.Printf verwendet. Dies weist die Funktion an, diedata type für die Variable zu drucken.

Da in Go alle Werte einen Wert vonzerohaben, können wir wie in einigen anderen Sprachen keine Werte vonundefinedhaben. Zum Beispiel könnte einboolean in einigen Sprachenundefined,true oderfalse sein, wasthree Zustände für die Variable zulässt. In Go können wir nicht mehr alstwo Zustände für einen booleschen Wert haben.

Variablen benennen: Regeln und Stil

Die Benennung von Variablen ist sehr flexibel, es gibt jedoch einige Regeln, die beachtet werden müssen:

  • Variablennamen dürfen nur ein Wort enthalten (wie in keinem Leerzeichen).

  • Variablennamen dürfen nur aus Buchstaben, Zahlen und Unterstrichen (_) bestehen.

  • Variablennamen dürfen nicht mit einer Zahl beginnen.

Sehen wir uns nach diesen Regeln sowohl gültige als auch ungültige Variablennamen an:

Gültig Ungültig Warum ungültig?

userName

user-name

Bindestriche sind nicht erlaubt

name4

4name

Kann nicht mit einer Zahl beginnen

user

$user

Es können keine Symbole verwendet werden

userName

user name

Kann nicht mehr als ein Wort sein

Beachten Sie außerdem, dass bei der Benennung von Variablen die Groß- und Kleinschreibung berücksichtigt wird. Diese NamenuserName,USERNAME,UserName unduSERnAME sind alle völlig unterschiedliche Variablen. Es wird empfohlen, die Verwendung ähnlicher Variablennamen in einem Programm zu vermeiden, um sicherzustellen, dass sowohl Sie als auch Ihre Mitbearbeiter - aktuelle und zukünftige - Ihre Variablen gerade halten können.

Während Variablen zwischen Groß- und Kleinschreibung unterscheiden, hat die Groß- und Kleinschreibung des ersten Buchstabens einer Variablen in Go eine besondere Bedeutung. Wenn eine Variable mit einem Großbuchstaben beginnt, kann auf diese Variable außerhalb des Pakets zugegriffen werden, in dem sie deklariert wurde (oderexported). Wenn eine Variable mit einem Kleinbuchstaben beginnt, ist sie nur in dem Paket verfügbar, in dem sie deklariert ist. 

var Email string
var password string

Email beginnt mit einem Großbuchstaben und kann von anderen Paketen aufgerufen werden. password beginnt mit einem Kleinbuchstaben und ist nur innerhalb des Pakets zugänglich, in dem es deklariert ist.

In Go werden häufig sehr knappe (oder kurze) Variablennamen verwendet. Angesichts der Wahl zwischen der Verwendung vonuserName unduser für eine Variable wäre es idiomatisch,user zu wählen.

Der Bereich spielt auch eine Rolle für die Kürze des Variablennamens. Die Regel lautet, je kleiner der Gültigkeitsbereich der Variablen ist, desto kleiner ist der Variablenname: 

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

Wir verwenden die Variablenames in einem größeren Bereich, daher ist es üblich, ihr einen aussagekräftigeren Namen zu geben, um sich daran zu erinnern, was sie im Programm bedeutet. Wir verwenden jedoch die Variableni undn sofort in der nächsten Codezeile und verwenden sie dann nicht erneut. Aus diesem Grund wird es niemanden beim Lesen des Codes verwirren, wo die Variablen verwendet werden oder was sie bedeuten.

Lassen Sie uns als Nächstes einige Hinweise zum variablen Stil behandeln. Der Stil besteht darin,MixedCaps odermixedCaps anstelle von Unterstrichen für Namen mit mehreren Wörtern zu verwenden.

Konventioneller Stil Unkonventioneller Stil Warum unkonventionell

userName

user_name

Unterstriche sind nicht konventionell

i

index

bevorzugen Siei gegenüberindex, da es kürzer ist

serveHTTP

serveHttp

Akronyme sollten groß geschrieben werden

Das Wichtigste am Stil ist, dass er konsistent ist und dass das Team, in dem Sie arbeiten, dem Stil zustimmt.

Variablen neu zuweisen

Wie das Wort "Variable" impliziert, können wir Go-Variablen leicht ändern. Dies bedeutet, dass wir durch Neuzuweisung einen anderen Wert mit einer zuvor zugewiesenen Variablen verbinden können. Neu zuweisen zu können ist nützlich, da wir im Verlauf eines Programms möglicherweise vom Benutzer generierte Werte in bereits initialisierte Variablen übernehmen müssen. Möglicherweise müssen wir auch die Zuweisung auf etwas zuvor Definiertes ändern.

Zu wissen, dass wir eine Variable problemlos neu zuweisen können, kann hilfreich sein, wenn Sie an einem großen Programm arbeiten, das von einem anderen Benutzer geschrieben wurde. Es ist nicht klar, welche Variablen bereits definiert sind.

Weisen wir einer Variablen namensi vom Typint den Wert76 zu und weisen ihr dann einen neuen Wert von42 zu: 

package main

import "fmt"

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

    i = 42
    fmt.Println(i)
}
Output76
42

Dieses Beispiel zeigt, dass wir zuerst die Variablei mit dem Wert einer Ganzzahl zuweisen und dann die Variablei neu zuweisen können, indem wir sie diesmal mit dem Wert42 zuweisen.

[.note] #Note: Wenn Sie deklarieren, dassand eine Variable initialisiert, können Sie:= verwenden. Wenn Sie jedoch einfach den Wert einer bereits deklarierten Variablen ändern möchten, benötigen Sie nur um den gleichen Operator (=) zu verwenden.
#

Da Go einetyped-Sprache ist, können wir keinen Typ einem anderen zuweisen. Beispielsweise können wir den Wert"Sammy" keiner Variablen vom Typint zuweisen: 

i := 72
i = "Sammy"

Der Versuch, verschiedene Typen zuzuweisen, führt zu einem Fehler bei der Kompilierung: 

Outputcannot use "Sammy" (type string) as type int in assignment

Go erlaubt uns nicht, einen Variablennamen mehrmals zu verwenden: 

var s string
var s string
Outputs redeclared in this block

Wenn wir versuchen, eine kurze Variablendeklaration mehrmals für denselben Variablennamen zu verwenden, wird ebenfalls ein Kompilierungsfehler angezeigt. Dies kann versehentlich passieren. Daher ist es hilfreich zu verstehen, was die Fehlermeldung bedeutet: 

i := 5
i := 10
Outputno new variables on left side of :=

Ähnlich wie bei der Variablendeklaration verbessert die Berücksichtigung der Benennung Ihrer Variablen die Lesbarkeit Ihres Programms für Sie und andere, wenn Sie es in Zukunft erneut besuchen.

Mehrfachzuweisung

Mit Go können wir auch mehreren Variablen in derselben Zeile mehrere Werte zuweisen. Jeder dieser Werte kann einen anderen Datentyp haben: 

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

In diesem Beispiel wurde die Variablej der Zeichenfolge"shark" zugewiesen, die Variablek wurde dem Float2.05 zugewiesen und die Variablel wurde zugewiesen auf die ganze Zahl15.

Dieser Ansatz zum Zuweisen mehrerer Variablen zu mehreren Werten in einer Zeile kann die Anzahl der Zeilen in Ihrem Code verringern. Es ist jedoch wichtig, die Lesbarkeit für weniger Codezeilen nicht zu beeinträchtigen.

Globale und lokale Variablen

Bei der Verwendung von Variablen in einem Programm ist es wichtig,variable scope zu berücksichtigen. Der Gültigkeitsbereich einer Variablen bezieht sich auf die bestimmten Stellen, auf die innerhalb des Codes eines bestimmten Programms zugegriffen werden kann. Dies bedeutet, dass nicht alle Variablen von allen Teilen eines bestimmten Programms aus zugänglich sind - einige Variablen sind global und andere lokal.

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

Sehen 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)
}
Outputlocal
global

Hier verwenden wirvar g = "global", um eine globale Variable außerhalb der Funktion zu erstellen. Dann definieren wir die FunktionprintLocal(). Innerhalb der Funktion wird eine lokale Variable namensl zugewiesen und dann ausgedruckt. Das Programm endet mit dem Aufruf vonprintLocal() und dem anschließenden Drucken der globalen Variableng.

Dag eine globale Variable ist, können wir inprintLocal() darauf verweisen. Ändern wir dazu das vorherige Programm: 

package main

import "fmt"


var g = "global"

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

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

Wir beginnen mit der Deklaration einer globalen Variableng,var g = "global". In der Funktionmain rufen wir die FunktionprintLocal auf, die eine lokale Variablel deklariert und sie ausdruckt,fmt.Println(l). Dann drucktprintLocal die globale Variableg,fmt.Println(g) aus. Auch wenng nicht innerhalb vonprintLocal definiert wurde, konnte dennoch darauf zugegriffen werden, da es in einem globalen Bereich deklariert wurde. Schließlich druckt die Funktionmain auchg 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)
}
Outputundefined: l

Wir können keine lokale Variable außerhalb der Funktion verwenden, in der sie zugewiesen ist. Wenn Sie dies versuchen, erhalten Sie beim Kompilieren einenundefined-Fehler.

Schauen wir uns ein weiteres Beispiel an, in dem wir denselben Variablennamen für eine globale Variable 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)
}
Output10
7
5

In diesem Programm haben wir die Variablenum1zweimal deklariert. Zuerst haben wirnum1 im globalen Bereichvar num1 = 5 und erneut im lokalen Bereich derprintNumbers-Funktionnum1 := 10 deklariert. Wenn wirnum1 aus dem Programmmain drucken, wird der Wert von5 ausgedruckt. Dies liegt daran, dassmain nur die globale Variablendeklaration sieht. Wenn wir jedochnum1 aus der FunktionprintNumbers ausdrucken, wird die lokale Deklaration angezeigt und der Wert von10 ausgedruckt. ObwohlprintNumbers eine neue Variable namensnum1 erstellt und ihr einen Wert von10 zugewiesen hat, wirkt sich dies nicht auf die globale Instanz vonnum1 mit dem Wert von5aus. s.

Wenn Sie mit Variablen arbeiten, müssen Sie auch berücksichtigen, welche Teile Ihres Programms Zugriff auf die einzelnen Variablen benötigen. eine globale oder lokale Variable entsprechend übernehmen. In allen Go-Programmen werden Sie feststellen, dass lokale Variablen in der Regel häufiger vorkommen.

Konstanten

Konstanten sind wie Variablen, können jedoch nach ihrer Deklaration nicht mehr geändert werden. Konstanten sind nützlich, um einen Wert zu definieren, der in Ihrem Programm mehrmals verwendet wird, sich aber nicht ändern darf.

Wenn wir beispielsweise den Steuersatz für ein Warenkorbsystem deklarieren möchten, können wir eine Konstante verwenden und dann die Steuer in verschiedenen Bereichen unseres Programms berechnen. Irgendwann in der Zukunft müssen wir, wenn sich der Steuersatz ändert, diesen Wert nur an einer Stelle in unserem Programm ändern. Wenn wir eine Variable verwenden, ist es möglich, dass wir den Wert versehentlich irgendwo in unserem Programm ändern, 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)
OutputSammy

Wenn wir versuchen, eine Konstante zu ändern, nachdem sie deklariert wurde, wird beim Kompilieren ein Fehler angezeigt: 

Outputcannot assign to shark

Konstanten könnenuntyped sein. Dies kann nützlich sein, wenn Sie mit Zahlen wie Daten vom Typ Integer arbeiten. Wenn die Konstanteuntyped ist, wird sie explizit konvertiert, während dies beityped nicht der Fall ist. Mal sehen, 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)
}
Output8760
21900
21960

Wenn Sie eine Konstante mit einem Typ deklarieren, ist dies der genaue Typ. Wenn wir hier die KonstanteleapYear deklarieren, definieren wir sie als Datentypint32. Daher ist es einetyped-Konstante, was bedeutet, dass es nur mitint32-Datentypen arbeiten kann. Dieyear-Konstante, die wir ohne Typ deklarieren, wird alsuntyped betrachtet. Aus diesem Grund können Sie es mit jedem ganzzahligen Datentyp verwenden.

Wennhours definiert wurde, warinferred vom Typint, da wir ihm nicht explizit den Typhours := 24 gegeben haben. Wenn wirminutes deklariert haben, haben wir es explizit alsint32,minutes := int32(60) deklariert.

Lassen Sie uns nun die einzelnen Berechnungen durchgehen und erläutern, warum dies funktioniert: 

hours * year

In diesem Fall isthours einint undyears istuntyped. Wenn das Programm kompiliert wird, konvertiert es explizityears inint, wodurch die Multiplikationsoperation erfolgreich sein kann. 

minutes * year

In diesem Fall istminutes einint32 undyear istuntyped. Wenn das Programm kompiliert wird, konvertiert es explizityears inint32, wodurch die Multiplikationsoperation erfolgreich sein kann. 

minutes * leapYear

In diesem Fall istminutes einint32 undleapYear ist einetyped-Konstante vonint32. Diesmal hat der Compiler nichts zu tun, da beide Variablen bereits vom gleichen Typ sind.

Wenn wir versuchen, zwei Typen zu multiplizieren, dietyped sind und nicht kompatibel sind, wird das Programm nicht kompiliert: 

fmt.Println(hours * leapYear)
Outputinvalid operation: hours * leapYear (mismatched types int and int32)

In diesem Fall wurdehours alsint abgeleitet undleapYear wurde explizit alsint32 deklariert. Da Go eine typisierte Sprache ist, sindint undint32 nicht für mathematische Operationen kompatibel. Um sie zu multiplizieren, benötigen Sieto convert one to a int32 or an int.

Fazit

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

Related