package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
)

func main() {

	nuovofile, errore := os.Create("miofile.txt")
	if errore == nil {
		fmt.Println("File creato: ", nuovofile.Name())
	} else {
		fmt.Println("Errore: ", errore)
		panic(errore)
	}
	nuovofile.WriteString("ciao a tutti")

	myWriter := bufio.NewWriter(nuovofile)
	myWriter.WriteString("\nciao a tutti")
	myWriter.Flush()
	nuovofile.Close()
	fmt.Println("File popolato")

	nuovofile, errore = os.Open("miofile.txt")
	if errore == nil {
		myslice := make([]byte, 100)
		n1, _ := nuovofile.Read(myslice)
		fmt.Println("char letti", n1)
		nuovofile.Seek(10, 0)
		n1, _ = nuovofile.Read(myslice)
		fmt.Println("char letti", n1)
	} else {
		panic(errore)
	}

	nuovofile.Seek(0, 0)
	myReader := bufio.NewReader(nuovofile)
	lettura, _, errore := myReader.ReadLine()
	if errore == nil {
		fmt.Println(string(lettura))
	} else {
		fmt.Println(errore)
	}
	nuovofile.Close()

	txt, errore := ioutil.ReadFile(nuovofile.Name())
	if errore == nil {
		fmt.Println("File letto: ", nuovofile.Name(), "->", string(txt))
	}

	errore = os.Remove(nuovofile.Name())
	if errore == nil {
		fmt.Println("File rimosso: ", nuovofile.Name())
	} else {
		fmt.Println("Errore: ", errore)
	}

}

Come si può vedere ho introdotto nuovi package: os, io/ioutil e bufio. os è il package che offre i metodi per la creazione e cancellazione dei file, ioutil offre funzioni per la manipolazione del file e bufio offre metodi bufferizzati per la lettura e scrittura

Nell’esempio in sequenza creo il file, lo popolo, ne leggo il contenuto e poi lo rimuovo dal file system.

nuovofile, errore := os.Create(“miofile.txt”) crea un file di nome miofile.txt nella directory dove eseguo il file .go. Il metodo Create restituisce 2 variabili, la prima di tipo file e la seconda di tipo Error che sarà valorizzato con il messaggio di errore se l’operazione non è possibile. Successivamente per popolare il file uso il metodo writestring della classe File e aggiungo ulteriore testo utilizzando un Writer offerto dal package bufio. Il writer bufferizzato migliora le prestazioni in caso di molte operazioni di scrittura e le rende effettive con il metodo flush, Infine con il close rendo il file disponibile per altre manipolazioni.

nuovofile, errore = os.Open(“miofile.txt”) apre il file con il nome passato come parametro e lo cerca nella directory dove il file go viene lanciato. Restituisce un oggetto di tipo file e l’eventuale errore. La lettura del contenuto può essere fatta in vari modi. La funzione Read legge il contenuto e lo salva in uno slice, restituendo in uscita il numero di caratteri letti. La funzione Seek consente di spostare il punto di inizio di lettura del file. Anche per la lettura il bufio ci mette a disposizione il reader che consente di effettuare le letture sfruttando il buffer in memoria. Il package ioutil mette a disposizione delle funzioni che agevolano l’operazione di lettura, es. txt, errore := ioutil.ReadFile(nuovofile.Name()), restituisce il contenuto del file in una variabile di tipo []byte.

Infine per cancellare il file il package io mette a disposizione la funzione Remove che riceve in ingresso il nome del file.

package main

import (
	"fmt"
	"time"
)

func main() {

	timer := time.NewTimer(time.Second * 2)

	go func() {
		<-timer.C
		fmt.Println("Passati 2 secondi")
	}()

	time.Sleep(time.Second * 5)
}

Nell’esempio ho definito un timer che scatta dopo 2 secondi e una goroutine che allo scadere del timer darà evidenza a video del tempo trascorso. La goroutine aspetta il valore inviato sul channel, attributo dell’oggetto timer. Questo meccanismo ci permette di impostare agevolmente dei timeout nel nostro codice. Tramite la funzione Stop del timer possiamo evitare la sua attivazione.

