Go
variabler

Syntax

• var x int // deklarera variabel x med typ int
• var s string // deklarera variabel med typsträng
• x = 4 // definiera x-värde
• s = "foo" // definiera s-värde
• y: = 5 // förklara och definiera y sluta sin typ till int
• f: = 4.5 // förklara och definiera f att dra slutsatsen till float64
• b: = "bar" // förklara och definiera b som släpper sin typ till sträng

Grundläggande variabel deklaration

Go är ett statiskt typspråk, vilket innebär att du i allmänhet måste ange vilken typ av variabler du använder.

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

Flera variabel tilldelning

I Go kan du deklarera flera variabler samtidigt.

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

Om en funktion returnerar flera värden kan du också tilldela värden till variabler baserade på funktionens returvärden.

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

Tom identifierare

Go kommer att kasta ett fel när det finns en variabel som är oanvänd för att uppmuntra dig att skriva bättre kod. Det finns dock vissa situationer där du verkligen inte behöver använda ett värde som är lagrat i en variabel. I dessa fall använder du en "tom identifierare" _ att tilldela och kassera det tilldelade värdet.

En tom identifierare kan tilldelas ett värde av valfri typ och används oftast i funktioner som returnerar flera värden.

Flera avkastningsvärden

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
}

Använd 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)
    }

}

Kontrollera en variabelns typ

Det finns vissa situationer där du inte är säker på vilken typ en variabel är när den returneras från en funktion. Du kan alltid kontrollera en variabeltyp med var.(type) om du är osäker på vilken typ det är:

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
}