Cerrábamos la lección de arrays con dos deudas: ${importe%.*}, que recortaba los céntimos, y ${ENVIOS[$c]:-0}, que ponía un valor por defecto. La segunda ya la conoces de 03-06; la primera pertenece a una familia mucho mayor. Bash puede cortar, recortar, sustituir y transformar cadenas sin llamar a ningún programa externo, usando la misma sintaxis ${...} de siempre. Esto importa por dos motivos: el código queda más corto, y sobre todo es entre diez y cien veces más rápido, porque cada sed o cut dentro de un bucle es un proceso nuevo del sistema operativo. En esta lección completas la familia entera y aprendes a formatear la salida de informe-diario.sh con printf.

1. Longitud y subcadenas
2. Eliminar prefijos y sufijos
3. Sustitución de texto
4. Mayúsculas y minúsculas
5. Concatenación
6. Comparación y coincidencia de patrones
7. Dividir una cadena en array
8. printf: anchos, alineación y decimales
9. Expansiones frente a sed, cut, basename
10. Ejemplo integrador

La sintaxis es ${cadena:desplazamiento:longitud}, con el desplazamiento empezando en 0. Tres notas prácticas: el espacio antes de un número negativo es obligatorio, porque sin él ${s:-7} significa "valor por defecto 7", una expansión completamente distinta (también vale ${s:(-7)}); ambos números admiten aritmética, como ${s:i:n} o ${s:0:${#s}-4}; y se cuentan caracteres, no bytes, siempre que el locale sea UTF-8, así que una ñ cuenta 1. Funciona también sobre los argumentos: ${1:0:4} son los cuatro primeros caracteres de $1.

Cuatro operadores que recortan lo que coincida con un patrón glob (los de 02-05: *, ?, [...]), no con una expresión regular:

Regla mnemotécnica, mirando un teclado: # está a la izquierda del $ y recorta por la izquierda; % está a la derecha y recorta por la derecha. Y doblar el símbolo significa "come todo lo que puedas".

Aplicado a nuestros datos:

Ese bloque final extrae fecha, hora, nivel y mensaje de una línea de app.log sin lanzar un solo proceso. Los \\[ y \\] van escapados porque en un patrón glob los corchetes definen una clase de caracteres.

Resumen: una barra sustituye la primera coincidencia, dos barras todas, /# ancla al principio y /% al final. El patrón de búsqueda es otra vez un glob, lo que permite cosas como:

Ese idioma para recortar espacios es feo pero es el estándar en Bash puro; guárdalo como función trim() en tu librería.

Cuatro operadores, disponibles desde Bash 4:

El uso más frecuente es normalizar antes de comparar, para que el usuario pueda escribir VALENCIA, valencia o Valencia: ciudad="${1,,}"; ciudad="${ciudad^}" deja siempre Valencia. Se puede limitar a ciertos caracteres con un patrón (${s^^[aeiou]} pone en mayúsculas solo las vocales), aunque es poco frecuente.

Bash no tiene operador de concatenación: basta con escribir las cadenas seguidas.

Las llaves de ${prefijo}_ son obligatorias aquí: sin ellas Bash buscaría una variable llamada prefijo_. Y para ir acumulando texto en un bucle:

+= sobre una cadena concatena; sobre un array (04-03) añade elementos; sobre una variable declare -i suma. El mismo operador, tres comportamientos según el tipo.

Dentro de [[ ]], el operador == hace algo más que comparar: si el lado derecho no está entrecomillado, se interpreta como un patrón glob.

Esta es la única situación del curso en la que quitar las comillas es deliberado y correcto: cuando quieres que el contenido de la variable funcione como patrón. En cualquier otro contexto, comillas.

Otros operadores de cadena en [[ ]], ya vistos en 03-03: !=, < y > (orden alfabético según el locale), -z (vacía) y -n (no vacía).

Para coincidencias que un glob no puede expresar —"tres dígitos seguidos de una letra", "una IP válida"— hace falta el operador =~ con expresiones regulares. Es tema completo de 05-04; por ahora, si el patrón se puede escribir con * y ?, usa ==.

Ya lo viste en 04-03; lo recogemos aquí porque es una operación de cadenas de pleno derecho:

La segunda variante falla si un campo contiene *, porque el globbing lo expandirá a nombres de ficheros. La operación inversa, unir un array en una cadena, se hace con "${arr[*]}" y el IFS adecuado:

Nota: solo se usa el primer carácter de IFS como separador en ${arr[*]}, así que el ejemplo anterior une con un espacio. Para separadores de varios caracteres, usa printf o un bucle.

Ya sabes de 03-06 que printf es preferible a echo. Aquí explotamos sus especificadores para construir tablas:

Tres comportamientos de printf que conviene conocer: reutiliza el formato mientras queden argumentos, de modo que printf '%s\n' "${ciudades[@]}" imprime cada ciudad en su línea sin necesidad de bucle; el ancho puede venir de una variable usando *, como en printf '%-*s\n' 15 "$ciudad"; y %.2f redondea, no trunca (printf '%.2f' 2.005 da 2.01), admitiendo decimales aunque Bash no sepa calcularlos, porque el formateo lo hace printf y no la aritmética del shell (04-06). Con caracteres acentuados el ancho se cuenta en caracteres si el locale es UTF-8; si tus columnas bailan, revisa LANG.

Todo lo de esta lección se puede hacer también con herramientas externas. La diferencia es el coste:

Cada columna izquierda lanza un proceso nuevo: el kernel hace un fork, carga el binario, monta una tubería y espera. Son unos pocos milisegundos... multiplicados por el número de iteraciones.

La regla práctica: dentro de un bucle, expansión; fuera de un bucle, la herramienta que sea más legible. Y si el trabajo es procesar un fichero entero de una vez, casi siempre gana awk en una sola pasada (06-01); volveremos sobre esto al medir de verdad en 08-02. Un matiz a favor de basename/dirname: manejan los casos raros (rutas terminadas en /, ., ..) según el estándar, mientras que "${ruta%/*}" sobre un archivo.txt sin barras devuelve archivo.txt y no .. Para rutas controladas por ti, la expansión es perfecta; para rutas arbitrarias del usuario, usa las herramientas.

Un analizador de app.log que extrae los campos con expansiones y formatea una tabla con printf, sin cut, sin awk y sin sed:

Salida: una tabla HORA / ERRORES con líneas como 10:00 14. Comentarios sobre las partes nuevas:

• [[ "$linea" == "$fecha"* ]]: la variable va entrecomillada y el * fuera, así se compara literalmente la fecha y se acepta cualquier cosa después. Es el idioma correcto para "empieza por".
• ${resto%%:*} corta en el primer :, dejando la hora. Con % en lugar de %% habríamos cortado en el último y obtendríamos 10:15.
• $(( 10#$h )) fuerza la interpretación en base 10. Una hora como 08 se interpretaría como octal inválido y daría error; es una trampa clásica que desmontamos entera en 04-06.

Y en informe-diario.sh, la función de formato queda en una línea: fila_ciudad() { printf '%-10s %8d %13d %10.2f€\n' "${1^}" "$2" "$3" "$4"; }. El ${1^} normaliza la inicial de la ciudad y los anchos fijos garantizan que las columnas cuadren venga como venga el dato.

• Olvidar el espacio en ${s: -3}. Sin él, ${s:-3} es "valor por defecto", una expansión distinta que no dará error pero devolverá otra cosa.
• Confundir #/## y %/%%. Prueba siempre con un echo antes de meterlo en el script; la diferencia entre la coincidencia más corta y la más larga rompe rutas con varios puntos.
• Creer que los patrones son regex. ${s#[0-9]+} no funciona: + no es un cuantificador en globbing. Para regex, =~ en 05-04.
• Entrecomillar el patrón en [[ $f == "*.gz" ]]. Lo convierte en literal y siempre da falso. El patrón va sin comillas; la variable, con ellas.
• Aplicar ${s^^} en Bash 3.2 (macOS). No existe; ahí toca tr.
• Consejo: cuando una cadena de recortes se vuelva ilegible (${${x#a}%b} ni siquiera es válido en Bash), usa variables intermedias con nombre. Tres líneas claras valen más que una críptica.

Ejercicio 1. Dada ruta="/srv/veloz/datos/envios-2026-08-03.csv", obtén con expansiones: el nombre del fichero, el directorio, el nombre sin extensión y la fecha 2026-08-03 que lleva dentro.

Ejercicio 2. Escribe normaliza_ciudad() que acepte cualquier combinación de mayúsculas (SEVILLA, sevilla, SeViLla) y devuelva siempre Sevilla; si la ciudad no es de las cuatro, devuelve código 1.

Ejercicio 3. A partir de la línea 2026-08-03 10:15:22 [WARN] cola de reparto por encima del umbral, extrae fecha, hora, nivel y mensaje en cuatro variables sin usar herramientas externas, e imprímelos con printf en columnas alineadas.

Solución 1.

Solución 2.

Normalizar ambos lados a minúsculas y comparar es más robusto que jugar con ${c^}, porque devuelve la forma canónica exacta de la lista.

Solución 3.

Cada línea usa el operador mínimo necesario: %% para "hasta el primero por la derecha", # para "el primero por la izquierda". Cero procesos lanzados.

Ya no necesitas cut, tr ni sed para el trabajo rutinario sobre cadenas. ${#s} mide, ${s:i:n} corta por posición, #/##/%/%% recortan por patrón desde cada extremo, / y // sustituyen, ^/, cambian la caja, += concatena, [[ $s == patron* ]] compara con globs, IFS reparte una línea en un array, y printf con anchos y %.2f produce tablas que cuadran. Todo dentro del mismo proceso, que en un bucle sobre miles de líneas es la diferencia entre segundos y minutos.

Nos queda una pieza estructural. Cuando en el ejercicio 2 recorriste cuatro ciudades con un bucle para ver si una cadena era válida, estabas usando la herramienta equivocada: comparar un valor contra una lista cerrada de alternativas es exactamente lo que hace case, la construcción que en 04-05 recibirá por fin el tratamiento formal que en 03-05 solo usamos de pasada para parsear opciones. Con ella daremos a informe-diario.sh subcomandos (resumen, detalle, ciudades) y construiremos veloz-menu.sh, un menú interactivo del toolkit con select.