go func() {
		timer.Stop()
	}()

Qualora si voglia effettuare delle operazioni ad intervalli regolari Go mette a disposizione l’oggetto Ticker

ticker := time.NewTicker(time.Second * 1)
	go func() {
		for t := range ticker.C {
			fmt.Println("Ticker", t.Second())
			if t.Second() == 10 {
				ticker.Stop()
			}
		}
	}()

Nell’esempio ho creato un oggetto che inserisce un messaggio nel channel a intervalli regolari di un secondo. Anche il ticker presente una funzione Stop che consente di interrompere l’esecuzione del ticker.

func workerCloser(channel chan string) {
	channel <- "workerCloser"
	close(channel)
}
main() {
	canale4 := make(chan string)
	go workerCloser(canale4)
	msg3, ok := <-canale4
	fmt.Println(msg3)
	msg3, ok = <-canale4
	if !ok {
		fmt.Println("Canale chiuso")
	}
}

Nell’esempio ho realizzato una funzione che scrive un messaggio e successivamente chiude il canale. Per capire se il canale è stato chiuso o meno leggo il secondo parametro ok di tipo boolean che vale false qualora il canale sia stato chiuso esplicitamente.

Insieme al close go mette a disposizione range, che avevamo visto usato per scorrere gli slices e che applicato ai channel permette di leggere tutti i valori nel channel fino alla chiusura.

func contatore(channel chan int, max int) {
	for i := 0; i < max; i++ {
		channel <- i
	}
	close(channel)
}
main() {
	canale5 := make(chan int, 10)
	go contatore(canale5, 5)
	for valore := range canale5 {
		fmt.Println(valore)
	}
}

Nell’esempio ho creato una funzione contatore che riceve un parametro in ingresso e tramite ciclo for invia i parametri sul channel. Terminato il ciclo chiude il channel con il comando close. Nel main tramite il range leggo i valori dal channel e il ciclo si interrompe da solo. Notate che in questo caso il valore restituito dal range non l’indice ma il valore stesso.

Go permette di gestire la lettura di più channel concorrenti utilizzando la stessa goroutine. Per fare ciò si avvale del comando select che consente la lettura dei valori da channel differenti. Come sintassi ricorda molto lo switch case.

go func() {
		canale6 <- "1"
		canale6 <- "2"
	}()

	go func() {
		canale7 <- "3"
		time.Sleep(time.Second * 3)
		canale7 <- "4"
	}()

	for i := 0; i < 4; i++ {
		select {
		case mess1 := <-canale6:
			fmt.Println(mess1)
		case mess2 := <-canale7:
			fmt.Println(mess2)
		default:
			fmt.Println("Niente")
		}
	}

Nell’esempio ho creato 2 funzioni anonime che scrivono i messaggi su 2 channel separati, tramite il comando select inserito all’interno nel ciclo for recupero tutti i valori inviati. Nel caso di messaggi concorrenti la select sceglie casualmente quale processare per primo. Con lo statement default possiamo implementare della logica da eseguire qualora non sia presente alcun dato nei channel gestiti dal select. Senza default la select rimarrà in attesa di messaggi dal channel ad ogni iterazione.

Il costrutto select consente anche di implementare in modo agevole un meccanismo di timeout tramite la funzione After del package time.

for i := 0; i < 2; i++ {
		select {
		case mess1 := <-canale6:
			fmt.Println(mess1)
		case <-time.After(time.Second * 2):
			fmt.Println("timeout")
		}
	}

La funzione After simula la ricezione di un messaggio nel channel, in tal modo implementiamo una attesa di 2 secondi sul channel canale, trascorso il quale viene gestita la condizione di timeout.

