Tutti gli articoli di admin

TUTORIAL GO – GESTIONE DEL DATABASE

06/09/2020 admin

Nell’articolo di oggi vedremo come integrare un database oracle e come effettuare le operazione di lettua e scrittura.

Prima di tutto introduciamo il package per la gestione del db database/sql e insieme al package dobbiamo importare il driver specifico per il database cui connettersi. L’elenco dei driver disponibili e le relative basi di dati supportati sono disponibili al link https://github.com/golang/go/wiki/SQLDrivers. Per lavoro uso Oracle, pertanto nell’esempio integro il driver godror. Per poter usare questo driver occorre installarlo e configurarlo nell’ambiente go tramite la direttiva:

go get github.com/godror/godror

1	go get github.com/godror/godror

Il driver è realizzato in cgo pertanto è richiesta la presenza di un gcc compiler, nel mio caso ho utilizzato quello disponibile all’indirizzo https://jmeubank.github.io/tdm-gcc/. Maggiori informazioni su godror sono disponibili al l’url https://github.com/godror/godror

Dopo aver installato gcc e godror possiamo finalmente definire l’import

import (
	"database/sql"
	"fmt"
	_ "github.com/godror/godror"
)

import (

"database/sql"

"fmt"

_ "github.com/godror/godror"

)

Per la connessione al db il comando da usare è Open del package db

	db, err := sql.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

db, err := sql.Open("godror", "ldc/ldc@localhost:1521/xe")

if err != nil {

panic(err)

}

Il primo parametro della Open è il nome del driver e a seguire la stringa di connessione verso il db nel formato username@password@ip:port:sid

La funzione restituisce una istanza db e come secondo parametro un oggetto error che potrà essere gestito tramite la funzione panic.

Vediamo subito come effettuare una operazione di scrittura tramite la funzione Exec

	tx, _ := db.Begin()
	rowsDeleted, err := db.Exec("delete from audit_obj where id=1")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsDeleted: ", rowsDeleted)

	rowsInserted, err := db.Exec("insert into audit_obj (id, dataora, operazione) values(1, sysdate, 'insert')")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsInserted: ", rowsInserted)
	tx.Commit()

tx, _ := db.Begin()

rowsDeleted, err := db.Exec("delete from audit_obj where id=1")

if err != nil {

panic(err)

}

fmt.Println("rowsDeleted: ", rowsDeleted)

rowsInserted, err := db.Exec("insert into audit_obj (id, dataora, operazione) values(1, sysdate, 'insert')")

if err != nil {

panic(err)

}

fmt.Println("rowsInserted: ", rowsInserted)

tx.Commit()

Nell’esempio tramite la funzione Begin ho avviato una transazione con commit previsto a fine operazioni di scrittura. Nel caso specifico sto facendo la cancellazione di un record dalla tabella di audit e successivo inserimento La funzione Exec ritorna un oggetto Result che rappresenta l’esito di una qualsiasi chiamata al db mostrando quante righe sono state coinvolte e l’id dell’ultimo inserimento.

Se volessi leggere i dati mi viene in aiuto la funzione Query che restituisce un cursore che scorre sulle righe selezionate

	rows, err := db.Query("select id, dataora, operazione  from audit_obj")
	if err != nil {
		panic(err)
	}
	defer rows.Close()

	var id int
	var dataora time.Time
	var operazione string
	for rows.Next() {
		rows.Scan(&amp;id, &amp;dataora, &amp;operazione)
		fmt.Println(id, dataora, operazione)
	}
	db.Close()

rows, err := db.Query("select id, dataora, operazione from audit_obj")

if err != nil {

panic(err)

}

defer rows.Close()

var id int

var dataora time.Time

var operazione string

for rows.Next() {

rows.Scan(&id, &dataora, &operazione)

fmt.Println(id, dataora, operazione)

}

db.Close()

Nell’esempio sto leggenda dalla tabella audit tutti i record e tramite la funzione Scan dell’oggetto Rows la assegna a delle variabili per stamparne successivamente il valore. Con il comando defer chiudo il cursore alla fine di tutte le operazioni.

Per semplificare il lavoro con il db ci vengono in soccorso altri package che consentono di velocizzare il lavoro. Oggi introduco il package sqlx disponibile all’url https://jmoiron.github.io/sqlx/

Per installarlo il comando è

go get github.com/jmoiron/sqlx

1	go get github.com/jmoiron/sqlx

ad installazione effettuata può essere importato con la direttiva github.com/jmoiron/sqlx”. Questo package consente di mappare le query direttamente su struct senza dover ricorrere al comando Scan.

type Audit struct {
	ID      uint64    `db:"ID"`
	DATAORA time.Time `db:"DATAORA"`
}

type Audit struct {

ID uint64 `db:"ID"`

DATAORA time.Time `db:"DATAORA"`

}

Ho definito una struct Audit che presenta i parametri ID e dataora, ne ho definito il tipo e tramite il thick ho definito il mapping, tramite la regola del contesto:nomecolonna.

