Dominando los argumentos en Bash: Guía completa de $1, $2, $@, $# y el comando shift

Introducción

Si alguna vez abriste una terminal y ejecutaste un comando como git commit -m "mensaje" o npm install paquete, ya estuviste interactuando con argumentos de línea de comandos. Pero, ¿qué pasa cuando vos sos el que escribe el script? ¿Cómo hacés para que tu programa sea dinámico y reciba datos desde afuera sin tener que editar el código cada vez?

En el mundo de Bash y los scripts de shell, el manejo de argumentos es fundamental. Ya sea que estés armando un pipeline de CI/CD, un script de backup automatizado o una herramienta de despliegue, necesitás saber cómo capturar, contar y procesar la información que el usuario le pasa al script al momento de ejecutarlo.

En este artículo vas a aprender exactamente cómo funcionan las variables posicionales ($1, $2, etc.), cómo manejar todos los argumentos a la vez con $@, cómo contar cuántos parámetros recibiste con $# y, lo más importante, cómo usar el comando shift para procesar opciones complejas de manera profesional. Este contenido está pensado para desarrolladores y sysadmins que quieran pasar de scripts rígidos a herramientas flexibles y potentes.

Las Variables Posicionales: $1, $2 y más

Cuando ejecutás un script, Bash asigna automáticamente cada palabra que escribís después del nombre del script a una variable numérica. Estas son las llamadas variables posicionales.

¿Cómo funcionan?

• $0: Es el nombre del script que se está ejecutando. Es muy útil para mostrar mensajes de ayuda o logs.
• $1: El primer argumento pasado al script.
• $2: El segundo argumento.
• $3 hasta $9: Siguen el mismo patrón.
• ${10}, ${11}, etc.: A partir del décimo argumento, es obligatorio usar llaves {} para que Bash no interprete $10 como la variable $1 seguida de un cero.

Ejemplo práctico 1: Un saludo personalizado

Vamos a crear un script simple llamado saludo.sh:

#!/bin/bash

echo "Hola, el script se llama: $0"
echo "El primer nombre es: $1"
echo "El segundo nombre es: $2"

Ejecución y salida:

Si lo ejecutás así:
./saludo.sh Juan Pedro

La salida será:

Hola, el script se llama: ./saludo.sh
El primer nombre es: Juan
El segundo nombre es: Pedro

Ojo acá: Si el argumento contiene espacios, tenés que encerrarlo entre comillas. Si ejecutás ./saludo.sh "Juan Perez" Pedro, entonces $1 será Juan Perez y $2 será Pedro. Si te olvidás las comillas, Bash romperá la frase en palabras independientes.

Manejando el conjunto: $@ y $#

En la vida real, no siempre sabés cuántos argumentos te va a pasar el usuario. No podés escribir $1, $2, $3... hasta el infinito. Para eso existen $@ y $#.

El contador de argumentos: $#

La variable $# te devuelve la cantidad total de argumentos pasados. Es fundamental para validar que el usuario haya ingresado la información mínima necesaria antes de que el script falle.

La lista completa: $@

$@ representa todos los argumentos pasados al script. Es ideal para iterar sobre ellos usando un bucle for.

Ejemplo práctico 2: Procesador de archivos

Imaginá que querés un script que imprima el nombre de varios archivos que le pases.

#!/bin/bash