Infine qualora si voglia gestire l’accesso concorrente a risorse di più goroutines Go mette a disposizioni le funzioni Lock e Unlock del package sync. I 2 comandi ci assicurano che solo un thread per volta potrà eseguire il codice compreso tra i 2 statement

func (cont *contatoreStruct) somma(val int) {
	var mutex sync.Mutex
	mutex.Lock()
	cont.counter = cont.counter + val
	mutex.Unlock()
}

package main

import (
	"fmt"
	"time"
)

func hello() {
	fmt.Println("ciao mondo")
}

func main() {

	hello()

	go hello()

	go func() {
		hello()
	}()

	time.Sleep(time.Second * 3)
}

Nell’esempio ho definito la func hello che si limita a stampare a video il classico messaggio “ciao mondo” e per invocarne l’esecuzione chiamo la function anteponendo la parola chiave go, con cui avvio un thread dedicato per l’esecuzione. Notate che ho importato il package time con cui ho impostato un attesa di 5 secondi per vedere il messaggio stampato altrimenti il programma avrebbe finito la sua esecuzione e non avremmo visto niente a schermo. Con semplicità ho gestito in maniera asincrona una funzione che non lo era. La parola chiave go può essere applicata anche a funzioni anonime ottenendo lo stesso effetto.

Le goroutines comunicano tra di loro tramite i channel,canali di comunicazioni monodirezionali detti in informatica pipe. Per creare una pipe si usa la parola chiave make seguito dalla parola chiave chan e il tipo di dato gestito. L’invio o la ricezione del dato avviene tramite la parola chiave -> e <-

messaggi := make(chan string)
	go func() {
		time.Sleep(time.Second * 3)
		messaggi <- "ciao"
	}()
	msg := <-messaggi
	fmt.Println(msg)

Nell’esempio ho creato un chanel che accetta stringhe e nella goroutine anonima ho inviato la stringa “ciao” tramite il comando channel <- con un ritardo di 3 secondi. Con il comando <- channel effettuo la lettura del dato e in questo caso non è stato necessario gestire ritardi e sincronizzazione perchè l’esecuzione del codice si interrompe in attesa della lettura del flusso dal channel.

Go mette a disposizione i channel con buffer, ovvero channel che possono ricevere più di un valore in attesa che poi venga letti. La sintassi prevede la dimensione del buffer successivamente al tipo gestito.

messaggiBufferend := make(chan string, 2)
	messaggiBufferend <- "Ciao"
	messaggiBufferend <- "Mondo"

Nell’esempio ho creato un channel con dimensione del buffer pari a 2 e su questo ho inviato 2 messaggi separati.

Grazie ai channel è possibile sincronizzare i processi visto che i channel bloccano l’esecuzione dei comandi stando in attesa di un valore.

func worker(channel chan string) {
	time.Sleep(time.Second * 3)
	channel <- "fine"
}
main () {
	canale := make(chan string)
	go worker(canale)
	msg2 := <-canale
	fmt.Println(msg2)
}

Nell’esempio ho creato una funzione worker che attende 3 secondi prima di comunicare la fine sul channel ricevuto come parametro. Nel main avvia la goroutine con il worker e resto in attesa dell’esito della elaborazione per chiudere l’esecuzione.

E’ possibile stabilire in sede di passaggio di una channel ad una funzione la direzione del channel, ovvero specificare se è abilitata l’invio o la ricezione

func chiamante(channel chan<- string) {
	channel <- "sono il ricevente"
}

func ricevente(channel <-chan string) {
	fmt.Println(<-channel)
}
main () {
	can := make(chan string)
	go chiamante(can)
	go ricevente(can)
}

Nell’esempio ho definito una funzione chiamante che accetta un channel su cui inviare solo dati, una finzione ricevente che accetta un channel che riceve solo dati e nel main ho lanciato le go routine associate.

Nel prossimo articolo vedremo altre funzioni collegate ai channel

package main

import (
	"errors"
	"fmt"
)

func noerrore(valore string) string {
	return valore
}

