Einführung in Go-Variablen

Einführung

Warum benötigen wir Variablen in Computerprogrammiersprachen? Dies ist eine uralte Frage. Genauso wie wir uns merken können, dass die URL für LabEx labex.io ist, müssen auch Computerprogramme einige Daten für ihre Verwendung merken.

Der Zweck von Variablen besteht darin, ein Datenstück darzustellen. In diesem Abschnitt werden wir untersuchen, wie Variablen in der Go-Sprache verwendet werden.

Wissenspunkte:

• Variablendeklaration
• Variable Initialisierung
• Variable Verwendung
• Lebensdauer von Variablen
• Konstanten

Was ist eine Variable?

Was ist eine Variable? Einfach ausgedrückt, ist eine Variable ein Behälter, der verwendet wird, um ein Stück veränderlicher Daten zu speichern.

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

Was bedeutet es, dass ein Variablentyp festgelegt ist?

Das bedeutet, dass eine Variable nur einen Datentyp enthalten kann. Mit anderen Worten, die Elemente, die in dem Variablenbehälter gespeichert werden, sind festgelegt.

Wenn eine Variable verwendet wird, um Früchte zu speichern, sollte sie nur Früchte enthalten. Sobald der Behälter Früchte enthalten hat, kann er nicht mehr verwendet werden, um Kekse zu speichern. Dies spiegelt sich im Code darin wider, dass einer Variable nicht zwei verschiedene Datentypen zugewiesen werden können.

Variablenänderbarkeit

Wie der Name schon sagt, kann der Wert einer Variable sich ändern, solange die Änderung nicht den vom Typ erlaubten Bereich überschreitet.

Die Go-Sprache hat die folgenden Regeln für Variablen:

• Der Name muss aus Buchstaben, Ziffern und Unterstrichen bestehen.
• Der Variablenbezeichner darf nicht mit einer Ziffer beginnen.
• Der Bezeichner darf kein reserviertes Schlüsselwort sein. Prüfen Sie die reservierten Schlüsselwörter
• Variablennamen sind case-sensitive (groß- und kleinschreibungsabhängig), aber es wird nicht empfohlen, unterschiedliche Großschreibung zu verwenden, um zwei Variablen mit gleichem Namen zu unterscheiden.

Allgemeine Deklarationsmethode

In der Go-Sprache ist das Schlüsselwort, das zur Deklaration von Variablen auf die allgemeine Weise verwendet wird, var.

Die Form der Deklaration lautet: var identifier type, was bedeutet:

var variableName variableType.

Welche sind die gängigen Variablentypen in Go?

Da Variablentypen nicht der Fokus dieses Abschnitts sind, werden nur die drei gängigsten Typen aufgeführt.

Weitere Typen werden in den folgenden Kursen erklärt.

Wie deklarieren wir eine Variable?

Jetzt deklarieren wir eine ganzzahlige Variable mit dem Namen a.

var a int

Wie kann man sich das merken? Sie können sich in Gedanken sagen:

Definiere eine Variable mit dem Namen `a`, die vom Typ int ist.

Im Gegensatz zu vielen traditionellen Programmiersprachen wird der in Go verwendete Variablentyp hinter dem Variablennamen platziert.

Diese Art der Variablendeklaration macht den Code leichter von links nach rechts zu lesen und vermeidet die spiralförmige Leselogik der C-Sprache. Weitere Details finden Sie in der offiziellen Dokumentation.

Welchen Namen sollten wir einer Variable geben?

Ein guter Variablenname sollte die Bedeutung der Variable klar wiedergeben.

Beim Benennen von Variablen müssen wir auf ihre Ausdrucksstärke achten und die Verwendung von Abkürzungen vermeiden.

Hier werden wir kurz die grundlegende Methode des Variablennamens: die Camel Case Benennungskonvention einführen.

Die Camel Case Benennungskonvention verwendet gemischte Groß- und Kleinbuchstaben, um eine Variable darzustellen. Das erste Wort steht in Kleinbuchstaben, und der erste Buchstabe jedes folgenden Wortes wird groß geschrieben.

Beispiel: currentDate. Das erste Wort, current, steht in Kleinbuchstaben, und das zweite Wort, Date, beginnt mit einem Großbuchstaben.

Auf diese Weise ist eine Variable, die das aktuelle Datum darstellt, leicht verständlich.

