Go-Sprachvariablen

Variablen stammen aus der Mathematik; in Computersprachen sind sie abstrakte Konzepte, die Berechnungsergebnisse speichern oder Werte darstellen können.

Auf Variablen kann über ihre Variablennamen zugegriffen werden.

Go-Variablennamen bestehen aus Buchstaben, Ziffern und Unterstrichen, und das erste Zeichen darf keine Ziffer sein.

Die allgemeine Form zum Deklarieren einer Variable ist die Verwendung des Schlüsselworts var:

var identifier type

Mehrere Variablen können gleichzeitig deklariert werden:

var identifier1, identifier2 type

Beispiel

package main
import "fmt"
func main() {
    var a string = "Example"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
}

Die Ausgabe des obigen Beispiels ist:

Example
1 2

Variablendeklaration

Geben Sie zuerst den Variablentyp an. Wenn sie nicht initialisiert wird, hat die Variable standardmäßig ihren Nullwert.。

var v_name v_type
v_name = value

Der Nullwert ist der Wert, der vom System standardmäßig festgelegt wird, wenn die Variable nicht initialisiert wurde.

Beispiel

package main
import "fmt"
func main() {

    // Eine Variable deklarieren und initialisieren
    var a = "EXAMPLE"
    fmt.Println(a)

    // Ohne Initialisierung ist es der Nullwert
    var b int
    fmt.Println(b)

    // Der Nullwert von bool ist false
    var c bool
    fmt.Println(c)
}

Das Ausführungsergebnis des obigen Beispiels ist:

EXAMPLE
0
false

  • Numerische Typen (einschließlich complex/128) sind0

  • Der boolesche Typ istfalse

  • Der String ist""(leerer String)

  • Die folgenden Typen sind:nil：

    var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

Beispiel

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

Die Ausgabe ist:

0 0 false ""

Zweitens wird der Variablentyp durch den Wert selbst bestimmt.

var v_name = value

Beispiel

package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}

Die Ausgabe ist:

true

Drittens: Wenn eine Variable bereits mit var deklariert wurde, dann führt die erneute Verwendung:=zur Deklaration der Variable zu einem Compilerfehler. Format:

v_name := value

Zum Beispiel:

var intVal int 
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明

Verwenden Sie einfach die folgende Anweisung:

intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句

intVal := 1Entspricht:

var intVal int 
intVal =1

Sie können var f string = "Example" als f := "Example" abkürzen:

Beispiel

package main
import "fmt"
func main() {
    f := "Example" // var f string = "Example"

    fmt.Println(f)
}

Die Ausgabe ist:

Example

Deklaration mehrerer Variablen

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

Beispiel

package main
import "fmt"

var x, y int
var (  // Diese faktorisierte Schlüsselwortsyntax wird im Allgemeinen verwendet, um globale Variablen zu deklarieren
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

// Diese Form ohne die Deklarationssyntax kann nur innerhalb eines Funktionskörpers vorkommen
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    fmt.Println(x, y, a, b, c, d, e, f, g, h)
}

Das Ausführungsergebnis des obigen Beispiels ist:

0 0 0 false 1 2 123 hello 123 hello

Werttypen und Referenztypen

Alle Basistypen wie int, float, bool und string sind Werttypen. Variablen dieser Typen zeigen direkt auf Werte, die im Speicher gespeichert sind:

Bei Verwendung des Gleichheitszeichens=Wenn Sie den Wert einer Variablen einer anderen Variablen zuweisen, wie zum Beispiel:j = iTatsächlich wird dabei der Wert von i im Speicher kopiert:

Sie können die Speicheradresse der Variablen i über &i ermitteln, zum Beispiel: 0xf840000040 (die Adresse kann jedes Mal anders sein).

Variablen von Werttypen werden normalerweise auf dem Stack gespeichert, insbesondere wenn sie lokale Variablen sind. Wenn der Wert einer Variablen eines Werttyps außerhalb des Funktionsbereichs verwendet werden muss, weist Go ihn dem Heap-Speicher zu.

Speicheradressen können sich je nach Maschine unterscheiden, und selbst dasselbe Programm kann nach der Ausführung auf verschiedenen Maschinen unterschiedliche Speicheradressen haben. Das liegt daran, dass jede Maschine ein unterschiedliches Speicherlayout haben kann und auch die Speicherplatzzuweisung unterschiedlich sein kann.

Komplexere Daten benötigen normalerweise mehrere Wörter, und solche Daten werden im Allgemeinen mithilfe von Referenztypen gespeichert.

