revision_salud.sh ya existe, pero lleva el umbral de disco escrito a mano en el cuerpo y la IP del servidor justo encima. El día que Marta pida vigilar también el servidor de pruebas tendrás que duplicar el fichero, y a partir de ahí tendrás dos scripts que se separan poco a poco hasta que uno de los dos miente. La cura es sacar los valores del cuerpo y meterlos en variables bien pensadas.

Esta lección va de eso, pero sobre todo va de algo más profundo: en Bash todo es una cadena de texto, y esa única frase explica el 90 % de las sorpresas que te vas a llevar. A cambio, Bash te da un arsenal de manipulación de cadenas —la expansión de parámetros— tan potente que sustituye a basename, dirname, cut, tr y buena parte de sed sin lanzar un solo proceso.

1. Bash no tiene tipos: todo es cadena
2. Asignación: las tres reglas que rompen a todo el mundo
3. Ámbito: script, subshell y entorno
4. declare y sus atributos
5. Expansión de parámetros a fondo
6. Aritmética, y por qué Bash no sabe de decimales
7. Arrays indexados
8. Arrays asociativos: reservas por casa
9. Cadenas y printf
10. Aplicación: revision_salud.sh configurable

En Python o Java declaras el tipo y el lenguaje te protege. En Bash no hay tipos: toda variable guarda una cadena de bytes, y el «tipo» aparece solo al usarla, según el contexto.

La misma variable es un número dentro de $(( )) y texto fuera. Nadie te avisó al asignar 42abc; el error llegó al intentar sumar. Tres consecuencias que conviene interiorizar hoy:

• Nada valida lo que guardas. Validar es tu trabajo, y lo formalizaremos en 04-04 con [[ $v =~ ^[0-9]+$ ]].
• Comparar números y comparar cadenas son operaciones distintas. "10" < "9" es cierto como texto y falso como número; de ahí que existan -lt y < por separado.
• No hay decimales. $(( 7842 / 25 )) da 313, no 313.70 (apartado 6). Las únicas excepciones parciales a la regla son los atributos de declare y los arrays, que sí son una estructura de datos de verdad.

• Sin espacios alrededor del =. version = 3.2.1 no es una asignación: Bash lo lee como el comando version con los argumentos = y 3.2.1. Es la regla más quebrantada por quien viene de otros lenguajes, y el mensaje de error no ayuda nada.
• Comillas si hay espacios. Sin ellas la asignación termina en el primer espacio. Regla operativa: entrecomilla siempre el valor, tenga espacios o no.
• Al usarla, $; al asignarla, no. nombre=valor para escribir, "$nombre" para leer.

Las dos últimas líneas del ejemplo muestran otra cosa: anteponer una variable a un comando la hace existir solo durante esa ejecución, que es exactamente lo que hace la convención LC_ALL=C del curso. Sobre los nombres: letras, dígitos y _, sin empezar por dígito; MAYÚSCULAS para constantes y entorno, minúsculas para las de trabajo. Y evita pisar PATH, HOME, IFS, PWD, RANDOM o SECONDS, que tienen dueño.

Retomando 03-01, ahora desde dentro de un script:

Tres lecciones en seis líneas. El hijo no ve CASA porque no está exportada, pero sí RELEASE. El subshell —los paréntesis— sí ve todo lo del padre porque es una copia de él, pero sus cambios no vuelven: el mismo muro que encontraste con cd, y el que hará que un while read dentro de una tubería pierda sus variables (04-03). En cuanto a local, solo puede usarse dentro de una función y es un adelanto de 04-05, pero la regla es tan importante que la enunciamos ya: toda variable creada dentro de una función debe ser local; sin él es global, y una función puede pisar silenciosamente el contador de otra.

declare (o su sinónimo typeset) crea variables con atributos, lo más parecido a un tipo que tiene Bash.