Diese Benennungskonvention wird im Allgemeinen für wichtige und häufig verwendete Variablen verwendet, während temporäre Variablen vereinfacht werden können, solange keine Namenskonflikte entstehen.

Batch-Deklarationsmethode

Jetzt deklarieren wir 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

Beobachtende Schüler haben vielleicht bemerkt, dass alle drei Variablen a, b, c vom Typ int sind.

In diesem Fall können wir ein Komma verwenden, um die Variablennamen zu verbinden und den Code zu verkürzen.

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

Aber was ist, 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

Wir scheinen eine ähnliche Situation zu haben wie beim Importieren von Paketen. Viele Pakete mit unterschiedlichen Namen müssen zusammen importiert werden, daher können wir eine ähnliche Schreibweise verwenden:

var (
    a int
    b string
    c bool
)

Beachten Sie, dass diese Art der Deklaration, die ähnlich wie beim Importieren von Paketen ist, im Allgemeinen zur Definition von globalen Variablen verwendet wird.

Standardinitialisierung

In Go werden allen Variablen bei ihrer Deklaration Anfangswerte zugewiesen. Lassen Sie uns untersuchen, was die Anfangswerte von Variablen sind!

Erstellen Sie eine Datei mit dem Namen varExercise.go im Verzeichnis ~/project.

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)
}

Sie können es selbst ausführen und prüfen, ob es mit der folgenden Tabelle übereinstimmt.

go run varExercise.go

Die Typen der Anfangswerte sind wie folgt zusammengefasst:

Standardinitialisierung

Da der Typ einer Variable durch ihren Anfangswert bestimmt werden kann, können wir den Standardwert oder 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 wir einfach nach der Deklaration der Variable ein = hinzufügen, gefolgt von einem Anfangswert, der mit dem Variablentyp kompatibel ist. Wenn Sie den Wert ändern möchten, verwenden Sie einfach den Variablennamen, gefolgt von = und einem anderen Wert des gleichen 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)
}

Nachdem Sie den Code ausgeführt haben, ist die Ausgabe wie folgt:

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

Sie können es selbst ausführen und die Anfangswerte ändern.

Wir haben gerade erwähnt, dass der Anfangswert, der einer Variable zugewiesen wird, vom gleichen Typ wie die Variablendeklaration sein muss. Was passiert, wenn sie unterschiedlich sind?

Beispielsweise weisen wir der Variable a den Anfangswert "labex" 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 in der Abbildung gezeigt, können wir keinen Zeichenketten-Typ wie "labex" einer Variable vom Typ int zuweisen. Dies liegt daran, dass Go eine stark typisierte kompilierte Sprache ist und nicht kompiliert werden kann.

Typdeklaration durch Inferenz

Da Go den Typ einer Variable anhand ihres Anfangswerts bestimmen kann, können wir den Prozess der Typdeklaration vereinfachen, indem wir den Schritt des expliziten Angebens 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 sogar nicht einmal das Schlüsselwort var verwenden, um eine Variable zu definieren.

Diese Art der Deklaration und Initialisierung einer Variable kann auch mit der Batch-Deklarationsmethode kombiniert werden:

a, b, c := 0
// Declare variables a, b, c as integers and assign an initial value of 0
a, b, c := 0, "", true
// Declare variables a, b, c as integer, string, and boolean, respectively

Die Kurzdeklaration ist sehr praktisch, aber beachten Sie, dass := keine Zuweisungsoperation ist. Es ist eine Art, Variablen zu deklarieren, und ist einzigartig für Go. Es wird verwendet, um lokale Variablen innerhalb einer Funktion zu deklarieren und zu initialisieren. Der Typ der Variable wird automatisch anhand des Ausdrucks abgeleitet.

Manchmal schreiben wir folgenden Code:

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

Der Compiler wird Ihnen sagen, dass es einen Fehler im Code gibt, weil die Variable a erneut deklariert wurde. Wenn er jedoch wie folgt geschrieben wird:

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

Es gibt eine solche Ausgabe, weil die a mit dem Wert 1 oben und die a mit dem Wert 2 unten nicht im gleichen Variablenbereich (innerhalb der gleichen geschweiften Klammern) liegen. Daher behandelt der Compiler sie als zwei verschiedene Variablen.

Der Compiler wird Ihren Fehler nicht aufzeigen, aber es wird eine unerwartete Ausgabe geben.

In Go ist festgelegt:

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