Eine Variable r1 vom Referenztyp speichert die Speicheradresse (eine Zahl), an der der Wert von r1 liegt, bzw. die Position des ersten Worts an dieser Speicheradresse.

Diese Speicheradresse wird als Pointer bezeichnet, und dieser Pointer ist tatsächlich in einem anderen Wert gespeichert.

Die mehreren Wörter, auf die ein Pointer desselben Referenztyps zeigt, können an aufeinanderfolgenden Speicheradressen liegen (zusammenhängendes Speicherlayout), was auch die rechentechnisch effizienteste Form der Speicherung ist; alternativ können diese Wörter im Speicher verstreut sein, wobei jedes Wort die Speicheradresse des nächsten Worts angibt.

Wenn die Zuweisungsanweisung r2 = r1 verwendet wird, wird nur die Referenz (Adresse) kopiert.

Wenn der Wert von r1 geändert wird, zeigen alle Referenzen auf diesen Wert auf den geänderten Inhalt. In diesem Beispiel ist r2 ebenfalls betroffen.

Kurzform unter Verwendung des Zuweisungsoperators :=

Wir wissen, dass der Variablentyp bei der Variableninitialisierung weggelassen und automatisch vom System abgeleitet werden kann. Die Angabe des Schlüsselworts var in der Deklarationsanweisung ist etwas redundant, daher können wir sie als a := 50 oder b := false abkürzen.

Die Typen von a und b (int und bool) werden automatisch vom Compiler abgeleitet.

Dies ist die bevorzugte Form für die Verwendung von Variablen, aber sie kann nur innerhalb eines Funktionskörpers verwendet werden und nicht zum Deklarieren und Zuweisen globaler Variablen. Die Verwendung des Operators := kann effizient eine neue Variable erstellen, was als Initialisierungsdeklaration bezeichnet wird.

Hinweise

Im selben Codeblock können wir eine Initialisierungsdeklaration nicht erneut für eine Variable mit demselben Namen verwenden. Zum Beispiel ist a := 20 nicht erlaubt, und der Compiler meldet einen Fehler: no new variables on left side of :=, aber a = 20 ist erlaubt, weil dies derselben Variable einen neuen Wert zuweist.

Wenn Sie die Variable a verwenden, bevor Sie sie definieren, erhalten Sie einen Kompilierfehler: undefined: a.

Wenn Sie eine lokale Variable deklarieren, sie aber nicht im selben Codeblock verwenden, erhalten Sie ebenfalls einen Kompilierungsfehler, wie die Variable a im folgenden Beispiel:

Beispiel

package main

import "fmt"

func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

Der Versuch, diesen Code zu kompilieren, führt zu einem Fehler.a deklariert, aber nicht verwendet。

Außerdem reicht es nicht aus, der Variable a einfach einen Wert zuzuweisen; dieser Wert muss verwendet werden, also verwenden Sie

fmt.Println("hello, world", a)

Behebt den Fehler.

Aber globale Variablen dürfen deklariert werden, ohne verwendet zu werden.

var a, b, c int

Mehrere Variablen können in derselben Zeile zugewiesen werden, zum Beispiel:

var a, b int
var c string
a, b, c = 5, 7, "abc"

Die obige Zeile setzt voraus, dass die Variablen a, b und c bereits deklariert wurden; andernfalls sollte sie so verwendet werden:

a, b, c := 5, 7, "abc"

Die Werte auf der rechten Seite werden den Variablen auf der linken Seite in derselben Reihenfolge zugewiesen, sodass der Wert von a 5 ist, der Wert von b 7 ist und der Wert von c "abc" ist.

Dies wird als parallele oder gleichzeitige Zuweisung bezeichnet.

Wenn Sie die Werte zweier Variablen vertauschen möchten, können Sie einfach verwendena, b = b, aDie Typen der beiden Variablen müssen identisch sein.

Der leere Bezeichner _ wird auch verwendet, um Werte zu verwerfen, wie etwa den Wert 5 in: _, b = 5, 7 verworfen wird.

_ ist tatsächlich eine Nur-Schreib-Variable; man kann ihren Wert nicht abrufen. Das geschieht, weil man in der Sprache Go alle deklarierten Variablen verwenden muss, aber manchmal muss man nicht alle Rückgabewerte verwenden, die man von einer Funktion erhält.

Parallele Zuweisung wird auch verwendet, wenn eine Funktion mehrere Rückgabewerte zurückgibt. Zum Beispiel werden hier val und der Fehler err gleichzeitig durch Aufruf der Funktion Func1 erhalten: val, err = Func1(var1).

Weitere Erweiterungen