# Validamos que se haya pasado al menos un argumento
if [ $# -eq 0 ]; then
    echo "Error: No pasaste ningún archivo."
    echo "Uso: $0 archivo1 archivo2 ..."
    exit 1
fi

echo "Recibí $# archivos para procesar:"

for archivo in "$@"; do
    echo "Procesando el archivo: $archivo"
done

Ejecución y salida:

Si lo ejecutás así:
./procesar.sh nota.txt config.json imagen.png

La salida será:

Recibí 3 archivos para procesar:
Procesando el archivo: nota.txt
Procesando el archivo: config.json
Procesando el archivo: imagen.png

El comando shift: El secreto de los scripts profesionales

Acá es donde las cosas se ponen interesantes. El comando shift desplaza los argumentos posicionales una posición hacia la izquierda.

Cuando ejecutás shift, el valor de $2 pasa a ser $1, el de $3 pasa a ser $2, y así sucesivamente. El antiguo $1 desaparece definitivamente.

¿Para qué sirve esto?

shift es extremadamente útil cuando tenés que procesar "banderas" o opciones (como -v, -f, --help) y querés ir "consumiendo" los argumentos a medida que los procesás, dejando siempre el argumento actual en $1.

Ejemplo práctico 3: Script con opciones dinámicas

Vamos a armar un script que acepte opciones como -u (usuario) y -p (puerto), seguidos de su valor.

#!/bin/bash

USER="Invitado"
PORT="80"

while [ $# -gt 0 ]; do
    case "$1" in
        -u|--user)
            USER="$2"
            shift 2 # Desplazamos 2: la bandera (-u) y el valor (el nombre)
            ;;
        -p|--port)
            PORT="$2"
            shift 2 # Desplazamos 2: la bandera (-p) y el valor (el puerto)
            ;;
        -h|--help)
            echo "Uso: $0 [-u usuario] [-p puerto]"
            exit 0
            ;;
        *)
            echo "Opción desconocida: $1"
            exit 1
            ;;
    esac
done

echo "Configuración final:"
echo "Usuario: $USER"
echo "Puerto: $PORT"

Análisis de la ejecución:

Si ejecutás:
./config.sh -u admin -p 8080

1. En la primera iteración: $1 es -u. El script asigna $2 (admin) a USER y hace shift 2. Ahora, los argumentos restantes son -p 8080. El nuevo $1 es -p.
2. En la segunda iteración: $1 es -p. El script asigna $2 (8080) a PORT y hace shift 2. Ahora no quedan más argumentos ($# es 0).
3. El bucle termina.

Salida esperada:

Configuración final:
Usuario: admin
Puerto: 8080

Buenas prácticas y errores comunes

Para que tus scripts no se rompan en producción, tené en cuenta estos puntos:

1. Siempre usá comillas dobles

Nunca escribas $1 o $@ sin comillas si hay posibilidad de que el valor tenga espacios.

• Mal: echo $1 $
  ightarrow$ Si el argumento es "Mi Documento.txt", Bash lo verá como dos palabras separadas.
• Bien: echo "$1" $
  ightarrow$ Mantiene la integridad del string.

2. Validá la cantidad de argumentos

No asumas que el usuario sabe cómo usar tu script. Usá $# al principio para verificar que tenés los datos necesarios.

if [ $# -lt 2 ]; then
    echo "Error: Faltan argumentos obligatorios."
    exit 1
fi

3. Provee un menú de ayuda

Implementar la opción -h o --help es una señal de profesionalismo. Ayuda a otros desarrolladores (y a vos mismo en seis meses) a entender cómo funciona la herramienta sin leer todo el código.

4. Cuidado con el shift excesivo

Si hacés un shift cuando ya no quedan argumentos, no pasará nada catastrófico, pero podrías estar procesando variables vacías. Siempre chequeá que $# sea mayor a cero antes de entrar en el bucle de procesamiento.

Conclusión

Dominar los argumentos de Bash es el primer paso para crear herramientas de automatización reales. Pasamos desde lo más simple, como capturar un nombre con $1, hasta la implementación de un procesador de opciones dinámico usando shift y un bucle while.

Resumen rápido:

• $0: Nombre del script.
• $1...$n: Argumentos específicos por posición.
• $#: Cantidad de argumentos recibidos.
• $@: Todos los argumentos como una lista.
• shift: Desplaza los argumentos a la izquierda para procesarlos secuencialmente.

Próximos pasos:
Si ya te sentís cómodo con esto, te recomiendo investigar sobre getopts. Es una herramienta integrada en Bash diseñada específicamente para parsear opciones de una sola letra de manera más estandarizada. Sin embargo, entender el funcionamiento manual con shift te da un control total y una comprensión mucho más profunda de cómo opera la shell.

¡Ahora salí a automatizar todo lo que puedas!