Go
Variablen

Syntax

• var x int // deklariere die Variable x mit dem Typ int
• var s string // deklariere die Variable s mit dem Typ string
• x = 4 // x Wert definieren
• s = "foo" // s-Wert definieren
• y: = 5 // deklarieren und definieren y, wenn dessen Typ auf int gesetzt wird
• f: = 4.5 // deklarieren und definieren, wenn f den Typ auf float64 bezieht
• b: = "bar" // deklarieren und definieren b, wenn dessen Typ auf string verweist

Grundlegende Variablendeklaration

Go ist eine statisch typisierte Sprache, was bedeutet, dass Sie im Allgemeinen den Typ der verwendeten Variablen angeben müssen.

// Basic variable declaration. Declares a variable of type specified on the right.
// The variable is initialized to the zero value of the respective type.
var x int
var s string
var p Person // Assuming type Person struct {}

// Assignment of a value to a variable
x = 3

// Short declaration using := infers the type
y := 4

u := int64(100)    // declare variable of type int64 and init with 100 
var u2 int64 = 100 // declare variable of type int64 and init with 100

Mehrfachzuweisung von Variablen

In Go können Sie mehrere Variablen gleichzeitig deklarieren.

// You can declare multiple variables of the same type in one line
var a, b, c string

var d, e string = "Hello", "world!"

// You can also use short declaration to assign multiple variables
x, y, z := 1, 2, 3

foo, bar := 4, "stack" // `foo` is type `int`, `bar` is type `string`

Wenn eine Funktion mehrere Werte zurückgibt, können Sie den Werten basierend auf den Rückgabewerten der Funktion auch Werte zuweisen.

func multipleReturn() (int, int) {
    return 1, 2
}

x, y := multipleReturn() // x = 1, y = 2

func multipleReturn2() (a int, b int) {
    a = 3
    b = 4
    return
}

w, z := multipleReturn2() // w = 3, z = 4

Leere Kennung

Go gibt einen Fehler aus, wenn eine Variable nicht verwendet wird, um Sie zu ermutigen, besseren Code zu schreiben. Es gibt jedoch Situationen, in denen Sie wirklich keinen in einer Variablen gespeicherten Wert verwenden müssen. In diesen Fällen verwenden Sie einen "leeren Bezeichner" _ , um den zugewiesenen Wert zuzuweisen und zu verwerfen.

Einem leeren Bezeichner kann ein Wert eines beliebigen Typs zugewiesen werden. Er wird am häufigsten in Funktionen verwendet, die mehrere Werte zurückgeben.

Mehrere Rückgabewerte

func SumProduct(a, b int) (int, int) {
    return a+b, a*b
}

func main() {
    // I only want the sum, but not the product
    sum, _ := SumProduct(1,2) // the product gets discarded
    fmt.Println(sum) // prints 3
}

range

func main() {

    pets := []string{"dog", "cat", "fish"}

    // Range returns both the current index and value
    // but sometimes you may only want to use the value
    for _, pet := range pets {
        fmt.Println(pet)
    }

}

Typ einer Variable prüfen

Es gibt Situationen, in denen Sie nicht sicher sind, welcher Typ eine Variable ist, wenn sie von einer Funktion zurückgegeben wird. Sie können den Variablentyp immer mit var.(type) überprüfen, wenn Sie nicht sicher sind, um welchen Typ es sich handelt:

x := someFunction() // Some value of an unknown type is stored in x now

switch x := x.(type) {
    case bool:
        fmt.Printf("boolean %t\n", x)             // x has type bool
    case int:
        fmt.Printf("integer %d\n", x)             // x has type int
    case string:
        fmt.Printf("pointer to boolean %s\n", x) // x has type string
    default:
        fmt.Printf("unexpected type %T\n", x)     // %T prints whatever type x is
}