En la lección anterior colamos una línea sin explicarla: readonly CIUDADES=(Valencia Sevilla Bilbao Madrid), recorrida luego con for ciudad in "${CIUDADES[@]}". Eso es un array, y es la estructura de datos que le faltaba a informe-diario.sh para dejar de leer el CSV una vez por ciudad. Bash tiene dos tipos: los indexados, listas ordenadas con índice numérico, y los asociativos, mapas de clave arbitraria a valor, que son la respuesta nativa a "cuántas incidencias tiene cada ciudad" sin salir del shell. Al terminar esta lección sabrás acumular contadores en una sola pasada y jubilar el sort | uniq -c del Módulo 2 cuando el resultado tenga que usarse dentro del script.

1. Crear arrays indexados
2. Acceder a elementos y a todo el array
3. "${arr[@]}" frente a "${arr[*]}"
4. Longitud, índices y recorrido
5. Añadir, rebanar y borrar
6. Arrays asociativos
7. El patrón contador
8. Poblar arrays: mapfile y IFS
9. Pasar arrays a funciones
10. Tabla de operaciones
11. Aplicación en informe-diario.sh

Hay tres formas, y todas producen lo mismo:

Puntos clave: los elementos van separados por espacios, no por comas ((a, b) crea los elementos a, y b); si un elemento contiene espacios hay que entrecomillarlo, ciudades=("San Sebastián" Valencia); los índices empiezan en 0 y son dispersos, de modo que el array anterior tiene 3 elementos con índices 0, 1 y 5 y no hay huecos vacíos en medio; y declare -a no es obligatorio, pero documenta la intención y hace falta si quieres el array vacío desde el principio. Una variable normal es, en realidad, el elemento 0 de un array: x=hola; echo "${x[0]}" imprime hola.

Las llaves son obligatorias. $ciudades[1] no accede al elemento 1: Bash expande $ciudades (elemento 0) y deja [1] como texto literal. Siempre ${ciudades[1]}.

El índice puede ser cualquier expresión aritmética: ${ciudades[i+1]} funciona, y dentro de los corchetes las variables no necesitan $.

Es exactamente la misma distinción que "$@" frente a "$*" de 03-05, y por la misma razón:

Regla sin excepciones: para recorrer o pasar arrays, "${arr[@]}" con comillas. "${arr[*]}" solo sirve para una cosa útil, unir los elementos en una cadena legible aprovechando IFS: IFS=', '; echo "Ciudades: ${ciudades[*]}"; unset IFS imprime Ciudades: Valencia, Sevilla, Bilbao, Madrid.

