Archivi categoria: DOCUMENTAZIONE

La categoria contiene tutta la documentazione disponibile per la consultazione

Go gestisce il tempo tramite gli oggetti timer e tick. Il timer rappresenta un evento che si verifica una sola volta e si manifesta tramite l’invio di un dato su un channel ad esso associato.

package main
import (
"fmt"
"time"
)
func main() {
timer := time.NewTimer(time.Second * 2)
go func() {
&lt;-timer.C
fmt.Println("Passati 2 secondi")
}()
time.Sleep(time.Second * 5)
}

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()
}()

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()
}
}
}()

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.

GOLANG

TUTORIAL GO – GESTIRE LA COMUNICAZIONE CON I CHANNEL

19/08/2020 admin

Nell’articolo precedente abbiamo illustrato un primo meccanismo per notificare al ricevente la chiusura del channel, ovvero l’invio di una stringa dedicata che comunica la fine del flusso. Go mette a disposizione la funzione close con cui esplicitare che il canale è stato chiuso, la chiusura non è una operazione obbligatoria come nel caso dei file, ma permette di notificare al ricevente in modo esplicito la chiusura dello stream di dati.

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

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 &lt; max; i++ {
channel &lt;- i
}
close(channel)
}
main() {
canale5 := make(chan int, 10)
go contatore(canale5, 5)
for valore := range canale5 {
fmt.Println(valore)
}
}

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 &lt;- "1"
canale6 &lt;- "2"
}()
go func() {
canale7 &lt;- "3"
time.Sleep(time.Second * 3)
canale7 &lt;- "4"
}()
for i := 0; i &lt; 4; i++ {
select {
case mess1 := &lt;-canale6:
fmt.Println(mess1)
case mess2 := &lt;-canale7:
fmt.Println(mess2)
default:
fmt.Println("Niente")
}
}

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 &lt; 2; i++ {
select {
case mess1 := &lt;-canale6:
fmt.Println(mess1)
case &lt;-time.After(time.Second * 2):
fmt.Println("timeout")
}
}

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()
}

func (cont *contatoreStruct) somma(val int) {

var mutex sync.Mutex

mutex.Lock()

cont.counter = cont.counter + val

mutex.Unlock()

}

GOLANG

TUTORIAL GO – GOROUTINES E CHANNEL

17/08/2020 admin

Go supporta i thread per la gestione di processi asincroni e lo fa in un modo estremamente semplice. Go usa la parola chiave go per avviare una function in modalità asincrona.

package main
import (
"fmt"
"time"
)
func hello() {
fmt.Println("ciao mondo")
}
func main() {
hello()
go hello()
go func() {
hello()
}()
time.Sleep(time.Second * 3)
}

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 &lt;- "ciao"
}()
msg := &lt;-messaggi
fmt.Println(msg)

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 &lt;- "Ciao"
messaggiBufferend &lt;- "Mondo"

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 &lt;- "fine"
}
main () {
canale := make(chan string)
go worker(canale)
msg2 := &lt;-canale
fmt.Println(msg2)
}

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&lt;- string) {
channel &lt;- "sono il ricevente"
}
func ricevente(channel &lt;-chan string) {
fmt.Println(&lt;-channel)
}
main () {
can := make(chan string)
go chiamante(can)
go ricevente(can)
}

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

GOLANG

TUTORIAL GO – GESTIONE DEGLI ERRORI

13/08/2020 admin

Go introduce l’errore a livello di funzione, ovvero in Go solo una funzione può generare un errore e la sua presenza deve essere dichiarata tramite la parola chiave error

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"))
}

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 = &amp;myError{1, "KO"}
}
return error
}

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)

var errore = possibileMyerrore("prova")

var er = errore.(*myError)

fmt.Println(er.codice)

GOLANG

TUTORIAL GO – METODI E INTERFACCE

11/08/2020 admin

Go non consente di definire le classi ma consente di definire dei metodi disponibili per una struttura.

package main
import "fmt"
//Persona - commento
type Persona struct {
nome    string
cognome string
}
func (p Persona) iniziali() {
fmt.Println(p.nome[0:1] + p.cognome[0:1])
}
func main() {
var io = Persona{"Valerio", "Finazzo"}
io.iniziali()
}

package main

import "fmt"

//Persona - commento

type Persona struct {

nome string

cognome string

}

func (p Persona) iniziali() {

fmt.Println(p.nome[0:1] + p.cognome[0:1])

}

func main() {

var io = Persona{"Valerio", "Finazzo"}

io.iniziali()

}

Nel blocco sopra ho definito una struttura Persona che contiene nome e cognome. Per definire un metodo si usa una sintassi simile alla definizione di una funzione. Si usa la parola chiave func, definita dalla struttura cui si applica, il nome del metodo, la lista dei parametri che riceve in ingresso e l’eventuale output. Nello specifico ho definito un metodo iniziali che stampa le iniziali della persona.

