TUTORIAL GO – ARRAY, SLICES e MAP | www.valeriofinazzo.it

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

Il sito dell'ingegnere Valerio Finazzo