Array

Un array è un tipo dati di lunghezza fissa contenente un blocco contiguo di elementi dello stesso tipo.

• L’accesso agli elementi è tramite un indice
• Gli elementi sono mutabili, ma la dimensione dell’array è fissa
• Gli elementi non inizializzati hanno il valore zero del loro tipo
• Gli array sono allocati sullo stack

nums := [6]int{10, 36, 4, 44}

Esempio:

(080arrays.go):

package main

import "fmt"

func main() {

	// Array: sequenza numerata di elementi di lunghezza data
	// lunghezza tra quadre
	// tipo attaccato a quadra chiusa
	// Creati nello stack
	var a [5]int
	// Stampa tutti gli elementi dell'array
	// Ogni elemento non assegnato vale zero
	fmt.Println("emp:", a)

	// Assegnazione valore ad un elemento tramite indice
	// Gli indici vanno da 0 a lunghezza
	a[4] = 100
	fmt.Println("set:", a)
	fmt.Println("get:", a[4])

	// Funzione di lunghezza dell'array
	fmt.Println("len:", len(a))

	// Assegnazione di valori alla dichiarazione
	// Si possono assegnare anche solo i primi valori
	b := [5]int{1, 2, 3}
	fmt.Println("dcl:", b)

	// Copia di un array
	// poichè è nello stack viene copiato per valore
	c := b
	// La copia è diversa dall'originale
	c[0] = 0
	fmt.Println("b: ", b)
	fmt.Println("c: ", c)

	// Creazione di un array vuoto
	// inutile perchè non estendibile
	var z[0]int
	fmt.Println("z: ", z)
	fmt.Println("len(z): ", len(z))

	// Array pluridimensionale
	var twoD [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d: ", twoD)
}

Osservazioni

Un array è dichiarato come: var a [5]int, uve a è una variabile array di 5 elementi di tipo intero.

Se gli elementi non sono esplicitamente inizializzati, vengono implicitamente assegnati allo zero del loro tipo.

Il riferimento ad un elemento dell'array è tramite un indice intero:

a[4] = 100

Come in tutti i linguaggi derivati dal C gli indici vanno da zero a uno meno della dimensione dell'array. L'accesso ad un elemento fuori dai confini dell'array (overflow) genera un errore di compilazione o una eccezione a runtime.

Stampare un array produce una lista dei suoi elementi tra parentesi quadre e separati da spazi.

La funzione len(a) ritorna la lunghezza dell'array a.

Un array può essere inizializzato all'atto della dichiarazione, come in

b := [5]int{1, 2, 3, 4, 5}

La parola var può essere omessa.

La dimensione si può omettere se sostituita con ...

a := [...]int{1, 2, 3}

Il tipo dell'array (qui: int) deve comunque essere indicato.
Non è necessario che il tipo segua immediatamente le quadre chiuse, si possono porre spazi.

Gli array possono avere più dimensioni, come in:

var twoD [2][3]int

Tutte le dimensioni sono dello stesso tipo.

In realtà il Go, come il C, registra internamente un unico array consecutivo, anche se controlla gli indici.
Cioè non è vero che si possa usare twoD[0][3] come equivalente di twoD[1][0].

Gli array, come in C, sono allocati nello stack.

Copia di un Array

Per valore, non per riferimento. Non esiste riferimento ad un array:

a := [...]string{"Alice", "Bob", "Charlie"}
b := a // una copia di a è assegnata a b
b[0] = "Tom"
fmt.Println("a is ", a)
fmt.Println("b is ", b)

produce l’output

a is [Alice Bob Charlie]
b is [Tom Bob Charlie]