Nell’esempio di sopra il metodo definito sfrutta il passaggio per valore, ovvero il metodo opera su una copia della struttura persona senza modificare i valori dell’istanza di partenza. Per ovviare a questo Go mette a disposizione il passaggio per riferimento, che si ottiene specificando il puntatore alla struttura.

func (p *Persona) inverti() {
var nome, cognome string
nome = p.nome
cognome = p.cognome
p.cognome = nome
p.nome = cognome
}

func (p *Persona) inverti() {

var nome, cognome string

nome = p.nome

cognome = p.cognome

p.cognome = nome

p.nome = cognome

}

Con questo approccio invocando il metodo iniziali si avrà l’effetto desiderato. In assenza del puntatore non si avrebbe l’effetto atteso.

func main() {
var io = Persona{"Valerio", "Finazzo"}
io.iniziali()
io.inverti()
io.iniziali()
}

func main() {

var io = Persona{"Valerio", "Finazzo"}

io.iniziali()

io.inverti()

io.iniziali()

}

Go mette a disposizione anche il costrutto interfaccia, ovvero permette di definire una lista di metodi che le strutture devono implementare

//Familiare - commento
type Familiare interface {
iniziali()
}

//Familiare - commento

type Familiare interface {

iniziali()

}

In questo caso ho definito una interfaccia Familiare che prevede il metodo iniziali, pertanto posso invocare il metodo iniziali su una variabile che implementa l’interfaccia Familiare

var nuovoio Familiare = Persona{"Valerio", "Finazzo"}
nuovoio.iniziali()

1 2	var nuovoio Familiare = Persona{"Valerio", "Finazzo"} nuovoio.iniziali()

GOLANG

TUTORIAL GO – FUNCTIONS

10/08/2020 admin

Per definire una funzione Go mette a disposizione la parola chiave func seguita dal nome della funzione, l’elenco dei tipi attesi e l’elenco dei tipi restituiti, questo perchè in Go le funzioni possono restituire più valori in modo sequenziale,

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

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
}

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

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

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")
}

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

func fattoriale(valore int) int {

if valore == 0 {

return 1

} else {

return valore * fattoriale(valore-1)

}

GOLANG

TUTORIAL GO – ARRAY, SLICES e MAP

08/08/2020 admin

Cosa è un array ? E’ una sequenze definita di valori dello stesso tipo e prevede fin dall’inizio di stabilire quanti elementi contenga.

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 &lt; 3; i++ {
multi[i][0] = "0"
multi[i][1] = "X"
multi[i][2] = "0"
}
fmt.Println(multi)
fmt.Println(len(multi))
}

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 &lt; 5; i++ {
sl = append(sl, i)
fmt.Println(len(sl), cap(sl))
}

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

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

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

GOLANG

TUTORIAL GO – TIPI COMPLESSI STRUCTS E POINTER

07/08/2020 admin

Nell’articolo precedente abbiamo visto i tipi semplici messi a disposizione da GO, in questo vediamo come definire delle strutture dati più complesse. Go mette a disposizione il comando type che consente di definire delle strutture, ovvero collezioni di dati

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

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 = &amp;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)

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.

GOLANG

TUTORIAL GO – COSTRUTTI DI CONTROLLO

06/08/2020 admin

Oggi vediamo i costrutti di controllo offerti da GO. I costrutti consentono di configurare il flusso delle operazione sequenziali in base all’algoritmo stabilito dall’autore. Si dividono in iterativi e di selezione.

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 &lt; limite; i++ {
fmt.Println(i)
}
}

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 &lt; limite {
fmt.Println(j)
j = j + 1
}

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

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.

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

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")
}

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")
}

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 &lt; limite; i++ {
fmt.Println(i)
}
j := 0
for j &lt; 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")
}
}

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

fine

Sto per scrivere il penultimo messaggio

Fatto quello che c'era da fare

GOLANG

TUTORIAL GO – PACKAGE, TIPI, VARIABILI E COSTANTI

05/08/2020 admin

Messo in piedi l’IDE incominciamo a vedere come è strutturato il sorgente. Go è organizzato in package, quindi il primo comando definito all’interno del nostro file contiene la definizione del package tramite la direttiva package

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

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

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

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

1 2	// Costante - esempio const Costante = 10

www.valeriofinazzo.it

Archivi categoria: DOCUMENTAZIONE

TUTORIAL GO – GESTIONE DEI TIMER E DEI TICK

TUTORIAL GO – GESTIRE LA COMUNICAZIONE CON I CHANNEL

TUTORIAL GO – GOROUTINES E CHANNEL

TUTORIAL GO – GESTIONE DEGLI ERRORI

TUTORIAL GO – METODI E INTERFACCE

TUTORIAL GO – FUNCTIONS

TUTORIAL GO – ARRAY, SLICES e MAP

TUTORIAL GO – TIPI COMPLESSI STRUCTS E POINTER

TUTORIAL GO – COSTRUTTI DI CONTROLLO

TUTORIAL GO – PACKAGE, TIPI, VARIABILI E COSTANTI

Il sito dell'ingegnere Valerio Finazzo