func possibileerrore(valore string) error {
	var error error
	if valore == "prova" {
		error = errors.New("Valore non ammesso")
	}
	return error
}

func valoreconpossibileerrore(valore string) (string, error) {
	var error error
	if valore == "prova" {
		error = errors.New("Valore non ammesso")
	}
	return valore, error
}

func main() {
	fmt.Println(noerrore("prova"))
	fmt.Println(possibileerrore("prova"))
	fmt.Println(valoreconpossibileerrore("prova"))
}

Nell’esempio ho creato 3 funzioni con 3 comportamenti distinti: la prima non può generare un errore, la seconda può generare un errore, la terza restituisce una stringa e può generare un errore. Per convenzione l’errore è l’ultimo tipo di valore restituito e in assenza di errore esso vale nil. Per generare l’errore ci viene in soccorso il package errors che mette a disposizione la funzione New che genera un errore contenente un testo.

Go ci permette di definire nuovi tipi di errori basati sul comando structs, la cosa fondamentale è che essi implementino l’interafaccia error che presenta il metodo Error da implementare

type myError struct {
	codice      int
	descrizione string
}

func (e *myError) Error() string {
	return fmt.Sprintf("%d - %s", e.codice, e.descrizione)
}

func possibileMyerrore(valore string) error {
	var error error
	if valore == "prova" {
		error = &myError{1, "KO"}
	}
	return error
}

In questo caso ho definito un error custom che presenta i campi codice e descrizione. Ho implementato la funzione Error() che sostanzialmente fa il toString dell’errore e implementato un metodo di esempio che lo utilizza

A questo punto il metodo restituisce una interfaccia error e pertanto non sono accessibili i campi della struct definita. Per ovviare a questa limite occorre sfruttare il meccanismo della type assertion che permette di forzare il tipo che si desidera (il meccanismo ricordo il casting di java) e il gioco è fatto.

var errore = possibileMyerrore("prova")
	var er = errore.(*myError)
	fmt.Println(er.codice)

func duplica(valore string) string {
	return valore + valore
}

Nel caso sopra ho definito la funzione duplica che riceve in ingresso una stringa e restituisce la string concatenata con se stessa

E’ possibile definire più parametri in ingresso e se i parametri sono dello stesso tipo Go permette di dichiarare il tipo una volta sola

func concatena(primo string, secondo string) string {
	return primo + secondo
}

func concatena2(primo, secondo string) string {
	return primo + secondo
}

In questo caso la funzione concatena riceve 2 stringhe in ingresso e le concatena dando il valore in uscita. Essendo parametri dello stesso tipo è possibile dichiarare il tipo una volta sola.

Anche in uscita è possibile definire più parametri

func conta(primo, secondo string) (int, int) {
	var a = len(primo)
	var b = len(secondo)
	return a, b
}
func main() {
	fmt.Println(conta("primo", "secondo"))
	var _, b = conta("primo", "secondo")
	fmt.Println(b)
}

In questo la funzione restituisce la lunghezza delle 2 stringhe ricevute in ingresso. E’ possibile anche ignorare una delle 2 variabili tramite la parola chiave _.

Go mette anche a disposizione un meccanismo per definire un numero infinito di parametri in ingresso tramite la parola chiave …

func conta2(parole ...string) {
	for _, parola := range parole {
		fmt.Print(fmt.Sprintf("%d ", len(parola)))
	}
}

In questo caso ho definito una lista di valori in ingresso e per ognuno di essi restituisco la lunghezza della parola

Go permette di ritornare la funzione come tipo di ritorno di una funzione e di assegnarla ad una funzione e di poterlo assegnare ad una variabile

func conta3() func(...string) {
	var counter int = 1
	return func(parole ...string) {
		fmt.Print("esecuzione ", counter, " ")
		counter++
		for _, parola := range parole {
			fmt.Print(fmt.Sprintf("%d ", len(parola)))
		}
		fmt.Println()
	}
}

