Array in

Informazioni su Array

Bash fornisce due tipi di parametri: i valori «scalari» e gli array. Un valore scalare può essere una stringa o un numero: rappresenta una sola «cosa».

Il più delle volte, i valori scalari bastano a contenere i dati. Ma a volte devi memorizzare un elenco di valori scalari. In questo caso userai un array.

Esistono due tipi di array:

• Gli array indicizzati numericamente associano una chiave intera a un valore stringa. (In altri linguaggi questo potrebbe chiamarsi «list» o «sequence».)
• Gli array associativi associano una chiave stringa a un valore stringa. (In altri linguaggi questo potrebbe chiamarsi «map» o «dictionary».)

Le prime sezioni di questo documento trattano gli array indicizzati numericamente (da qui in poi chiamati semplicemente «array»). I dettagli sugli array associativi arriveranno alla fine.

Dichiarare e inizializzare una variabile di tipo array

Puoi inizializzare un array assegnando a una variabile un elenco di elementi tra parentesi (eventualmente vuoto).

myarray=("one" "two" "three")

Come per qualsiasi assegnazione di variabile, non ci devono essere spazi intorno al segno di uguale.

Nota che non ci sono virgole a separare gli elementi: è un elenco di stringhe separate da spazi bianchi.

In realtà, la quantità di spazi bianchi all'interno delle parentesi è del tutto arbitraria. Sono ammessi anche i ritorni a capo: usane quanti vuoi per rendere il codice più leggibile.

myarray=(
    "first element"
    "second element"
    "this is the last element"
)

Assegnare un elenco di stringhe a una variabile di tipo array in questo modo memorizza la prima stringa all'indice zero, la successiva all'indice uno, quella dopo all'indice due, e così via.

È possibile inizializzare un «array sparso» specificando gli indici che servono.

raindrops=([3]="Pling" [5]="Plang" [7]="Plong")

myarray=("one" "two" "three")
[[ "${myarray[0]}" == "one" ]] && echo true || echo false

Puoi usare il comando declare (o local all'interno di una funzione) per specificare che una variabile conterrà un array.

declare -a myarray

È più idiomatico limitarsi ad assegnare un elenco tra parentesi (magari vuoto) per inizializzare la variabile.

Accedere agli elementi di un array

Come hai visto nella nota qui sopra, la sintassi per accedere a un elemento di un array è ${myarray[$index]}. L'indice è indicato tra parentesi quadre. Le parentesi graffe sono obbligatorie.

i=5
echo "${myarray[i]}"
# ..............^

Se l'indice indicato non esiste nell'array, il risultato dell'espansione è una stringa vuota.

Assegnare a un array

Per assegnare un valore a una voce specifica dell'array, usa questa sintassi:

myarray[10]="hello"

Per aggiungere in coda a un array, usa l'operatore di assegnazione concatenante += e le parentesi:

myarray+=("new element 1" "new element 2")

Iterare su un array

Di solito avrai bisogno di iterare sui valori di un array. Usa un ciclo for (quello che hai visto nel concetto Cicli):

myarray=("one" "two" "three")
for value in "${myarray[@]}"; do
    echo "$value"
done

Nota la sintassi speciale per espandere l'array: "${myarray[@]}" Questa forma di espansione dei parametri sostituisce i valori dell'array come parole separate. È più o meno equivalente a:

for value in "${myarray[0]}" "${myarray[1]}" ... "${myarray[n]}"

La forma "${myarray[@]}" funziona con gli array sparsi: si espande solo ai valori definiti.

Questa espansione speciale, in cui l'indice è una chiocciola (@), è speciale solo all'interno delle virgolette doppie.

Altre espansioni speciali dei parametri

Ecco un altro paio di sintassi speciali che ci servono per iterare su un array. Sono descritte nel manuale alla voce Shell Parameter Expansion.

Per trovare la lunghezza di un array, usa ${#myarray[@]}, con un # prima del nome. La «lunghezza» di un array è il numero di elementi che contiene.

Per estrarre l'elenco degli indici di un array, usa "${!myarray[@]}", con un ! prima del nome e l'espansione tra virgolette doppie. Per gli array indicizzati numericamente, gli indici vengono espansi in ordine numerico.

Iterare sugli indici di un array

A volte hai bisogno anche dell'indice, oltre al valore. Ci sono un paio di modi per farlo.

1. Quando sai che gli indici formano una sequenza ininterrotta, puoi usare un ciclo for aritmetico.

   for ((i = 0; i < ${#myarray[@]}; i++)); do
       echo "$i -> ${myarray[i]}"
   done
   

   Nota la sintassi ${#myarray[@]}, con il carattere # davanti al nome dell'array. Dato che gli array usano indici che partono da zero, l'ultimo indice dell'array è la lunghezza dell'array meno uno.

2. Quando l'array è sparso, puoi usare questa forma:

   for index in "${!raindrops[@]}"; do
       echo "$index -> ${raindrops[index]}"
   done
   

   Nota la sintassi ${!myarray[@]}, con il carattere ! davanti al nome dell'array.

Ispezionare un array

Se vuoi dare un'occhiata al contenuto di un array, usa il comando declare con l'opzione -p:

a=("the 'first' element"
   second
   third
   'the "last" element')
declare -p a

Questo stampa il contenuto con la forma canonica di quoting della shell.

declare -a a=([0]="the 'first' element" [1]="second" [2]="third" [3]="the \"last\" element")

Array associativi

Per ripetere, gli array associativi usano stringhe come indici, non numeri. Tutto quello scritto sopra vale anche per gli array associativi, ma con qualche piccola differenza. In genere si parla di «chiave» e non di «indice»: gli array associativi associano chiavi a valori.

Dichiarare un array associativo

A differenza degli array, gli array associativi devono essere dichiarati. Usa l'opzione -A di declare (o di local all'interno di una funzione):

declare -A mymap

myfunc() {
    local -A my_local_map
    # ...
}

Inizializzare un array associativo

Le coppie chiave-valore sono specificate all'interno dell'elenco tra parentesi:

mymap=([first]=foo [second]=bar [third]=baz)
declare -p mymap

Questo stampa:

declare -A mymap=([second]="bar" [first]="foo" [third]="baz")

La dichiarazione e l'inizializzazione possono avvenire su una sola riga.

declare -A mymap=([first]=foo [second]=bar [third]=baz)

Nelle versioni recenti di Bash, l'inizializzazione può usare un elenco (key value key value ...).

declare -A mymap=(first foo second bar third baz)

Accedere ai valori

Per accedere agli elementi si usa la stessa sintassi di prima: ${mymap[$key]}.

Le chiavi degli array associativi non vengono valutate in un contesto aritmetico. Serve la solita sintassi di espansione dei parametri.

Assegnare a un array associativo

L'assegnazione usa la stessa sintassi di prima:

mymap[$key]="$value"

Iterare

Puoi usare un ciclo for value in "${mymap[@]}" per iterare. Tuttavia, di solito vuoi avere anche la chiave insieme al valore.

Usa la sintassi "${!mymap[@]}" che abbiamo visto sopra.

for key in "${!mymap[@]}"; do
    echo "$key -> ${mymap[$key]}"
done

Questo stampa

second -> bar
first -> foo
third -> baz

Per ribadire, le chiavi non hanno alcun ordine.