Go
variabili

Sintassi

• var x int // declare la variabile x con tipo int
• var s string // dichiara la variabile s con tipo string
• x = 4 // definisce il valore x
• s = "pippo" // definisce il valore s
• y: = 5 // dichiara e definisce y inferendo il suo tipo a int
• f: = 4.5 // dichiara e definisce f inferendo il suo tipo a float64
• b: = "bar" // dichiara e definisce b inferendo il suo tipo a stringa

Dichiarazione delle variabili di base

Go è un linguaggio tipizzato staticamente, il che significa che in genere devi dichiarare il tipo di variabili che stai utilizzando.

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

Assegnazione di variabili multiple

In Go, puoi dichiarare più variabili allo stesso tempo.

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

Se una funzione restituisce più valori, è anche possibile assegnare valori alle variabili in base ai valori di ritorno della funzione.

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

Identificatore vuoto

Go genererà un errore quando è presente una variabile non utilizzata, al fine di incoraggiarti a scrivere codice migliore. Tuttavia, ci sono alcune situazioni in cui davvero non è necessario utilizzare un valore memorizzato in una variabile. In questi casi, si utilizza un "identificativo vuoto" _ per assegnare e scartare il valore assegnato.

Ad un identificatore vuoto può essere assegnato un valore di qualsiasi tipo ed è più comunemente utilizzato in funzioni che restituiscono più valori.

Più valori di ritorno

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
}

Usando la 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)
    }

}

Controllo del tipo di una variabile

Ci sono alcune situazioni in cui non si è sicuri di quale sia il tipo di variabile quando viene restituito da una funzione. Puoi sempre controllare il tipo di una variabile usando var.(type) se non sei sicuro di quale tipo sia:

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
}