func main() {
        contatore := conta3()
	contatore("primo", "secondo", "terzo")
	contatore("terzo", "quarto", "quinto")

	contatore2 := func(parole ...string) {
		for _, parola := range parole {
			fmt.Print(fmt.Sprintf("%d ", len(parola)))
		}
		fmt.Println()
	}

	contatore2("primo", "secondo", "terzo")
	contatore2("terzo", "quarto", "quinto")
}

Nell’esempio ho definito una funzione conta3 che riceve una lista di valori variabili in ingresso e che per ognuno di essi elabora la lunghezza e la stampa. Successivamente assegno la funzione ad una variabile e la eseguo invocando la variabile stessa con i parametri in ingresso. Posso ottenere un comportamento analogo definendo la function direttamente dopo il nome della variabile ma in questo caso perdo la gestione della variabile di stato counter.

Infine Go supporta la ricorsione ovvero una funzione che elabora il risultato richiamando se stesso e basando il tutto su una condizione di uscita. Classico esempio è la funzione fattoriale

func fattoriale(valore int) int {
	if valore == 0 {
		return 1
	} else {
		return valore * fattoriale(valore-1)
	}
}

package main

import "fmt"

func main() {
	var ar [5]int
	fmt.Println(ar)

	var br = [5]string{"a", "b", "c", "d", "e"}
	fmt.Println(br)

	br[0] = ""
	fmt.Println(br)

	var multi [3][3]string
	for i := 0; i < 3; i++ {
		multi[i][0] = "0"
		multi[i][1] = "X"
		multi[i][2] = "0"
	}
	fmt.Println(multi)

	fmt.Println(len(multi))
}

la sintassi per definire l’array prevede la parola var, il nome della variabile (in questo caso ar), numero di elementi in esso contenuti previsti compreso tra [] e il tipo degli elementi. In assenza di inizializzazione si applicano le regole 0 per numeri, false per booleani, stringa vuota per Stringhe. Per l’inizializzazione si usano le parentesi {} con i valori previsti separati da ,.

Per accedere al singolo elemento si specifica l’indice tra [], considerando che l’indice parte da 0.

Per conoscere quanti elementi contiene l’array Go mette a disposizione il comando len.

E’ possibile definire array multidimensionali specificando più volte le varie dimensioni sempre racchiuse tra [].

Il limite dell’array è che ha una dimensione fissa e non può essere esteso, quindi va usato in caso dove la dimensione è nota a priori, negli altri casi Go mette a disposizione il tipo slices.

Devo dire che lo slices come concetto è carico, esso supera i limiti dell’array appoggiandosi sempre ad un array che Go gestisce internamente.

Per instanziare lo slice si usa il comanda make che riceve in ingresso 3 parametri: il tipo di elementi, la lunghezza iniziale dello slices e la sua capacità. La capacità è opzionale ed in usa assenza verrà inizializzata con il valore della lunghezza.

var sl = make([]int, 0, 3)
	fmt.Println(len(sl), cap(sl))
	for i := 0; i < 5; i++ {
		sl = append(sl, i)
		fmt.Println(len(sl), cap(sl))
	}

Nell’esempio ho creato uno slice che non ha nessun elemento presente ma che prevede una capacità iniziale di 3 elementi, superati il quale Go estenderà in automatico. Tramite il ciclo for aggiungo in coda un elemento che Go farà senza problemi appoggiandosi ad un array virtualmente infinito. Infatti lo slice rappresenta una sezione di un array di sistema

Go permette anche di gestire lo slices a partire da un array definito dall’utente specificando gli indici separati da :, indici che possono essere opzionali e in loro assenza viene considerata l’intera sezione dell’array.