A questo punto ottengo il gioco è fatto

	dbx, err := sqlx.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

	var audit Audit
	err = dbx.Get(&amp;audit, "select id, dataora from audit_obj where id = 1")
	if err != nil {
		panic(err)
	}
	fmt.Println(audit)

	audits := []Audit{}
	dbx.Select(&amp;audits, "select id, dataora  from audit_obj")
	if err != nil {
		panic(err)
	}
	fmt.Println(audits)

dbx, err := sqlx.Open("godror", "ldc/ldc@localhost:1521/xe")

if err != nil {

panic(err)

}

var audit Audit

err = dbx.Get(&audit, "select id, dataora from audit_obj where id = 1")

if err != nil {

panic(err)

}

fmt.Println(audit)

audits := []Audit{}

dbx.Select(&audits, "select id, dataora from audit_obj")

if err != nil {

panic(err)

}

fmt.Println(audits)

Con la Open ottengo un riferimento al db che mi espone le funzioni Get per il recupero del singolo oggetto e Select per il recupero di un set di righe,

Alla prossima

ps. per i pigri a seguire l’intero codice

package main

import (
	"database/sql"
	"fmt"
	"time"

	_ "github.com/godror/godror"
	"github.com/jmoiron/sqlx"
)

type Audit struct {
	ID      uint64    `db:"ID"`
	DATAORA time.Time `db:"DATAORA"`
}

func main() {

	fmt.Println("Start")

	db, err := sql.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

	tx, _ := db.Begin()
	result, err := db.Exec("delete from audit_obj where id=1")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsDeleted: ", result)

	result, err = db.Exec("insert into audit_obj (id, dataora, operazione) values(1, sysdate, 'insert')")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsInserted: ", result)
	tx.Commit()

	rows, err := db.Query("select id, dataora, operazione  from audit_obj")
	if err != nil {
		panic(err)
	}
	defer rows.Close()

	var id int
	var dataora time.Time
	var operazione string
	for rows.Next() {
		rows.Scan(&amp;id, &amp;dataora, &amp;operazione)
		fmt.Println(id, dataora, operazione)
	}
	db.Close()

	dbx, err := sqlx.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

	var audit Audit
	err = dbx.Get(&amp;audit, "select id, dataora from audit_obj where id = 1")
	if err != nil {
		panic(err)
	}
	fmt.Println(audit)

	audits := []Audit{}
	dbx.Select(&amp;audits, "select id, dataora  from audit_obj")
	if err != nil {
		panic(err)
	}
	fmt.Println(audits)

	dbx.Close()
	fmt.Println("End")

}

package main

import (

"database/sql"

"fmt"

"time"

_ "github.com/godror/godror"

"github.com/jmoiron/sqlx"

)

type Audit struct {

ID uint64 `db:"ID"`

DATAORA time.Time `db:"DATAORA"`

}

func main() {

fmt.Println("Start")

db, err := sql.Open("godror", "ldc/ldc@localhost:1521/xe")

if err != nil {

panic(err)

}

tx, _ := db.Begin()

result, err := db.Exec("delete from audit_obj where id=1")

if err != nil {

panic(err)

}

fmt.Println("rowsDeleted: ", result)

result, err = db.Exec("insert into audit_obj (id, dataora, operazione) values(1, sysdate, 'insert')")

if err != nil {

panic(err)

}

fmt.Println("rowsInserted: ", result)

tx.Commit()

rows, err := db.Query("select id, dataora, operazione from audit_obj")

if err != nil {

panic(err)

}

defer rows.Close()

var id int

var dataora time.Time

var operazione string

for rows.Next() {

rows.Scan(&id, &dataora, &operazione)

fmt.Println(id, dataora, operazione)

}

db.Close()

dbx, err := sqlx.Open("godror", "ldc/ldc@localhost:1521/xe")

if err != nil {

panic(err)

}

var audit Audit

err = dbx.Get(&audit, "select id, dataora from audit_obj where id = 1")

if err != nil {

panic(err)

}

fmt.Println(audit)

audits := []Audit{}

dbx.Select(&audits, "select id, dataora from audit_obj")

if err != nil {

panic(err)

}

fmt.Println(audits)

dbx.Close()

fmt.Println("End")

}

GOLANG

TUTORIAL GO – LETTURA E SCRITTURA DEI FILE

29/08/2020 admin

Dopo aver visto le caratteristiche di Go cominciamo a vedere alcuni casi d’uso tipici dello sviluppo. Iniziamo con la lettura e la scrittura dei file.

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

}

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.

GOLANG

TUTORIAL GO – GESTIONE DEI TIMER E DEI TICK

20/08/2020 admin

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.

www.valeriofinazzo.it

Tutti gli articoli di admin

TUTORIAL GO – GESTIONE DEL DATABASE

TUTORIAL GO – LETTURA E SCRITTURA DEI FILE

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

Il sito dell'ingegnere Valerio Finazzo