Array

L'array è una struttura dati fondamentale - sebbene non l'unica - per il linugaggio di programmazione Go. Si basa su sequenze di dimensione fissa per la custodia e gestione
di elementi omogenei ovvero dello stesso tipo.

L'operatore sintattico di fondo è costituito dalle parentesi quadre, indispensabili sia in fase di dichiarazione di un array (per indicare il numero di elementi
che lo compongono) sia per la scrittura e lettura dei vari elementi. Per la dichiarazione di un array va specificato: il riferimento con cui verrà riconosciuto, il numero di elementi che lo compongono (passato
tra parentesi quadre come detto) e la loro tipologia:

var nomi[10] string

Questa è, ad esempio, una dichiarazione che permetterà di avere un massimo di dieci stringhe contenute in un array denominato nomi. Aggiungiamovi i primi elementi:

nomi[0] = "Paolo"
nomi[1] = "Claudia"
nomi[2] = "Silvia"

In un array, ogni elemento viene indicizzato per posizione e tali posizioni vengono conteggiate a partire da zero. In questo caso, abbiamo assegnato la stringa "Paolo" alla cella numero 0 dell'array nomi, "Claudia" alla
1 e "Silvia" alla 2. In virtù di tale modo di annoverare le posizioni, in un array di dieci elementi l'ultimo indice utilizzabile sarà il 9. Qualora provassimo a compiere la seguente assegnazione (volutamente erronea):

nomi[10] = "Vanessa"

otterremmo il messaggio di errore "invalid array index 10 (out of bounds for 10-element array)" che specificherebbe proprio che abbiamo tentato di fare accesso ad un array di dieci posizioni al di fuori dei suoi limiti.

Anche l'accesso in lettura ad un array avviene mediante parentesi quadre. Ad esempio, possiamo leggere il contenuto della posizione numero due (la terza contando a partire da zero) in questo modo:

fmt.Println(nomi[2])

In output otterremmo la stringa "Silvia" stampata ad opera di Println, funzione del modulo fmt già incontrata nelle lezioni precedenti. Per ottenere la lunghezza totale di un array si può utilizzare la funzione
len che, invocata sul nostro array con len(nomi), restituirebbe il valore 10 sebbene l'array non fosse totalmente pieno.

Inizializzare array

A volte gli array possono essere inizializzati con sequenze di elementi. Supponiamo di voler creare l'array nomi dinamicamente con un complessivo di 10 posizioni ma solo con le prime
cinque inizializzate a determinati valori. Procediamo così:

var nomi= [10]string{"Paola", "Jennifer", "Noemi", "Sandro", "Simone"}
fmt.Println(nomi)
fmt.Println(len(nomi))

Dopo questa istruzione avremo l'array nomi di lunghezza dieci ma solo le prime cinque celle saranno state valorizzate tanto che l'output ottenuto su console sarà il seguente:

[Paola Jennifer Noemi Sandro Simone     ]
10

Array multidimensionali

Gli array visti sinora sono costituiti da una singola sequenza di elementi ma in generale una struttura di questo genere può vedere i suoi elementi disposti su più livelli dando vita a matrici o strutture di più di due dimensioni. Facciamo un esempio dove
andiamo a costituire un array multidimensionale innestando, uno nell'altro, tre cicli for:

package main
import "fmt"
func main() {
    var multi[3][3][3]string
    for x := 0; x < 3; x++ {
       for y := 0; y < 3; y++ {
           for z := 0; z < 3; z++ {
               multi[x][y][z] = fmt.Sprintf("(%d,%d,%d)", x, y, z)
           }
       }
    }
    fmt.Println(multi[0])
    fmt.Println(multi[0][1])
    fmt.Println(multi[0][1][2])
}

Il codice costituisce un programma completo all'interno del file array.go e potrà essere avviato all'esecuzione con:

$ go run array.go

Ad ogni iterazione, i valori correnti di x, y e z vengono concatenati in un'unica stringa (l'array viene infatti dichiarato di tipo string) con fmt.Sprintf("(%d,%d,%d)", x, y, z).
Mediante le istruzioni utilizzate, alla fine, avremo la possibilità di verificare il contenuto di porzioni diverse dell'array. L'output di fmt.Println(multi[0]) restituirà un'intera sezione della struttura:

[[(0,0,0) (0,0,1) (0,0,2)] [(0,1,0) (0,1,1) (0,1,2)] [(0,2,0) (0,2,1) (0,2,2)]]

La direttiva fmt.Println(multi[0][1]) fornirà:

[(0,1,0) (0,1,1) (0,1,2)]

ed infine fmt.Println(multi[0][1][2]) emetterà:

(0,1,2)

Il formato stesso dell'output utilizzato dal linguaggio Go sarà particolarmente utile per poter osservare la dimensione e la struttura di ogni elemento. La prima porzione emessa è costituita da un unico array che continene a
sua volta tre array di tre stringhe ognuno (ogni stringa è delimitata dalle parentesi tonde). Anche il secondo è un array ma questa volta è composto da tre stringhe e non ha alcun array annidato al suo interno. Infine, l'elemento che
è stato individuato fornendo tre coordinate, multi[0][1][2], ha restituito una singola stringa.