var slbr []string = br[2:4]
	fmt.Println(slbr)

	var slbr1 []string = br[:4]
	fmt.Println(slbr1)

	var slbr2 []string = br[0:]
	fmt.Println(slbr2)

	var slbr3 []string = br[:]
	fmt.Println(slbr3)

	var slb3copy = make([]string, len(slbr3))
	copy(slb3copy, slbr3)
	fmt.Println(slbr3, slb3copy)

	for i, v := range slb3copy {
		fmt.Printf("%d = %s\n", i, v)
	}
       
       for i := range slb3copy {
		fmt.Printf("%d = %s\n", i, "")
	}

	for _, v := range slb3copy {
		fmt.Printf("%d = %s\n", 0, v)
	}

Ogni modifica fatta sullo slice sarà visibile sull’array e viceversa, proprio perchè lo slice rappresenta una vista su quell’array. Tramite il comando copy sarà possibile copiare il contenuto dello slice verso un altro slice.

Per poter ciclare su uno slice ci viene in comando il comando range che restituisce 2 valori : indice e copia del valore contenuto nella cella. i valori possono essere omessi se non di interesse usando la chiave _.

Infine affrontiamo il concetto di map, che è una struttura che rappresenta il concetto di chiave/valore, e vediamo le operazioni che su di essa si possono effettuare,

var mp map[string]string = make(map[string]string)
	mp["chiave"] = "valore"
	fmt.Println(mp)
	delete(mp, "chiave")
	fmt.Println(mp)
	mp["chiave1"] = "valore1"
	mp["chiave2"] = "valore2"
	eleme, ok := mp["chiave2"]
	fmt.Println(eleme, ok)
	eleme1, ok1 := mp["chiave3"]
	fmt.Println(eleme1, ok1)
	for i, v := range mp {
		fmt.Println(i, v)
	}

Definiamo la variabile mp come mappa con la chiave di tipo string e il valore string. Per instanziare la variabile usiamo il comando make. Per inserire un record usiamo l’espressione nomevariabile[nomechiave]= valore. Dopo aver inserito il record possiamo eliminarlo tramite il comando delete che in ingresso vuole la mappa e la chiave che definisce il record. Per leggere il valore si usa l’espressione nomevariabile[nomechiave] che restituisce 2 valori, il valore stesso e un boolean che indica se la chiave è stata trovata o meno. Nel caso in cui la chiave sia assente viene restituita una stringa vuota. Anche in questo caso possiamo usare la parola chiave range che ci restituisce per ogni record chiave e valore.

Alla prossima

package main

import "fmt"

type persona struct {
	nome    string
	cognome string
}

func main() {

	var io persona
	io.cognome = "finazzo"
	io.nome = "valerio"
	fmt.Println(io)
	var sempreio = persona{"valerio", "finazzo"}
	fmt.Println(sempreio)
	var ancoraio = persona{nome: "valerio", cognome: "finazzo"}
	fmt.Println(ancoraio)
}

Tramite il comando type persona struct ho definito una struttura dati chiamata persona che presenta 2 attributi nome e cognome di tipo string. Nel main ho instanziato la variabile persona e valorizzato gli attributi opportunamente usando il . per accedere alle sue varibili. Go permette di inizializzare direttamente l’oggetto tramite il nome stesso della struttura passando direttamente i valori, oppure specificando i valori con la coppia nome valore separati da :.

Go supporta i puntatori, ovvero il riferimento a zone di memoria per accedere al valore contenuto in esso. I comandi per gestire i puntatori sono * e &.

var puntatoreame *persona = &io
	fmt.Println(puntatoreame.nome, puntatoreame.cognome)
	puntatoreame.cognome = "finazzo2"
	fmt.Println(puntatoreame.nome, puntatoreame.cognome)
	fmt.Println(io.nome, io.cognome)

	var nuovamenteio persona = io
	fmt.Println(nuovamenteio)
	nuovamenteio.cognome = "finazzo3"
	fmt.Println(nuovamenteio.nome, nuovamenteio.cognome)
	fmt.Println(io.nome, io.cognome)

Tramite * definisco un puntatore verso una struttura di tipo persona e tramite & la inizializzo verso la zona di memoria occupata dalla struttura io. A questo punto agisco su uno degli attributi di puntatoreame e vedrò le modifiche attive anche su io.