Daher kann die Kurzvariablendeklaration nur zur Deklaration von lokalen Variablen verwendet werden und nicht zur Deklaration von globalen Variablen.

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

Dies betrifft das Konzept der Variablenlebensdauer, das im nächsten Abschnitt erklärt wird.

Variablenbereich

Der Variablenbereich bezieht sich auf den Bereich, in dem eine Variable in einem Programm gültig ist, d. h. wie sie verwendet werden kann.

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

Mit anderen Worten, wenn Go kompiliert wird, prüft es, ob jede Variable verwendet wurde, d. h. ob sie innerhalb ihres Bereichs verwendet wurde.

Wir können Variablen einfach anhand ihrer Deklarationsposition in drei Typen unterteilen:

• 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 definiert werden, heißen formale Parameter.

Lokale Variablen

In diesem Abschnitt sind die meisten Variablen, die wir definieren, 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, wie z. B. a, das innerhalb der main-Funktion definiert wird. Der Bereich der Variable a ist auf die main-Funktion beschränkt.

Gleichzeitig wird der Compiler einen Fehler ausgeben, wenn die Variable in der main-Funktion nicht verwendet wird.

Globale Variablen

Es ist jedoch auch möglich, eine globale Variable zu 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, und ihr Bereich umfasst das gesamte Programm. Selbst wenn sie in keiner Funktion aufgerufen werden, wird vom Compiler kein Fehler gemeldet.

Sie können darüber nachdenken, warum globale Variablen auch dann keine Fehler verursachen, wenn sie nicht aufgerufen werden.

Details zu formalen Parameter-Variablen werden in späteren funktionsbezogenen Kursen erklärt.

Variablenlebensdauer

Vögel, die wegfliegen, verbergen ihre Spur. Listige Kaninchen sterben, und die Hunde werden gekocht. - Shiji (Records of the Grand Historian)

Wenn eine Variable ihren Zweck erfüllt hat, sollte sie zerstört werden, um den Speicherbedarf zu reduzieren.

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

Eine solche Gestaltung ist der Schlüssel für die hohe Leistung und die effiziente Speichernutzung von Go.

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

Sie können Folgendes in varExercise.go schreiben:

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)
}

Nachdem Sie den Code ausgeführt haben:

go run varExercise.go

Sie werden die folgende Fehlermeldung sehen:

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

Der Compiler sagt uns, dass a erneut definiert wird.

Konstanten (Constants)

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

Wenn sich eine Variable während der gesamten Programmlaufzeit nicht ändert, sollten wir sie als Konstante definieren.

Konstanten sind Variablen sehr ähnlich, und man kann sie sich sogar als Variablen mit unveränderlichen Werten vorstellen.

Beim Deklarieren einer Konstanten müssen wir lediglich das Schlüsselwort var durch das Schlüsselwort const ersetzen.

const Pi = 3.14159 // Verwendung der Typinferenz-Initialisierung

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

touch ~/project/constExercise.go

Was passiert, 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 neu zugewiesen werden kann.

Beim Deklarieren einer Konstanten müssen wir einen Anfangswert angeben.

Und der einer Konstanten zugewiesene Anfangswert muss zur Kompilierzeit festgelegt sein.

Rückgabewerte benutzerdefinierter Funktionen gelten in Go nicht als fest.

var a int = 1
// Wert ist fest, Deklaration ist gültig.
const Pi = 3.14159
// Der berechnete Wert ist ebenfalls fest, die Deklaration ist gültig.
const c = 1 / Pi
// Fester Rückgabewert von der eingebauten Funktion ist gültig.
const le = len("labex")
// Der Rückgabewert der benutzerdefinierten Funktion ist nicht fest, die Deklaration ist ungültig.
const le = getLen("labby")
// `a` ist ein Variablenwert, der nicht fest ist, die Deklaration ist ungültig.
const k = a

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

Zusammenfassung

Lassen Sie uns zusammenfassen, was wir in diesem Lab gelernt haben:

• Die Methoden zur Deklaration von Variablen
• Die Methoden zur Initialisierung von Variablen
• Das Konzept der Variablenlebensdauer
• Die Verwendung von Konstanten und die Gültigkeit ihrer Deklarationen

In diesem Lab haben wir die Grundlagen der Variablenverwendung in Go wiederholt, die Methoden zur Deklaration und Verwendung von Variablen in verschiedenen Situationen gezeigt und die Konstanten eingeführt.