Go
Zmienne

Składnia

• var x int // deklaruj zmienną x z typem int
• var s string // deklaruj zmienną s typem ciągu
• x = 4 // zdefiniuj wartość x
• s = "foo" // zdefiniuj wartość s
• y: = 5 // zadeklaruj i zdefiniuj y, wnioskując jego typ do int
• f: = 4.5 // deklaruj i definiuj f, określając jego typ na float64
• b: = "bar" // deklaruj i definiuj b, określając jego typ na ciąg znaków

Podstawowa deklaracja zmiennej

Go to język o typie statycznym, co oznacza, że zazwyczaj musisz zadeklarować typ używanych zmiennych.

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

Wiele przypisań zmiennych

W Go możesz zadeklarować wiele zmiennych jednocześnie.

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

Jeśli funkcja zwraca wiele wartości, możesz także przypisać wartości do zmiennych na podstawie wartości zwracanych przez funkcję.

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

Pusty identyfikator

Go rzuci błąd, gdy nieużywana jest zmienna, aby zachęcić cię do napisania lepszego kodu. Są jednak sytuacje, w których naprawdę nie trzeba używać wartości przechowywanej w zmiennej. W takich przypadkach używasz „pustego identyfikatora” _ aby przypisać i odrzucić przypisaną wartość.

Do pustego identyfikatora można przypisać wartość dowolnego typu i jest najczęściej używany w funkcjach, które zwracają wiele wartości.

Wiele wartości zwrotnych

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
}

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

}

Sprawdzanie typu zmiennej

Istnieją sytuacje, w których nie masz pewności, jakiego typu jest zmienna, gdy jest zwracana z funkcji. Zawsze możesz sprawdzić typ zmiennej, używając var.(type) jeśli nie masz pewności, jaki to typ:

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
}