Go
Variabelen

Syntaxis

• var x int // declareer variabele x met type int
• var s string // declareer variabele s met type string
• x = 4 // definieer x waarde
• s = "foo" // definieer s waarde
• y: = 5 // declareer en definieer y en leid het type af naar int
• f: = 4.5 // declareer en definieer f en leid het type af naar float64
• b: = "bar" // declareer en definieer b leid het type daarvan naar string

Basis variabele verklaring

Go is een statisch getypte taal, wat betekent dat u meestal het type van de variabelen die u gebruikt moet aangeven.

// 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

Meerdere variabele toewijzing

In Go kunt u meerdere variabelen tegelijkertijd declareren.

// 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`

Als een functie meerdere waarden retourneert, kunt u ook waarden toewijzen aan variabelen op basis van de retourwaarden van de functie.

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

Blanco ID

Go geeft een foutmelding wanneer er een variabele is die niet wordt gebruikt, om u aan te moedigen betere code te schrijven. Er zijn echter enkele situaties waarin u echt geen waarde hoeft te gebruiken die is opgeslagen in een variabele. In die gevallen, een "blanco identifier" gebruikt u _ toewijzen en gooi de toegekende waarde.

Aan een blanco ID kan een waarde van elk type worden toegewezen en wordt meestal gebruikt in functies die meerdere waarden retourneren.

Meerdere retourwaarden

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
}

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

}

Het type van een variabele controleren

Er zijn enkele situaties waarin u niet zeker weet welk type een variabele is wanneer deze wordt geretourneerd door een functie. U kunt het type van een variabele altijd controleren met var.(type) als u niet zeker weet welk type het is:

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
}