Funzioni in Golang: dichiarare, chiamare e passare funzioni

Dichiarare una funzione

Una dichiarazione di funzione è composta da func, un nome, i parametri, il tipo del risultato e un corpo. Il tipo va dopo il nome del parametro, non prima.

package main

import "fmt"

func add(a int, b int) int {
	return a + b
}

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add riceve due valori int e restituisce un int. greet non restituisce niente, quindi la sua firma non ha un tipo di risultato e il suo corpo non ha bisogno di return.

Una funzione che dichiara un risultato deve terminare con un'istruzione di chiusura. Se qualche percorso può raggiungere la parentesi graffa finale senza ritornare, il compilatore si ferma con missing return.

Parametri che condividono un tipo

Parametri consecutivi dello stesso tipo possono condividere un unico nome di tipo. func add(a, b int) int significa esattamente la stessa cosa di func add(a int, b int) int. Si possono anche mescolare:

func scale(x, y float64, factor int) (float64, float64)

Qui x e y sono float64 e factor è un int.

Valori di ritorno

Una funzione può restituire zero, uno o più valori. Più risultati vanno tra parentesi, e il chiamante li riceve con un'assegnazione multipla:

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

Stampa 3 2. La coppia (value, error) è l'uso più comune di questa funzionalità in Go, e ha una pagina dedicata sui valori di ritorno multipli.

Gli argomenti vengono copiati

Go passa ogni argomento per valore. La funzione lavora su una copia, quindi assegnare un valore a un parametro non modifica mai la variabile del chiamante.

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

L'output è:

{1 2}
{100 2}
[99 2 3]

La terza riga sorprende molti. Un valore slice è una piccola intestazione (puntatore, lunghezza, capacità). La copia punta allo stesso array sottostante, quindi scrivere s[0] scrive l'elemento del chiamante. Però append dentro la funzione può allocare un nuovo array, e il chiamante non vede mai quella nuova intestazione. Se una funzione fa crescere uno slice, restituisci il nuovo slice. La stessa logica vale per le mappe: la funzione può aggiungere chiavi che il chiamante vede, perché il valore map fa riferimento a dati condivisi.

Usa un parametro puntatore quando la funzione deve modificare la variabile del chiamante, oppure quando il valore è una struct grande che non vuoi copiare a ogni chiamata.

Le funzioni sono valori

Una funzione ha un tipo, scritto senza il nome: func(int, int) int. Puoi memorizzare una funzione in una variabile, metterla in una mappa o in uno slice e passarla a un'altra funzione.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square è una funzione anonima assegnata a una variabile. Le funzioni anonime possono anche leggere e modificare variabili dello scope circostante, il che le rende closure.

Un tipo funzione con nome rende le firme più leggibili quando la stessa forma compare in molti punti:

type Transform func(int) int

func apply(xs []int, f Transform) []int

Il valore zero di un tipo funzione è nil. Chiamare una funzione nil provoca il panic invalid memory address or nil pointer dereference, quindi controlla le callback opzionali prima di chiamarle. I valori funzione si possono confrontare solo con nil, mai tra loro.

Ricorsione

Una funzione può chiamare sé stessa. Go non ha l'ottimizzazione delle chiamate in coda, ma gli stack delle goroutine crescono quando serve, quindi le normali profondità di ricorsione non sono un problema.

package main

import "fmt"

func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6 conta da 0 a 5 e richiede Go 1.22 o successivo.

Cosa non hanno le funzioni Go

• Niente overloading. Due funzioni nello stesso package non possono avere lo stesso nome, neanche con parametri diversi.
• Niente argomenti predefiniti o con nome. Ogni parametro viene passato a ogni chiamata, nell'ordine. Una struct di configurazione ti dà campi con nome e facoltativi: NewServer(Config{Port: 8080}).
• Niente funzioni con nome annidate. Dentro il corpo di una funzione puoi dichiarare solo funzioni anonime, di solito assegnate a una variabile.

Le liste di argomenti di lunghezza variabile sono supportate tramite le funzioni variadiche.

Funzioni esportate e non esportate

Una funzione il cui nome inizia con una lettera maiuscola (Parse) è esportata e si può chiamare da altri package. Un nome in minuscolo (parse) è visibile solo dentro il proprio package. Non esistono parole chiave public o private; la maiuscola è l'intera regola.

Errori comuni

• Aspettarsi che la modifica di un parametro arrivi al chiamante. Assegnare un valore a un parametro modifica solo la copia. Restituisci il nuovo valore o accetta un puntatore.
• Fare append dentro una funzione e ignorare il risultato. func add(s []int) { s = append(s, 1) } non ha effetto sulla lunghezza dello slice del chiamante. Scrivi func add(s []int) []int e usa s = add(s).
• Risultati inutilizzati. Go permette di ignorare un valore di ritorno. go vet non segnala un errore scartato, ma linter come errcheck (parte di golangci-lint) sì. Usa _ = solo quando ignorarlo è una scelta.