10 Variables & Parámetros

El finalizar este módulo serás capaz de definir variables, diferenciar tipos de comillas y manejar parámetros posicionales y opciones.

10.1 Variables

#!/bin/bash
GENOME="Homo_sapiens"
READS=1000000
path_data="/home/user/data"

No hay tipado: todo es cadena.
Se asigna sin espacios alrededor del =.

10.2 Comillas

Dobles ("): expanden variables y comandos.
Simples ('): contenido literal.
Escapado (\): para literales.

VAR="mundo"

# Dobles: expanden variables y comandos
echo "Hola $VAR"                    # Output: Hola mundo
echo "Fecha: $(date)"               # Output: Fecha: Wed May 28...

# Simples: literales
echo 'Hola $VAR'                    # Output: Hola $VAR
echo 'Fecha: $(date)'               # Output: Fecha: $(date)

# Sin comillas: pueden causar problemas
FILE="archivo con espacios.txt"
ls $FILE                            # Error: busca 3 archivos
ls "$FILE"                          # Correcto: un archivo

10.3 Expansión de Variables

FILE="sample.fastq"

# Expansión básica
echo "${FILE}"                      # sample.fastq

# Manipulación de strings
echo "${FILE%.fastq}"               # sample (quita extensión)
echo "${FILE%.*}"                   # sample (quita última extensión)
echo "${FILE##*/}"                  # sample.fastq (solo nombre)
echo "${FILE%/*}"                   # directorio (sin nombre)

# Longitud
echo "${#FILE}"                     # 12 (caracteres)

# Valores por defecto
echo "${OUTPUT_DIR:-./results}"     # ./results si OUTPUT_DIR vacía
echo "${THREADS:=4}"                # asigna 4 si THREADS vacía

10.4 Argumentos Posicionales

$1, $2, … $N.
$0 es el nombre del script.
$@ o $*: todos los argumentos.
$#: conteo de argumentos.

#!/bin/bash
# Uso: bash setup.sh input.fasta output.txt
in=$1
out=$2
if [[ $# -ne 2 ]]; then
  echo "Uso: $0 <in.fasta> <out.txt>"; exit 1
fi
# convertir FASTA a lista de secuencias
grep -v '>' "$in" > "$out"

10.5 Verifica el número de argumentos

if [[ $# -ne 3 ]]; then
    echo "Error: Se requieren 3 argumentos"
    echo "Uso: $0 <referencia> <reads> <output>"
    exit 1
fi

# Asignar a variables con nombres descriptivos
REFERENCE="$1"
READS="$2"
OUTPUT="$3"

10.6 Ejemplo Bioinformático

10.6.1 Procesar de muestras múltiples

#!/bin/bash
# Procesar múltiples muestras de RNA-seq

# Arrays de muestras
SAMPLES=(control_1 control_2 treated_1 treated_2)
CONDITIONS=(control control treated treated)

# Procesar cada muestra
for i in "${!SAMPLES[@]}"; do
    sample="${SAMPLES[$i]}"
    condition="${CONDITIONS[$i]}"
    
    echo "=== Procesando $sample ($condition) ==="
    
    # Rutas de archivos
    R1="data/${sample}_R1.fastq.gz"
    R2="data/${sample}_R2.fastq.gz"
    OUTPUT="results/${sample}"
    
    # Verificar archivos
    if [[ ! -f "$R1" || ! -f "$R2" ]]; then
        echo "Warning: Archivos no encontrados para $sample"
        continue
    fi
    
    # Crear directorio de salida
    mkdir -p "$OUTPUT"
    
    # Alineamiento (ejemplo)
    echo "Alineando $sample..."
    # hisat2 -x genome_index -1 "$R1" -2 "$R2" -S "$OUTPUT/${sample}.sam"
    
    echo "$sample completado"
done

10.6.2 Configuración flexible con variables

#!/bin/bash
# Pipeline con configuración externa

# Archivo de configuración
CONFIG_FILE="${1:-config.txt}"

# Leer configuración
source "$CONFIG_FILE" 2>/dev/null || {
    echo "Creando archivo de configuración: $CONFIG_FILE"
    cat > "$CONFIG_FILE" << 'EOF'
# Configuración del pipeline
THREADS=8
MEMORY="16G"
GENOME_INDEX="/path/to/genome_index"
ADAPTER_SEQUENCE="AGATCGGAAGAGC"
MIN_LENGTH=50
QUALITY_CUTOFF=20
EOF
    echo "Edita $CONFIG_FILE y vuelve a ejecutar"
    exit 1
}

echo "Configuración cargada:"
echo "  Threads: $THREADS"
echo "  Memoria: $MEMORY"
echo "  Índice: $GENOME_INDEX"

# Usar variables en el pipeline
run_trimming() {
    local input_r1="$1"
    local input_r2="$2"
    local output_prefix="$3"
    
    cutadapt \
        -a "$ADAPTER_SEQUENCE" \
        -A "$ADAPTER_SEQUENCE" \
        -m "$MIN_LENGTH" \
        -q "$QUALITY_CUTOFF" \
        -j "$THREADS" \
        -o "${output_prefix}_R1_trimmed.fastq.gz" \
        -p "${output_prefix}_R2_trimmed.fastq.gz" \
        "$input_r1" "$input_r2"
}

10.6.3 Manejo robusto de parámetros

#!/bin/bash
# Script robusto para alineamiento

set -euo pipefail

# Función de validación
validate_inputs() {
    local ref="$1"
    local reads="$2"
    
    # Verificar archivos
    [[ ! -f "$ref" ]] && { echo "Error: Referencia no encontrada: $ref"; return 1; }
    [[ ! -f "$reads" ]] && { echo "Error: Reads no encontrados: $reads"; return 1; }
    
    # Verificar formato
    case "${ref##*.}" in
        fa|fasta) echo "Referencia FASTA: OK" ;;
        *) echo "Warning: Extensión de referencia inusual"; ;;
    esac
    
    case "${reads##*.}" in
        fastq|fq) echo "Reads FASTQ: OK" ;;
        gz) [[ "$reads" =~ \.(fastq|fq)\.gz$ ]] && echo "Reads FASTQ comprimidos: OK" ;;
        *) echo "Error: Formato de reads no soportado"; return 1 ;;
    esac
    
    return 0
}

# Función principal
main() {
    local reference="$1"
    local reads="$2"
    local output="${3:-alignment.sam}"
    local threads="${4:-4}"
    
    echo "=== Parámetros ==="
    echo "Referencia: $reference"
    echo "Reads: $reads"
    echo "Output: $output"
    echo "Threads: $threads"
    
    # Validar inputs
    validate_inputs "$reference" "$reads"
    
    # Ejecutar alineamiento
    echo "Iniciando alineamiento..."
    # bwa mem -t "$threads" "$reference" "$reads" > "$output"
    echo "Completado: $output"
}

# Verificar argumentos mínimos
if [[ $# -lt 2 ]]; then
    echo "USO: $0 <referencia> <reads> [output] [threads]"
    echo "Ejemplo: $0 genome.fa sample.fastq alignment.sam 8"
    exit 1
fi

main "$@"

10.7 Consejos Avanzados y Buenas Prácticas

Valida siempre el número y tipo de argumentos.
Provee flags -h o --help con usage().
Usa patrones POSIX para compatibilidad con otros shells.
Evita variables globales innecesarias; usa funciones.

10.8 Resumen de Comandos

Comando	Descripción
`VAR=value`	Declara variable
`"$VAR"`	Uso seguro respectando espacios
`$@`, `$#`	Lista y conteo de argumentos
`case...esac`	Manejo de opciones más complejo