Una funzione ti consente di raggruppare il codice in un'unità riutilizzabile.
È composta dalla parola chiave func, dal nome della funzione e da un elenco di zero o più parametri e tipi separati da virgole, racchiusi tra parentesi tonde.
Parametri della funzione
Tutti i parametri devono avere un tipo esplicito; non c'è inferenza di tipo per i parametri.
Non esistono valori predefiniti per i parametri, quindi tutti i parametri di una funzione sono obbligatori.
import "fmt"
// No parameters
func PrintHello() {
fmt.Println("Hello")
}
// Two parameters
func PrintGreetingName(greeting string, name string) {
fmt.Println(greeting + " " + name)
}
I parametri dello stesso tipo possono essere dichiarati insieme, seguiti da un'unica dichiarazione di tipo.
import "fmt"
func PrintGreetingName(greeting, name string) {
fmt.Println(greeting + " " + name)
}
Parametri e argomenti
Vediamo rapidamente due termini che vengono spesso confusi tra loro: parameters e arguments.
I parametri di una funzione sono i nomi definiti nella firma della funzione, come greeting e name nella funzione PrintGreetingName qui sopra.
Gli argomenti di una funzione sono i valori concreti passati ai parametri della funzione quando chiamiamo la funzione.
Per esempio, nell'esempio sotto, "Hello" e "Katrina" sono gli argomenti passati ai parametri greeting e name:
PrintGreetingName("Hello", "Katrina")
Valori restituiti
I parametri della funzione sono seguiti da zero o più valori restituiti, che devono anch'essi avere un tipo esplicito.
I singoli valori restituiti sono lasciati senza parentesi, mentre più valori restituiti sono racchiusi tra parentesi.
I valori vengono restituiti al codice chiamante dalle funzioni usando la parola chiave return.
In una funzione possono esserci più istruzioni return.
L'esecuzione della funzione termina non appena incontra una di queste istruzioni return.
Se una funzione deve restituire più valori, questi sono separati da virgole.
func Hello(name string) string {
return "Hello " + name
}
func HelloAndGoodbye(name string) (string, string) {
return "Hello " + name, "Goodbye " + name
}
Chiamare le funzioni
Chiamare una funzione significa specificare il nome della funzione e passare gli argomenti per ciascuno dei parametri della funzione tra parentesi.
import "fmt"
// No parameters, no return value
func PrintHello() {
fmt.Println("Hello")
}
// Called like this:
PrintHello()
// One parameter, one return value
func Hello(name string) string {
return "Hello " + name
}
// Called like this:
greeting := Hello("Dave")
// Multiple parameters, multiple return values
func SumAndMultiply(a, b int) (int, int) {
return a+b, a*b
}
// Called like this:
aplusb, atimesb := SumAndMultiply(a, b)
Valori restituiti con nome e return nudo
Oltre ai parametri, anche i valori restituiti possono avere un nome opzionale.
Se si usano valori restituiti con nome, un'istruzione return senza argomenti restituirà quei valori.
Questo è noto come return «nudo».
func SumAndMultiplyThenMinus(a, b, c int) (sum, mult int) {
sum, mult = a+b, a*b
sum -= c
mult -= c
return
}
Passaggio per valore e passaggio per riferimento
È anche importante chiarire il concetto di passaggio per valore e passaggio per riferimento.
Per prima cosa, chiariamo il passaggio per valore.
Nell'esempio sotto, quando passiamo la variabile val alla funzione MultiplyByTwo, passiamo una copia di val.
Per questo motivo, newVal ha il valore aggiornato 4, ma la variabile originale val è ancora 2.
Dietro le quinte, Go crea essenzialmente una copia del valore originale, così solo questa copia, cioè v, viene modificata dalla funzione.
val := 2
func MultiplyByTwo(v int) int {
v = v * 2
return v
}
newVal := MultiplyByTwo(val)
// newval is 4, val is still 2 because only a copy of its value was passed into the function
A rigor di termini, in Go tutti gli argomenti sono passati per valore, cioè viene fatta una copia del valore o dei dati forniti alla funzione.
Ma se non vuoi fare una copia dei dati passati a una funzione e vuoi modificare i dati all'interno della funzione, allora dovresti usare pointers come argomenti, cioè il passaggio per riferimento.
Puntatori
Usiamo un pointer per ottenere il passaggio per riferimento.
Passando argomenti pointer a una funzione, possiamo modificare i dati sottostanti passati alla funzione invece di operare solo su una copia dei dati.
Per ora, è sufficiente sapere che i tipi puntatore si riconoscono dal * davanti al tipo nella firma della funzione.
func HandlePointers(x, y *int) {
// Some logic to handle integer values referenced by pointers x and y
}
Se il concetto di pointer ti confonde, non preoccuparti.
Abbiamo una sezione dedicata più avanti nel programma per aiutarti a padroneggiare i puntatori.
Eccezioni
Nota che slices e maps sono eccezioni alla regola sopra.
Quando passiamo uno slice o una map come argomenti a una funzione, vengono trattati come tipi puntatore anche se non c'è un * esplicito nel tipo.
Questo significa che se passiamo uno slice o una map a una funzione e ne modifichiamo i dati sottostanti, le modifiche si rifletteranno sullo slice o sulla map originali.
Esercizio di apprendimento
