Szukaj…
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
}