Funzioni

Le funzioni sono componenti basilari di qualsiasi linguaggio di programmazione. Servono a racchiudere righe di codice, finalizzate
nel complesso al raggiungimento di un obiettivo e predisposte per la restituzione di un risultato. Anche in Go svolgono un ruolo fondamentale
e sono il blocco sintattico di base per l'articolazione dei programmi da creare.

In realtà, a questo punto, si è già avuto un primo approccio con questo costrutto infatti qualsiasi programma Go prende piede proprio da una
funzione, fatta più o meno così:

func main() {
	...
	...
}

La funzione main che qui vediamo rappresenta il tipico entry point di un programma e contiene tre
elementi principali distintivi di ogni funzione:

• la parola chiave func che segnala l'inizio di una funzione;
• il nome della funzione ovvero l'identificativo con cui essa potrà essere invocata (in questo caso main);
• le parentesi graffe destinate a contenere un blocco di codice che rappresenta il corpo della funzione.

In questa lezione, affronteremo l'approfondimento necessario per conoscere bene l'utilizzo delle funzioni in Go.

Funzioni in dettaglio

Per poter svolgere le loro operazioni, le funzioni hanno spesso bisogno di materiale su cui lavorare e per questo ricevono generalmente (anche se non obbligatoriamente)
degli argomenti in input. Ad esempio, volessimo creare la funzione somma che si occupa di ricevere due numeri in input e restituirne il risultato potremmo definirla così:

func somma(operando1 int, operando2 int) int {
	return operando1+operando2
}

I due argomenti operando1 e operando2 al momento dell'invocazione porteranno i due valori che dovranno essere
sommati. Come si vede, abbiamo specificato il loro tipo di dato, int, e ne abbiamo fatto la somma nel corpo della funzione.
È stato necessario però specificare che tale funzione dovrà essere in grado anche di restituire il risultato e per questo ci è servito indicare:

• nella prima riga il tipo di dato del risultato (la notazione int prima della parentesi graffa aperta);
• la parola chiave return che introduce il valore che costituirà il risultato della funzione.

Per attivare la funzione somma sarà sufficiente invocarla passando tra parentesi tonde i due argomenti numerici
richiesti:

func main() {
        a:=12
        b:=15
	fmt.Printf("%d + %d = %d",a,b, somma(a,b))
}

Il risultato ottenuto è il seguente:

12 + 15 = 27

Risultati multipli

Molto spesso abbiamo bisogno di fare in modo che una funzione restituisca più di un risultato e per questo Go
offre un modo ufficiale per perseguire questo obiettivo. Sarà sufficiente:

• specificare più tipi di dato di ritorno alla fine della definizione della funzione, racchiusi tra parentesi tonde;
• affidare al return più valori da restituire separati da virgole.

Vediamo un esempio subito. Supponiamo di passare una stringa ad una funzione contenente un nome ed un cognome separati da spazi e di volere
che tale funzione sia in grado di scinderli restituendoli come due stringhe separate. Ecco come fare:

import "strings"
func separaNomeCognome(nome_completo string) (string, string){
    parti:= strings.Fields(nome_completo)
    return parti[0], parti[1]
}

Per prima cosa, abbiamo importato il package strings che contiene la funzionalità che sfrutteremo per svolgere l'operazione.
Nella definizione della funzione abbiamo inserito, alla fine della prima riga, (string, string) che specifica che potremo ottenere
due risultati, entrambi di tipo stringa. Nel blocco di codice procediamo allo split della stringa e restituiamo le componenti dell'array
ottenuto mediante return parti[0], parti[1]. Come si può immaginare, ci sarebbero stati modi alternativi per ottenere tale risultato
ma in questo caso il nostro scopo era solo quello di mostrare la restituzione di valori multipli da una funzione.

Possiamo invocare la funzione nel seguente modo:

nome, cognome:=separaNomeCognome("Ignazio Rossi")
fmt.Println(nome)
fmt.Println(cognome)

ottenendo in output le due stringhe separate:

Ignazio
Rossi

Potrebbe capitare di non voler tutti i risultati ma invocare la funzione per ottenerne uno specifico: possiamo
sopperire sostituendo uno o più nomi delle variabili con un simbolo di underscore:

solo_nome, _:=separaNomeCognome("Ornella Bianchi")
fmt.Println(solo_nome)

In questo caso abbiamo chiesto di ottenere solo la prima stringa da ospitare nella variabile solo_nome. Per
evidenziare invece che la seconda stringa non ci interessa abbiamo inserito un underscore dopo la virgola. L'effetto
è quello desiderato tanto che il contenuto della variabile solo_nome corrisponde a "Ornella" ovvero la prima porzione
della stringa passata in input.