Capítulo 12: Bucles: for, while, until, select
Capítulo 12: Bucles: for, while, until, select
Los bucles son la diferencia entre usar Bash como una calculadora de comandos y usarlo como lenguaje de automatización. Sin bucles, una tarea como “alinea 30 muestras con BWA” requiere escribir 30 veces el mismo comando cambiando el nombre. Con un bucle for, son 4 líneas que se ejecutan sobre cualquier número de archivos.
Bash ofrece cuatro bucles:
for— itera sobre una lista de elementos.while— ejecuta mientras una condición sea verdadera.until— ejecuta hasta que una condición sea verdadera (lo contrario dewhile).select— genera menús interactivos.
A estos se añaden los controladores break y continue para modificar el flujo dentro del bucle, y la forma C-like de for (( )) para iteraciones numéricas con contador. En este capítulo los veremos todos con ejemplos bioinformáticos realistas y ejercicios con solución.
12.1. Bucle for
Sintaxis clásica
for var in lista; do
comandos
donelista es una secuencia de palabras separadas por espacios. En cada iteración var toma el valor del siguiente elemento.
for fruta in manzana pera uva; do
echo "Me gusta la $fruta"
doneMe gusta la manzana
Me gusta la pera
Me gusta la uva
Iterar sobre una lista explícita
for gen in BRCA1 TP53 EGFR MYC; do
grep "$gen" anotacion.gff3
doneIterar sobre el resultado de un comando
for f in $(ls *.fastq.gz); do
fastqc "$f"
donefor con $(ls) no es seguro si hay espacios
ls separa por espacios, así que un archivo llamado muestra A R1.fastq.gz se rompería en tres “elementos” del bucle. Mejor:
for f in *.fastq.gz; do
fastqc "$f"
doneEl shell expande *.fastq.gz a la lista de archivos sin partir nombres con espacios. Si necesitas recursión o filtros complejos, usa find ... -print0 | while IFS= read -r -d '' f; do ...; done.
Iterar sobre un rango numérico
Bash soporta expansiones de rango con {inicio..fin} o {inicio..fin..paso}:
for i in {1..10}; do echo $i; done # 1 2 3 ... 10
for i in {0..100..5}; do echo $i; done # 0 5 10 ... 100
for i in {10..1}; do echo $i; done # cuenta atrásCon seq:
for i in $(seq 1 10); do echo $i; done
for i in $(seq -w 1 3 30); do echo $i; done # 01 04 07 10 13 16 19 22 25 28Forma C-like
Para iteraciones con contador más complejas:
for ((i=0; i<10; i++)); do
echo "Iteración $i"
done
# Bucles anidados
for ((i=1; i<=3; i++)); do
for ((j=1; j<=3; j++)); do
echo "i=$i j=$j"
done
doneIterar sobre archivos de forma segura
for f in *.fastq; do
echo "Procesando $f"
done
# Con find para recursión
find . -name "*.bam" -print0 | while IFS= read -r -d '' bam; do
samtools index "$bam"
doneEl -print0 + read -d '' es la combinación infalible para nombres con espacios, saltos de línea o caracteres raros.
12.2. Bucle while
Sintaxis
while condición; do
comandos
doneEjecuta comandos mientras condición devuelva 0 (éxito). La condición puede ser [ ], [[ ]], (( )) o cualquier comando.
n=0
while [[ $n -lt 5 ]]; do
echo "n=$n"
n=$((n + 1))
doneLeer un archivo línea por línea
while read -r linea; do
echo "Línea: $linea"
done < archivo.txtIFS= read -r
La forma correcta de leer líneas en Bash es:
while IFS= read -r linea; do ...; done < archivoIFS=(vacío) preserva los espacios al inicio y al final de cada línea.-rdesactiva la interpretación de\como escape (sin-r,\tse vuelvet). Sin estas dos banderas, líneas con espacios o barras invertidas se corrompen silenciosamente.
Leer múltiples campos
Si cada línea tiene varios campos delimitados, lee varias variables:
while IFS=$'\t' read -r gen s1 s2 s3; do
echo "Gen $gen: total=$((s1+s2+s3))"
done < counts.tsvEl IFS=$'\t' solo dura durante el read, así que el resto del script no se ve afectado.
Bucle infinito
while true; do
echo "Esperando..."
sleep 5
doneSe rompe con break o matando el proceso (Ctrl-C).
while con la salida de un comando
some_command | while read -r linea; do
# procesar
doneEn Bash clásico, la parte derecha de un pipe se ejecuta en un subshell. Las variables que modifiques dentro del while no se conservan fuera. Si necesitas conservarlas, usa sustitución de proceso:
while read -r linea; do
contador=$((contador+1))
done < <(some_command)
echo "Procesé $contador líneas" # aquí sí conserva el valorEsto también se soluciona con shopt -s lastpipe en Bash 4+.
12.3. Bucle until
Es como while pero ejecuta hasta que la condición sea verdadera (es decir, mientras sea falsa):
until pgrep -f "bwa mem" > /dev/null; do
sleep 5
done
echo "BWA ha empezado"Equivale a while ! pgrep -f "bwa mem" > /dev/null; do ..., pero algunos lo encuentran más legible.
12.4. select: menús interactivos
PS3="Elige una opción: "
select opcion in "Alinear" "Llamar variantes" "Filtrar" "Salir"; do
case $opcion in
"Alinear")
echo "Ejecutando alineamiento..."
bwa mem ref.fa R1.fq R2.fq > aln.sam
;;
"Llamar variantes")
echo "Llamando variantes..."
bcftools mpileup -f ref.fa aln.bam | bcftools call -v > variants.vcf
;;
"Filtrar")
echo "Filtrando variantes..."
bcftools view -i 'QUAL>30' variants.vcf > filtered.vcf
;;
"Salir")
echo "Adiós"
break
;;
*)
echo "Opción no válida"
;;
esac
doneselect muestra la lista numerada y pide al usuario un número. La variable PS3 define el prompt.
12.5. break y continue
| Comando | Acción |
|---|---|
break |
Sale del bucle inmediatamente |
continue |
Salta a la siguiente iteración |
break N |
Sale de N niveles de bucles anidados |
continue N |
Salta a la siguiente iteración del N-ésimo nivel |
for i in {1..10}; do
if (( i % 2 == 0 )); then continue; fi # saltar pares
if (( i > 7 )); then break; fi # parar si pasamos de 7
echo $i
doneSalida: 1 3 5 7.
12.6. seq y otros generadores
seq START INC STOP:
seq 1 10 # 1 2 3 ... 10
seq 1 2 10 # 1 3 5 7 9
seq -w 1 10 # 01 02 03 ... 10 (padding con ceros)
seq -f "%.2f" 0 0.5 2 # 0.00 0.50 1.00 1.50 2.00Para repetir un string N veces:
yes "ACGT" | head -n 512.7. Parámetros posicionales con shift
shift desplaza los parámetros posicionales: $2 pasa a $1, $3 a $2, etc. Útil para procesar argumentos en bucle:
while [[ $# -gt 0 ]]; do
case "$1" in
-r) ref="$2"; shift 2 ;;
-o) outdir="$2"; shift 2 ;;
-h) echo "Ayuda"; exit 0 ;;
*) echo "Argumento desconocido: $1" >&2; exit 1 ;;
esac
doneEs la base de un parser de argumentos minimalista sin getopts.
12.8. Ejemplos bioinformáticos
Alinear múltiples muestras
mkdir -p alineados
for r1 in *_R1.fastq.gz; do
r2=${r1/_R1/_R2} # sustituye _R1 por _R2
muestra=$(basename "$r1" _R1.fastq.gz) # quita ruta y sufijo
echo "Alineando $muestra..."
bwa mem -t 8 ref.fa "$r1" "$r2" \
| samtools sort -o "alineados/${muestra}.bam"
doneComentarios:
${var/patrón/reemplazo}sustituye una vez el patrón por el reemplazo.basenamequita el directorio y, opcionalmente, un sufijo.- Se podría indexar a continuación en el mismo bucle.
Indexar todos los BAM
for bam in resultados/*.bam; do
samtools index "$bam"
doneEsperar a que terminen todos los jobs
while pgrep -f "bwa mem" > /dev/null; do
echo "Esperando BWA... ($(date +%H:%M:%S))"
sleep 60
done
echo "Todos los alineamientos han terminado"Procesar una tabla de muestras
while IFS=',' read -r muestra grupo condicion; do
echo "Procesando $muestra ($grupo, $condicion)"
# Aquí va el comando real (fastqc, trimming, alineamiento, etc.)
done < muestras.csvCountdown para checkpoint
for i in {10..1}; do
echo "Reintentando en $i..."
sleep 1
doneAplicar Variant Calling en cromosomas por separado
for chr in $(seq 1 22) X Y; do
echo "Cromosoma $chr"
bcftools mpileup -r "chr$chr" -f ref.fa aln.bam \
| bcftools call -v -o "vcf/chr${chr}.vcf"
donexargs -P o GNU parallel
Cuando un bucle for se vuelve lento porque cada iteración es intensiva, paralelízalo:
ls *_R1.fastq.gz | xargs -I{} -P 4 sh -c 'r2=${1/_R1/_R2}; m=$(basename "$1" _R1.fastq.gz); bwa mem ref.fa "$1" "$r2" | samtools sort -o "aln/${m}.bam"' _ {}-P 4 lanza hasta 4 procesos en paralelo. GNU parallel ofrece más control y es el estándar de facto en pipelines.
Renombrar archivos en masa
for f in *.fq.gz; do
mv "$f" "${f%.fq.gz}.fastq.gz"
done${f%sufijo} elimina el sufijo desde el final. Para prefijos se usa ${f#prefijo}.
$'\t' y los finales de línea
Si lees un CSV de Windows (\r\n) con while IFS=, read -r ..., el último campo se quedará con un \r al final y causará errores raros (“no se encuentra el archivo muestra1). Solución: pasa primero el archivo por sed -i 's/\r$//' muestras.csv o usa tr -d '\r' en el pipe.
12.9. Ejercicios
Ejercicio 1
Escribe un script que itere sobre todos los archivos *.fastq.gz del directorio actual y ejecute fastqc en cada uno. Maneja espacios en nombres y muestra progreso con echo "Procesando: $archivo".
Ejercicio 2
Escribe un script que lea muestras.tsv (columnas: muestra, R1, R2) y para cada muestra ejecute:
bwa mem ref.fa R1 R2 > muestra.samAsegúrate de usar IFS=$'\t' y read -r.
Ejercicio 3
Escribe esperar_job.sh que reciba como argumento un patrón de nombre de proceso. El script debe hacer polling cada 30 segundos hasta que no queden procesos cuyo nombre coincida con el patrón. En cada iteración imprime un mensaje. Ejemplo de uso:
./esperar_job.sh "bwa mem"12.10. Soluciones
Solución 1
#!/usr/bin/env bash
# fastqc_all.sh
# Iteramos directamente sobre el glob; el shell no parte nombres con espacios
for archivo in *.fastq.gz; do
# Si no hay coincidencias, el glob se queda literal "*.fastq.gz"
# Lo detectamos y salimos limpiamente
if [[ ! -e "$archivo" ]]; then
echo "No se encontraron archivos *.fastq.gz en $(pwd)" >&2
exit 0
fi
echo "Procesando: $archivo"
fastqc "$archivo"
doneComentarios:
for archivo in *.fastq.gz: Bash expande el glob a la lista de archivos. Los nombres con espacios se conservan íntegros porque cada archivo es un solo elemento del bucle."$archivo": siempre entre comillas al usarlo, para que ni el shell nifastqclo partan.- El chequeo
[[ ! -e "$archivo" ]]cubre el caso de directorio vacío: si no hay*.fastq.gz, Bash deja el literal como valor de$archivo, lo cual no es un archivo real. exit 0(no 1): no encontrar archivos no es un error, simplemente nada que hacer.
Solución 2
#!/usr/bin/env bash
# alinear_muestras.sh
ref="data/ref.fa"
tabla="muestras.tsv"
# Comprobaciones básicas
if [[ ! -f "$ref" ]]; then
echo "Error: falta el genoma de referencia $ref" >&2
exit 1
fi
if [[ ! -f "$tabla" ]]; then
echo "Error: falta la tabla $tabla" >&2
exit 1
fi
# IFS=$'\t' hace que read separe por tabulador (no por espacio)
while IFS=$'\t' read -r muestra r1 r2; do
# Saltar cabecera (si la primera columna es literal "muestra")
if [[ "$muestra" == "muestra" ]]; then
continue
fi
echo "Alineando muestra: $muestra"
echo " R1: $r1"
echo " R2: $r2"
# Lanzamos BWA y redirigimos la salida al SAM de la muestra
bwa mem "$ref" "$r1" "$r2" > "${muestra}.sam"
# Comprobamos que el comando terminó bien
if [[ $? -ne 0 ]]; then
echo " Error alinear $muestra" >&2
# Decidir: continuar con la siguiente o abortar
# Aquí optamos por continuar
continue
fi
echo " OK"
done < "$tabla"
echo "Procesamiento completado."Comentarios:
IFS=$'\t'se asigna solo durante elread. No afecta al resto del script.-revita que las barras invertidas de los paths sean interpretadas.- El chequeo
[[ "$muestra" == "muestra" ]]salta la cabecera del TSV (asumiendo que la primera columna se llama literalmente “muestra”). Otra opción:tail -n +2 muestras.tsv | while .... $?guarda el exit code debwa mem. Si no fue 0, hubo un error y lo avisamos.- El bucle continúa con la siguiente muestra en caso de error (decisiones de diseño: si prefieres abortar, sustituye
continueporexit 1).
Solución 3
#!/usr/bin/env bash
# esperar_job.sh
patron="$1"
# Validamos argumento
if [[ -z "$patron" ]]; then
echo "Uso: $0 <patrón de proceso>" >&2
echo "Ejemplo: $0 \"bwa mem\"" >&2
exit 1
fi
# Bucle de polling: mientras haya procesos que coincidan, espera
while pgrep -f "$patron" > /dev/null; do
n=$(pgrep -fc "$patron") # cuenta de procesos (-c)
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Quedan $n proceso(s) que coinciden con '$patron'"
sleep 30
done
echo "[$(date '+%Y-%m-%d %H:%M:%S')] No quedan procesos '$patron'. Terminado."Comentarios:
pgrep -f "$patron"busca procesos cuya línea de comando completa encaje con el patrón (no solo el nombre del binario). Devuelve 0 si encuentra al menos uno, 1 si ninguno.> /dev/nullsilencia la salida (los PIDs), porque solo nos interesa el exit code para elwhile.pgrep -fc "$patron"devuelve el número de procesos (-c= count).sleep 30introduce el retardo entre checks.date '+...'añade una marca temporal para saber cuánto llevamos esperando.- Cuando
pgrepno encuentre nada, elwhiletermina y se imprime el mensaje final.
Ejemplo de salida:
[2025-01-15 14:22:30] Quedan 3 proceso(s) que coinciden con 'bwa mem'
[2025-01-15 14:23:00] Quedan 3 proceso(s) que coinciden con 'bwa mem'
[2025-01-15 14:23:30] Quedan 1 proceso(s) que coinciden con 'bwa mem'
[2025-01-15 14:24:00] No quedan procesos 'bwa mem'. Terminado.
En bioinformática prácticamente todos los pipelines se reducen a: (1) iterar sobre muestras, (2) por cada muestra ejecutar una cadena de comandos, (3) reportar el éxito o fallo. Los bucles for (sobre archivos) y while read (sobre tablas de muestras) cubren el 90% de las necesidades. Aprende a usarlos con IFS= y -r desde el principio: son los detalles que separan un script robusto de uno que falla con el primer archivo cuyo nombre tiene un espacio.
Con los bucles y las estructuras de control del capítulo anterior ya tienes lo esencial para escribir scripts Bash completos. En los siguientes capítulos del curso veremos cómo empaquetar todo esto en scripts reutilizables con funciones, cómo manejar argumentos y señales, y cómo integrar tus scripts con herramientas bioinformáticas como samtools, bcftools y nextflow.