Il blocco successivo che non usa i puntatori crea una nuova variabile che ha gli stessi valori ma le modifiche che faccio successivamente non si ripercuotono sulla istanza io.

• FOR

il costrutto for è un costrutto iterativo e consente di iterare un comando n volte fino a che è valida la condizione di controllo

package main
import "fmt"
const limite = 5
// Stampa - commento
func main() {
	for i := 0; i < limite; i++ {
		fmt.Println(i)
	}
}

nel ciclo for ho inizializzato la variabile i con 0 (Non ho esplicitato il tipo perchè Go lo desume da solo), ho definivo la condizione per continuare l’iterazione (i deve essere minore della costante limite) e ho definito la regola di incremento ( in questo caso i cresce di una unità per ogni iterazione). Rispetto ad altri linguaggi come java non sono richieste parentesi per chiudere i comandi di inizializzazione del for, mentre sono obbligatorie le parentesi {} per racchiudere il blocco di operazioni da effettuare.

La condizione di inizializzazione e la condizione di incremento sono opzionali, pertanto posso scrivere il codice in questo, rendendo il codice equivalente ad un costrutto while.

j := 0
for j < limite {
	fmt.Println(j)
	j = j + 1
}

Anche la condizione di uscita può essere omessa, ottenendo così un ciclo virtualmente infinito che può essere pilotato tramite il comando break che interrompe l’esecuzione.

z := 0
for {
	z = z + 1
	fmt.Println(z)
	if z == 5 {
		break
	}
}

Insieme al comando break può essere usato il comando continue che permette di saltare l’iterazione corrente e andare alla prossima.

• IF

Il costrutto IF è un costrutto di seleziona e consente di eseguire il codice contenuto nelle sue parentesi {} al verificare di una condizione booleana. Se guardate il codice precedente quando il contatore vale 5 il sistema interrompe il ciclo con il comando break.

Tramite il comando else è possibile definire un blocco di operazioni alternativo ed inoltre è possibile all’interno del blocco if definire una assegnazione ad una variabile che sarà visibile solo nel blocco if.

z := 0
for {
	z = z + 1
	if d := z; d == 5 {
		fmt.Println("fine")
		break
	} else {
		fmt.Println(d)
	}
}

Nel blocco ho introdotto una variabile d inizializzata con il valore di z e ho definito una condizione alternativa a quella di uscita, grazie alla quale stampo il valore corrente dell’indice.

• SWITCH

Il costrutto switch è un costrutto di selezione e ci viene in aiuto quando dobbiamo gestire la verifica di n possibili valori. Invece di usare tanti if/else annidati lo switch case ci consente di gestire in modo elegante la casistisca descritta.

switch z {
case 1:
	fmt.Println(1)
case 2:
	fmt.Println(2)
case 3, 4:
	fmt.Println("3 o 4")
case 1 * 5:
	fmt.Println("5")
default:
	fmt.Println("default")
}

Nel blocco sopra sto verificando il valore di z, gestendo le casistiche 1 e 2 con apposito output, per gli altri valori viene stampato il valore default. Quando la condizione viene riscontrata il sistema esegue il codice relativo, a differenza di altri linquaggi come JAVA non è necessario specificare la chiave break. Nella clausola case possono essere presenti più condizioni separate da virgola ed è possibile inserire l’output di una funzione, l’importante che il tipo sia dello stesso tipo delle altre clausole.

E’ possibile anche omettere la condizione da verificare ottenendo un modo più elegante per scrivere degli if/else in cascata specificando la regola di ingresso a livello del blocco case. Lo stesso codice di sopra può essere riscritto come segue

switch {
case z == 1:
	fmt.Println(1)
case z == 2:
	fmt.Println(2)
case z == 3 || z == 4:
	fmt.Println("3 o 4")
case z == 1*5:
	fmt.Println("5")
default:
	fmt.Println("default")
}

• DEFER