Cuidado con la asimetría: ${#arr[@]} cuenta elementos, pero ${#arr[i]} cuenta caracteres. Y ${!arr[@]} con ! delante devuelve las claves, no los valores; es la única forma segura de recorrer un array disperso:

Si hubieras hecho for (( i=0; i<${#repartidores[@]}; i++ )) recorrerías los índices 0 y 1, y el elemento 5 no aparecería nunca. Ese for estilo C solo es fiable en arrays sin huecos.

El borrado tiene una particularidad que sorprende a todo el mundo:

unset deja un hueco: el array pasa a ser disperso, y solo reconstruyéndolo vuelve a ser compacto. Las comillas en unset 'ciudades[1]' evitan que el globbing interprete los corchetes como una clase de caracteres si existe un fichero con ese nombre.

Disponibles desde Bash 4 (2009). Recuerda de 01-02 cómo comprobar tu versión, porque en macOS el /bin/bash del sistema sigue siendo la 3.2: (( BASH_VERSINFO[0] >= 4 )) || { echo "Se requiere Bash 4+" >&2; exit 5; }.

A diferencia de los indexados, declare -A es obligatorio: sin él, Bash trata las claves como expresiones aritméticas y todo acaba en el índice 0.

También se pueden crear de una vez: declare -A zona=([Valencia]=Levante [Sevilla]=Sur).

El orden de las claves es el de la tabla hash interna, no el de inserción ni alfabético. Si necesitas salida ordenada, ordena tú:

Para comprobar si una clave existe, sin confundirla con una que existe pero vale cadena vacía, se usa if [[ -v zona[Madrid] ]]; then .... [[ -v ]] (Bash 4.2+) pregunta por la existencia de la variable o elemento. La alternativa antigua, [[ -n "${zona[Madrid]}" ]], solo mira si el valor no está vacío, que no es lo mismo. Borrar una clave: unset 'zona[Madrid]'.

Este es el motivo principal por el que existen los arrays asociativos en un script de operaciones. La forma del Módulo 2 —grep ',incidencia,' "$RUTA_CSV" | cut -d, -f3 | sort | uniq -c— es bonita en la terminal pero inútil dentro del script: el resultado es texto, y para usar el número de Sevilla habría que volver a parsearlo. Con un mapa, los datos quedan en variables:

Salida: Valencia 128 envíos, 11 incidencias y una línea igual por cada ciudad. Tres detalles que hacen que esto funcione:

• (( mapa["$clave"]++ )) funciona aunque la clave no exista todavía: en contexto aritmético una variable sin valor cuenta como 0, así que el primer incremento la crea con valor 1. No hace falta inicializar nada.
• ${incidencias_por_ciudad[$ciudad]:-0} usa el valor por defecto de 03-06 para las ciudades sin incidencias, que no tienen entrada en ese mapa.
• Todo el conteo se hace en una sola pasada y sin procesos externos: sustituye a ocho invocaciones de grep. Para ficheros de millones de líneas, en cambio, el bucle de Bash es lento y conviene delegar en awk (06-01).

Para llenar un array con la salida de un comando, una línea por elemento, la herramienta correcta es mapfile (también llamada readarray, son sinónimos):

La opción -t elimina el salto de línea final de cada elemento; sin ella cada entrada arrastraría un \n y las comparaciones fallarían. Otras opciones útiles: -n N (leer como mucho N líneas) y -s N (saltar las N primeras, práctico para la cabecera de un CSV). Nunca uses arr=( $(comando) ) sin comillas para esto: divide por espacios y aplica globbing, así que un nombre con espacios o un * en la salida rompen el array.

Para trocear una cadena en array, se cambia IFS temporalmente y se usa read -a:

<<< es un here-string: alimenta la entrada estándar del comando con esa cadena (lo verás a fondo en 05-05). -a campos le dice a read que reparta los campos en el array en vez de en variables sueltas. Como el IFS= va delante del comando, solo afecta a esa línea.

Aquí hay una limitación real de Bash: no se puede pasar un array como un solo argumento. Todo lo que una función recibe son cadenas. Hay dos soluciones:

Simple y suficiente cuando el array es lo único que pasas. Si necesitas pasar además otros argumentos, ponlos primero y usa shift.

El nameref (local -n, introducido en 04-02) es imprescindible con arrays asociativos, porque "${mapa[@]}" perdería las claves por el camino. También es la forma de devolver un array: la función escribe en local -n salida="$2" y el llamante recibe el array completo.

Sustituimos el bucle que releía el CSV por ciudad por una sola pasada que acumula tres mapas:

Novedades: declare -gA, porque dentro de una función declare crea variables locales por defecto y -g las hace globales para que tabla_ciudades las vea (es la alternativa al nameref cuando los mapas son compartidos por todo el script); el bucle recorre "${CIUDADES[@]}" y no las claves del mapa, así la tabla sale siempre en el mismo orden y no en el arbitrario de la tabla hash; y una sola pasada sin ningún grep, con lo que el script pasa de lanzar 8 procesos a lanzar 1.

Queda pendiente lo evidente: ${importe%.*} tira los céntimos porque Bash no suma decimales. Esa expansión la explicaremos formalmente en la próxima lección, y los decimales llegarán en 04-06.

• Olvidar declare -A en un asociativo. Bash no avisa: convierte las claves en aritmética y todo acaba machacando el índice 0. Es el error número uno.
• Escribir ${arr[@]} sin comillas. Rompe con cualquier elemento que tenga espacios. Siempre "${arr[@]}".
• Usar $arr creyendo que es todo el array. Es solo el elemento 0.
• Esperar orden en las claves de un asociativo. No lo hay. Ordena explícitamente o recorre una lista fija.
• arr=( $(comando) ). Usa mapfile -t arr < <(comando).
• Contar con for (( i=0; i<${#a[@]}; i++ )) sobre un array con huecos. Recorre "${!a[@]}".
• Consejo: usa MAYÚSCULAS para los mapas globales compartidos del script y minúsculas para los arrays locales; distinguirlos de un vistazo evita colisiones.

Ejercicio 1. Crea un array con los tres repartidores, añade pcastro al final, muestra cuántos hay, recórrelo numerado (1) alopez) y muestra los dos últimos.

Ejercicio 2. Con un array asociativo, cuenta cuántos envíos tiene cada repartidor en envios.csv en una sola pasada, e imprime el resultado ordenado alfabéticamente por repartidor.

Ejercicio 3. Escribe campo_n() que reciba una línea CSV y un número de campo, y escriba ese campo en stdout usando un array. Debe funcionar así: campo_n "E1001,2026-08-03,Valencia,alopez,entregado,24.50" 3 → Valencia.

Solución 1.

${!repartidores[@]} da los índices; sumamos 1 solo para presentarlos empezando en 1.

Solución 2.

Salida: alopez 137, jruiz 98, mgarcia 121. El printf | sort es necesario porque el orden de las claves es impredecible.

Solución 3.

Fíjate en ${campos[n-1]}: dentro de los corchetes hay contexto aritmético, así que ni $ ni $(( )) hacen falta. El -1 traduce del índice humano (1) al de Bash (0).

Ya tienes memoria estructurada. Los arrays indexados guardan listas ordenadas —ciudades, repartidores, ficheros— y se recorren con for x in "${arr[@]}" o por índice con "${!arr[@]}"; los asociativos, declarados obligatoriamente con declare -A, guardan mapas de clave a valor y hacen posible el patrón contador que resume un CSV entero en una sola pasada, con los resultados en variables en lugar de en texto. mapfile -t los llena desde un comando, IFS=',' read -r -a los llena desde una cadena, y los namerefs los llevan y traen de las funciones.

En el camino han aparecido dos expansiones que hemos usado sin justificar: ${importe%.*} para quedarnos con la parte entera y ${var:-0} para el valor por defecto. Pertenecen a la misma familia de manipulación de cadenas que empezaste en 03-06 y que la próxima lección completa: cortar subcadenas, quitar prefijos y sufijos, sustituir texto, cambiar mayúsculas y formatear tablas con printf. Todo ello sin lanzar un solo proceso externo, que es la diferencia entre un script que tarda dos segundos y uno que tarda dos minutos.