Fíjate en errores+=14: con el atributo -i suma, mientras que sin él concatenaría y dejaría 014. Ese comportamiento distinto según un atributo invisible es la razón por la que muchos prefieren la aritmética explícita con $(( )); usaremos -i solo para contadores evidentes. readonly sí lo usaremos mucho: convierte un error lógico —reasignar una constante por accidente— en un error inmediato y ruidoso, siempre mejor que uno silencioso.

Aquí Bash deja de parecer un lenguaje de juguete. Todo lo que sigue ocurre dentro del shell, sin lanzar procesos. Partimos de un nombre real de nuestras copias:

Eso es basename y dirname sin basename ni dirname. La regla mnemotécnica es visual: en un teclado, # está a la izquierda del $ y quita por la izquierda; % está a la derecha y quita por la derecha. Doblar el símbolo hace el patrón codicioso, como la codicia de 03-02. Ojo: son patrones de globbing (*, ?, [...]), no expresiones regulares.

Los cuatro primeros son la base de la configuración por defecto, y :+ es el menos conocido: añade algo solo si hay algo que añadir.

El ${ruta//í/i} resuelve, sin llamar a sed, la tilde que la aplicación mete en los enlaces a /casas/el-molí y que provoca los cuatro 404 de acceso.log. El ${verbose:+-v} añade la opción solo si la variable tiene contenido, que es como se construyen líneas de comando condicionales. Y ${VAR:?mensaje}, ya visto en 03-01, es la forma más barata de exigir un valor obligatorio.

Bash tiene dos formas de hacer cuentas y las dos trabajan solo con enteros con signo de 64 bits.

$(( )) sustituye por el resultado, así que se usa donde quieras el valor. (( )) evalúa y no imprime nada: sirve para modificar variables o como condición, devolviendo 0 (éxito) si el resultado es distinto de cero. Dentro de ambas las variables van sin $ y dispones de + - * / % **, comparadores, && || !, ++ --, += y el ternario a ? b : c.

Dos avisos: un número con cero a la izquierda se interpreta en octal: $(( 08 )) es un error de sintaxis, lo que arruina cualquier cuenta con meses (08, 09); fuérzalo con $(( 10#08 )). Y (( i++ )) con i a 0 devuelve 1, porque el valor de la expresión es el previo al incremento, y con set -e eso aborta el script; es una trampa de 04-06, y por ahora usa (( ++i )) o i=$(( i + 1 )).

Para decimales hay que salir de Bash:

El importe medio por reserva de Tramontana es de 313,70 €. A bc hay que decirle la escala (scale=2) porque por defecto trunca a cero decimales al dividir; bc -l carga la librería matemática y la sube a 20. Pero fíjate en el segundo ejemplo: si los datos ya están en un fichero, awk hace lectura y cuenta a la vez. La regla del curso: bc para una cuenta suelta, awk en cuanto haya un fichero. Y el LC_ALL=C no es decorativo: con locale español printf '%.2f' imprimiría 313,70 con coma, y esa coma rompe cualquier comparación posterior.

Un array es una lista ordenada de cadenas con índice numérico desde 0. Resuelve «guardar varias cosas en una variable» sin recurrir a cadenas separadas por espacios, que se rompen en cuanto un elemento contiene uno.

Se crea con paréntesis, se añade con +=(...), [-1] es el último, ${#array[@]} cuenta elementos y ${array[@]:1:2} es una rebanada. El último comando revela algo importante: unset deja un hueco, los índices no se recolocan; por eso existe ${!array[@]}, que da los índices y no los valores.

La diferencia que más bugs causa, y solo se manifiesta dentro de comillas dobles:

"${array[@]}" produce un argumento por elemento, respetando espacios: es lo que quieres el 99 % de las veces. "${array[*]}" produce un único argumento con los elementos unidos por el primer carácter de IFS, útil solo para imprimir. Y sin comillas Bash divide por espacios, y «informe agosto.pdf» se convierte en dos ficheros que no existen. Grábatelo: arrays siempre con "${array[@]}".

Un array asociativo indexa por cadena en vez de por número: es lo que en 03-05 te daba awk, ahora dentro de Bash. Hay que declararlo con declare -A antes de usarlo; si no, Bash lo trata como indexado y todas las claves colapsan en el índice 0.

Las 70 noches conocidas, repartidas (aquí en dos columnas para ahorrar espacio). Dos piezas nuevas: < <(tail -n +2 "$CSV") es una sustitución de proceso que evita que el while corra en un subshell y pierda los arrays al terminar —lo detalla 04-03—, y los _id, _fecha, _huesped son la convención para «leo este campo pero no lo uso», que además calla a shellcheck. Nota honesta: este informe cabe en una línea de awk. Los arrays asociativos brillan cuando lo que acumulas no es texto tabular —códigos de salida por servicio, rutas ya procesadas, un caché—; con un CSV, awk sigue ganando. La regla se formaliza en 04-04.

Concatenar es escribir seguido, y += añade al final:

Las llaves de ${host} no son opcionales: sin ellas $host: funcionaría por casualidad, pero $puertoX buscaría una variable llamada puertoX. Usa llaves siempre que la variable toque texto pegado. Para la salida, printf sustituye a echo en todo lo serio: echo varía entre shells y hace cosas raras con -n y las barras invertidas, mientras que printf está definido con precisión y reutiliza el formato mientras queden argumentos, lo que lo convierte en un generador de tablas.

Una sola llamada, tres filas: el formato se ha reutilizado tres veces. Esa es la tabla del informe de Marta, y la razón por la que echo queda ya solo para mensajes de una línea sin formato.

El cambio de fondo: ningún valor está ya clavado en el cuerpo. Todos son constantes al principio, y las que tiene sentido ajustar desde fuera se leen del entorno con ${VAR:-defecto}.

Sin tocar el fichero, el script apunta a otro puerto. Ese es el primer paso de la cadena de precedencia argumentos > entorno > fichero de configuración > defectos que completaremos en 04-03 y cerraremos en 04-07. Sigue sin comparar nada con UMBRAL_DISCO: eso llega en 04-04.

• Espacios alrededor del =. VAR = valor no asigna nada: es el error número uno. El segundo es usar $VAR sin comillas: si el valor contiene espacios o un *, Bash lo parte o lo expande contra el disco. SC2086 es esto, y no es un aviso pedante: es un fallo esperando su fichero con espacio.
• Olvidar declare -A. Sin él, datos[mas-figueres]=1 evalúa la clave como aritmética, la convierte en 0 y todas las casas se pisan entre sí, sin error alguno. Y no confundas ${VAR:-x} con ${VAR:=x}: el primero no modifica la variable, el segundo sí.
• ${array[*]} en un bucle. Recorre un único elemento gigante; usa siempre "${array[@]}". Y cuidado con los ceros a la izquierda: $(( 08 + 1 )) falla por octal, así que escribe 10#$mes.
• Esperar decimales de $(( )). $(( 7842 / 25 )) da 313 y se pierde el resto sin avisar. Para dinero, awk o bc con LC_ALL=C.
• Consejo: declare -p VAR te dice qué es realmente una variable —array, entero, exportada— cuando algo no cuadra. Es el stat de las variables.
• Consejo: prefiere expansión de parámetros a basename, dirname, cut o tr para lo simple: en un bucle de mil iteraciones son mil procesos que te ahorras. Y declara readonly toda constante.

Ejercicio 1. Dado f="/srv/tramontana/backups/pre-despliegue/app-3.2.1-2026-08-11.tar.gz", obtén solo con expansión de parámetros (ni basename, ni cut, ni sed): el directorio, el nombre del fichero, el nombre sin extensión, la versión 3.2.1 y la fecha 2026-08-11. Explica cada expansión.

Ejercicio 2. Escribe ~/scripts/resumen_reservas.sh que, leyendo reservas.csv, imprima una tabla alineada con casa, reservas, noches e importe, más una línea de totales. Usa un array asociativo y printf. Debe coincidir con los datos conocidos: 25 reservas, 70 noches, 7.842,50 €.

Ejercicio 3. Luis propone esto para calcular el porcentaje de peticiones POST sobre las 412 de acceso.log. Explica los tres defectos y reescríbelo.

Solución 1.

• ${f%/*} quita el sufijo más corto que empiece por /: es dirname. ${f##*/} quita el prefijo más largo acabado en /: es basename.
• ${base%%.tar.gz} recorta la extensión compuesta. Aquí %% y % dan lo mismo porque el patrón es literal, pero %%.* habría sido peligroso: cortaría también en el punto de 3.2.1, dejando app-3.
• La versión sale en dos pasos: #app- quita el prefijo y %%-* recorta desde el primer guion restante, el que precede a la fecha. Para la fecha, ##*-[0-9].[0-9].[0-9]- usa un patrón de globbing —no una regex— que consume todo hasta pasado el número de versión.

Solución 2.

Coincide con los datos conocidos. La función suma es un adelanto de 04-05, pero ilustra por qué las funciones son inevitables: la misma línea de awk se usa en dos sitios.

Solución 3. Los tres defectos:

1. Espacios alrededor del =. posts = 114 intenta ejecutar el comando posts y el script muere en la primera línea.
2. El orden de las operaciones trunca el resultado. $posts/$total*100 calcula primero 114/412, que en aritmética entera es 0, y luego 0*100 = 0. Siempre multiplica antes de dividir.
3. Los $ sobran dentro de $(( )) —ruido, no error— y sobre todo un porcentaje pide un decimal que Bash no puede dar.

Fíjate en el %% del formato: dentro de printf, un % literal se escribe doblado.

Ya no dependes de valores clavados en el código, y de paso te has llevado la parte de Bash que más productividad da por línea escrita.

• Sabes que en Bash todo es una cadena y que el «tipo» lo pone el contexto: nada se valida, comparar números no es comparar texto, y no hay decimales. Asignas sin espacios alrededor del =, entrecomillas siempre el valor, distingues los ámbitos de shell, entorno y subshell sabiendo que los cambios del hijo nunca vuelven al padre, y usas declare con sus atributos -r, -i, -a, -A, -x y -p.
• Dominas la expansión de parámetros completa: :-, :=, :? y :+, longitudes, subcadenas, recortes con #, ##, %, %%, sustituciones con / y //, y cambio de caso. Ya no necesitas basename ni cut para lo simple.
• Haces aritmética entera con $(( )) y (( )), conoces la trampa del octal y la de (( i++ )), y sales a bc o awk con LC_ALL=C en cuanto aparece un decimal: el importe medio de Tramontana es 313,70 €.
• Manejas arrays indexados —siempre "${array[@]}", nunca ${array[*]}—, cuentas por clave con arrays asociativos tras el imprescindible declare -A, formateas con printf (que ya produce la tabla del informe de Marta), y revision_salud.sh lee su configuración del entorno con valores por defecto.

Pero el script sigue siendo mudo: no sabes pedirle ayuda, no puedes decirle «usa umbral 60» sin exportar una variable, y no hay forma de que lea el mes de un informe. En la siguiente lección, Entrada, Salida y Argumentos de un Script, le damos una interfaz de verdad: parámetros posicionales y la diferencia crítica entre $@ y $*, una función de ayuda, getopts para opciones cortas, las convenciones -h, -v, --dry-run y -- que hacen que un script parezca profesional, read en todas sus variantes y el patrón canónico para leer un fichero línea a línea, la regla de oro de stdout para resultados y stderr para humanos, y los códigos de salida con significado. Al terminarla, revision_salud.sh aceptará opciones y nacerá informe_reservas.sh.