Il costrutto DEFER è un comando interessante. Consente di eseguire un codice alla fine del programma. Agisce come una pila con una logica di tipo First In Last Out, pertanto il primo comando inserito sarà l’ultimo ad essere eseguito.

package main

import "fmt"

const limite = 5

func main() {

	defer fmt.Println("Fatto quello che c'era da fare")
	defer fmt.Println("Sto per scrivere il penultimo messaggio")

	for i := 0; i < limite; i++ {
		fmt.Println(i)
	}

	j := 0
	for j < limite {
		fmt.Println(j)
		j = j + 1
	}

	var z int = 0
	for {
		z = z + 1
		if d := z; d == 5 {
			fmt.Println("fine")
			break
		} else {
			fmt.Println(d)
		}
	}

	switch z {
	case 1:
		fmt.Println(1)
	case 2:
		fmt.Println(2)
	case 3, 4:
		fmt.Println("3 o 4")
	case 1 * 5:
		fmt.Println("5")
	default:
		fmt.Println("default")
	}

	switch {
	case z == 1:
		fmt.Println(1)
	case z == 2:
		fmt.Println(2)
	case z == 3 || z == 4:
		fmt.Println("3 o 4")
	case z == 1*5:
		fmt.Println("5")
	default:
		fmt.Println("default")
	}
}

Ottenendo così l’output atteso

0
1
2
3
4
0
1
2
3
4
1
2
3
4
fine
5
5
Sto per scrivere il penultimo messaggio
Fatto quello che c'era da fare

Il package principale è main ed è quello da cui parte la nostra applicazione. Possiamo importare altri package per estendere le funzionalità a nostra disposizione e lo facciamo tramite la direttiva import. I package hanno la classica struttura ad albero, importante sapere che per invocare le funzioni all’interno del programma va usato l’ultimo nodo della definizione del package.

package main
import (
	"fmt"
	"math/rand"
)
func main() {
	fmt.Print(rand.Intn(100))
}

Nel codice sopra ho definito il package main, ho fatto l’import di 2 package di sistema e nella function main ho provveduto a stampare il risultato della chiamata random. Come potete vedere per invocare la funzione ho utilizzato l’ultima parte del nome del package rand.

L’elenco completo dei package di sistema è disponibile qui. L’import multiplo può essere fatto anche invocando più volte la direttiva import per ogni package ma così risulta più compatto.

A questo punto introduciamo le variabili, esse possono essere definite a livello di package o a livello di funzione, possono essere definite in modo esplicito tramite la chiave var e relativo tipo oppure lasciamo che sia Go a dedurre il tipo.

package main

import (
	"fmt"
	"math/rand"
)

var principale int = 10
var i, j, k int = 1, 3, 4
var numberFloat float64

func main() {
	fmt.Println(rand.Intn(100))
	secondaria := true
	fmt.Println(principale)
	fmt.Println(secondaria)
	fmt.Println(i + j + k)
	fmt.Println(numberFloat)
	numberFloat = float64(principale)
	fmt.Println(numberFloat)
}

Nel blocco ho definito una variabile principale a livello di package tramite var e specificando il tipo, mentre ho definito una variabile secondaria a livello di function specificando direttamente il valore e lasciando decidere al compilatore la deduzione del tipo. L’operatore := può essere usato solo dentro una function.

Go mira alla stesura di codice compatto e permette la definizione di più variabili e relativa inizializzazione nello stesso statement.

I tipi semplici previsti da Go sono i sequenti:

bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias per il tipo uint8
rune // alias per il tipo int32
float32 float64
complex64 complex128

Quando si definisce una variabile e non si specifica il valore il sistema inizializza con 0 i numeri, false i tipo bool e stringa vuota i tipi string. La conversione tra i tipi non è implicita ma deve essere gestita tramite l’opprtuna funzione.

Tramite l’operatore const è possibile definire delle costanti, se definite con lettera maiuscola saranno visibili al di fuori del package e dovranno presentare un commento a corredo

// Costante - esempio
const Costante = 10