A la lliçó anterior vam colar una línia sense explicar-la: readonly CIUTATS=(Valencia Sevilla Bilbao Madrid), recorreguda després amb for ciutat in "${CIUTATS[@]}". Això és un array, i és l'estructura de dades que li faltava a informe-diari.sh per deixar de llegir el CSV una vegada per ciutat. Bash en té dos tipus: els indexats, llistes ordenades amb índex numèric, i els associatius, mapes de clau arbitrària a valor, que són la resposta nativa a «quantes incidències té cada ciutat» sense sortir del shell. En acabar aquesta lliçó sabràs acumular comptadors en una sola passada i jubilar el sort | uniq -c del Mòdul 2 quan el resultat s'hagi de fer servir dins de l'script.

1. Crear arrays indexats
2. Accedir als elements i a tot l'array
3. "${arr[@]}" davant de "${arr[*]}"
4. Longitud, índexs i recorregut
5. Afegir, llescar i esborrar
6. Arrays associatius
7. El patró comptador
8. Poblar arrays: mapfile i IFS
9. Passar arrays a funcions
10. Taula d'operacions
11. Aplicació a informe-diari.sh

Hi ha tres maneres, i totes produeixen el mateix:

Punts clau: els elements van separats per espais, no per comes ((a, b) crea els elements a, i b); si un element conté espais cal posar-lo entre cometes, ciutats=("Sant Sebastià" Valencia); els índexs comencen a 0 i són dispersos, de manera que l'array anterior té 3 elements amb índexs 0, 1 i 5 i no hi ha forats buits pel mig; i declare -a no és obligatori, però documenta la intenció i cal si vols l'array buit des del principi. Una variable normal és, en realitat, l'element 0 d'un array: x=hola; echo "${x[0]}" imprimeix hola.

Les claus són obligatòries. $ciutats[1] no accedeix a l'element 1: Bash expandeix $ciutats (element 0) i deixa [1] com a text literal. Sempre ${ciutats[1]}.

L'índex pot ser qualsevol expressió aritmètica: ${ciutats[i+1]} funciona, i dins dels claudàtors les variables no necessiten $.

És exactament la mateixa distinció que "$@" davant de "$*" de 03-05, i per la mateixa raó:

Regla sense excepcions: per recórrer o passar arrays, "${arr[@]}" amb cometes. "${arr[*]}" només serveix per a una cosa útil, unir els elements en una cadena llegible aprofitant IFS: IFS=', '; echo "Ciutats: ${ciutats[*]}"; unset IFS imprimeix Ciutats: Valencia, Sevilla, Bilbao, Madrid.

Compte amb l'asimetria: ${#arr[@]} compta elements, però ${#arr[i]} compta caràcters. I ${!arr[@]} amb ! al davant retorna les claus, no els valors; és l'única manera segura de recórrer un array dispers:

Si haguessis fet for (( i=0; i<${#repartidors[@]}; i++ )) recorreries els índexs 0 i 1, i l'element 5 no apareixeria mai. Aquest for a l'estil C només és fiable en arrays sense forats.

L'esborrat té una particularitat que sorprèn tothom:

unset deixa un forat: l'array passa a ser dispers, i només reconstruint-lo torna a ser compacte. Les cometes a unset 'ciutats[1]' eviten que l'expansió de comodins interpreti els claudàtors com una classe de caràcters si existeix un fitxer amb aquell nom.

Disponibles des de Bash 4 (2009). Recorda de 01-02 com comprovar la teva versió, perquè a macOS el /bin/bash del sistema continua sent el 3.2: (( BASH_VERSINFO[0] >= 4 )) || { echo "Cal Bash 4+" >&2; exit 5; }.

A diferència dels indexats, declare -A és obligatori: sense ell, Bash tracta les claus com a expressions aritmètiques i tot acaba a l'índex 0.

També es poden crear d'un cop: declare -A zona=([Valencia]=Llevant [Sevilla]=Sud).

L'ordre de les claus és el de la taula hash interna, no el d'inserció ni l'alfabètic. Si necessites sortida ordenada, ordena-la tu:

Per comprovar si una clau existeix, sense confondre-la amb una que existeix però val cadena buida, es fa servir if [[ -v zona[Madrid] ]]; then .... [[ -v ]] (Bash 4.2+) pregunta per l'existència de la variable o element. L'alternativa antiga, [[ -n "${zona[Madrid]}" ]], només mira si el valor no és buit, que no és el mateix. Esborrar una clau: unset 'zona[Madrid]'.

Aquest és el motiu principal pel qual existeixen els arrays associatius en un script d'operacions. La forma del Mòdul 2 —grep ',incidencia,' "$CAMI_CSV" | cut -d, -f3 | sort | uniq -c— és bonica al terminal però inútil dins de l'script: el resultat és text, i per fer servir el número de Sevilla caldria tornar a analitzar-lo. Amb un mapa, les dades queden en variables:

Sortida: Valencia 128 enviaments, 11 incidències i una línia igual per cada ciutat. Tres detalls que fan que això funcioni:

• (( mapa["$clau"]++ )) funciona encara que la clau no existeixi: en context aritmètic una variable sense valor compta com a 0, així que el primer increment la crea amb valor 1. No cal inicialitzar res.
• ${incidencies_per_ciutat[$ciutat]:-0} fa servir el valor per defecte de 03-06 per a les ciutats sense incidències, que no tenen entrada en aquell mapa.
• Tot el recompte es fa en una sola passada i sense processos externs: substitueix vuit invocacions de grep. Per a fitxers de milions de línies, en canvi, el bucle de Bash és lent i val més delegar en awk (06-01).

Per omplir un array amb la sortida d'una ordre, una línia per element, l'eina correcta és mapfile (també anomenada readarray, són sinònims):

L'opció -t elimina el salt de línia final de cada element; sense ella cada entrada arrossegaria un \n i les comparacions fallarien. Altres opcions útils: -n N (llegir com a màxim N línies) i -s N (saltar-se les N primeres, pràctic per a la capçalera d'un CSV). No facis servir mai arr=( $(ordre) ) sense cometes per a això: divideix per espais i aplica expansió de comodins, així que un nom amb espais o un * a la sortida trenquen l'array.

Per trossejar una cadena en array, es canvia IFS temporalment i es fa servir read -a:

<<< és un here-string: alimenta l'entrada estàndard de l'ordre amb aquella cadena (ho veuràs a fons a 05-05). -a camps diu a read que reparteixi els camps a l'array en comptes de a variables soltes. Com que l'IFS= va davant de l'ordre, només afecta aquella línia.

Aquí hi ha una limitació real de Bash: no es pot passar un array com un sol argument. Tot el que una funció rep són cadenes. Hi ha dues solucions:

Simple i suficient quan l'array és l'única cosa que passes. Si a més necessites passar altres arguments, posa'ls primer i fes servir shift.

El nameref (local -n, introduït a 04-02) és imprescindible amb arrays associatius, perquè "${mapa[@]}" perdria les claus pel camí. També és la manera de retornar un array: la funció escriu a local -n sortida="$2" i qui la crida rep l'array complet.

Substituïm el bucle que rellegia el CSV per ciutat per una sola passada que acumula tres mapes:

Novetats: declare -gA, perquè dins d'una funció declare crea variables locals per defecte i -g les fa globals perquè taula_ciutats les vegi (és l'alternativa al nameref quan els mapes són compartits per tot l'script); el bucle recorre "${CIUTATS[@]}" i no les claus del mapa, així la taula surt sempre en el mateix ordre i no en l'arbitrari de la taula hash; i una sola passada sense cap grep, amb la qual cosa l'script passa de llançar 8 processos a llançar-ne 1.

Queda pendent el que és evident: ${import%.*} llença els cèntims perquè Bash no suma decimals. Aquesta expansió l'explicarem formalment a la lliçó següent, i els decimals arribaran a 04-06.

• Descuidar el declare -A en un associatiu. Bash no avisa: converteix les claus en aritmètica i tot acaba masegant l'índex 0. És l'error número u.
• Escriure ${arr[@]} sense cometes. Es trenca amb qualsevol element que tingui espais. Sempre "${arr[@]}".
• Fer servir $arr creient que és tot l'array. És només l'element 0.
• Esperar ordre a les claus d'un associatiu. No n'hi ha. Ordena-les explícitament o recorre una llista fixa.
• arr=( $(ordre) ). Fes servir mapfile -t arr < <(ordre).
• Comptar amb for (( i=0; i<${#a[@]}; i++ )) sobre un array amb forats. Recorre "${!a[@]}".
• Consell: fes servir MAJÚSCULES per als mapes globals compartits de l'script i minúscules per als arrays locals; distingir-los d'un cop d'ull evita col·lisions.

Exercici 1. Crea un array amb els tres repartidors, afegeix-hi pcastro al final, mostra quants n'hi ha, recorre'l numerat (1) alopez) i mostra els dos últims.

Exercici 2. Amb un array associatiu, compta quants enviaments té cada repartidor a enviaments.csv en una sola passada, i imprimeix el resultat ordenat alfabèticament per repartidor.

Exercici 3. Escriu camp_n() que rebi una línia CSV i un número de camp, i escrigui aquell camp a stdout fent servir un array. Ha de funcionar així: camp_n "E1001,2026-08-03,Valencia,alopez,lliurat,24.50" 3 → Valencia.

Solució 1.

${!repartidors[@]} dona els índexs; hi sumem 1 només per presentar-los començant per 1.

Solució 2.

Sortida: alopez 137, jruiz 98, mgarcia 121. El printf | sort és necessari perquè l'ordre de les claus és impredictible.

Solució 3.

Fixa't en ${camps[n-1]}: dins dels claudàtors hi ha context aritmètic, així que no calen ni $ ni $(( )). El -1 tradueix de l'índex humà (1) al de Bash (0).

Ja tens memòria estructurada. Els arrays indexats guarden llistes ordenades —ciutats, repartidors, fitxers— i es recorren amb for x in "${arr[@]}" o per índex amb "${!arr[@]}"; els associatius, declarats obligatòriament amb declare -A, guarden mapes de clau a valor i fan possible el patró comptador que resumeix un CSV sencer en una sola passada, amb els resultats en variables en comptes de en text. mapfile -t els omple des d'una ordre, IFS=',' read -r -a els omple des d'una cadena, i els namerefs els porten i els duen de les funcions.

Pel camí han aparegut dues expansions que hem fet servir sense justificar: ${import%.*} per quedar-nos amb la part entera i ${var:-0} per al valor per defecte. Pertanyen a la mateixa família de manipulació de cadenes que vas començar a 03-06 i que la lliçó següent completa: tallar subcadenes, treure prefixos i sufixos, substituir text, canviar majúscules i formatar taules amb printf. Tot això sense llançar ni un sol procés extern, que és la diferència entre un script que triga dos segons i un que triga dos minuts.