Guiones de Bash: variables, códigos de salida y argumentos

Un guion del intérprete de comandos guarda una secuencia de comandos en un archivo de texto sin formato. Bash lee los comandos en orden, igual que lee los que introduces en un indicador de comandos. Un guion puede repetir una tarea sin que alguien escriba cada paso y te proporciona un único lugar donde corregirla o mejorarla.

Pon el intérprete en la primera línea

La línea de intérprete indica a Linux qué programa debe leer un guion ejecutable. Comienza un guion de Bash con #!/bin/bash. Los caracteres #! deben ser los dos primeros del archivo: no debe haber espacios ni una línea en blanco antes de ellos. Bash es Bourne Again Shell. Se usa ampliamente como intérprete de comandos interactivo en Linux y también lee archivos de guion.

Un intérprete es un programa que lee y ejecuta otro lenguaje. El mismo mecanismo permite que #!/usr/bin/python3 seleccione Python o que #!/usr/bin/awk -f seleccione awk. El resto de un guion de Bash debe contener comandos que Bash entienda.

Crea backup-notes.sh en un editor de texto sin formato como nano o vi:

#!/bin/bash
# Keep a copy of the notes and show the backup folder.
mkdir -p ~/backup
cp ~/notes.txt ~/backup/
ls -l ~/backup

Bash primero crea el directorio de destino, después copia las notas y luego lista el destino. mkdir -p también tiene éxito cuando el directorio ya existe, por lo que una ejecución posterior puede reutilizarlo. El archivo de origen ~/notes.txt debe existir para que la copia funcione. Guardar los comandos no crea ese archivo de origen.

Haz que las personas puedan leer el archivo

La segunda línea es un comentario. Fuera del texto protegido por comillas, # inicia un comentario al principio de una palabra; Bash ignora el resto de esa línea. Escribe comentarios sobre el propósito de un paso, por ejemplo por qué debe conservarse una copia de seguridad. Las líneas en blanco y la sangría facilitan la identificación de grupos de comandos. Mantén una sangría coherente a medida que añadas condiciones y bucles.

La terminación .sh ayuda a reconocer un guion del intérprete de comandos. Linux no exige esa terminación y añadirla no selecciona Bash ni concede permiso de ejecución. Un archivo llamado backup-notes puede ejecutar los mismos comandos.

Ajusta el intérprete al lenguaje

En Debian y Ubuntu, /bin/sh normalmente selecciona dash. Las funciones de Bash como [[ ... ]] fallan ahí. Un guion de Bash necesita un intérprete de Bash aunque algunos comandos sencillos funcionen en ambos intérpretes. Llamar a un archivo something.sh no corrige una línea de intérprete inadecuada.

Reconoce un problema de finales de línea

Los editores de Windows pueden guardar un retorno de carro antes de cada salto de línea. En Linux, ese carácter invisible puede pasar a formar parte de la ruta de la línea de intérprete. Un error como /bin/bash^M: bad interpreter: No such file or directory señala este problema, aunque /bin/bash exista.

Convierte el archivo a finales de línea de Unix con dos2unix backup-notes.sh y guarda los futuros guiones con finales de línea de Unix en el editor. Los comandos del archivo pueden ser correctos y, aun así, el carácter adicional impedir que Linux inicie su intérprete.

Bash puede leer un guion directamente o iniciarlo como programa. Estas formas difieren en los permisos que necesitan y en cómo se elige el intérprete. La ruta que escribes también determina si el intérprete de comandos busca un comando o usa un archivo concreto.

Dos formas de iniciar el mismo archivo

bash backup-notes.sh
chmod u+x backup-notes.sh
./backup-notes.sh

El primer comando inicia Bash y le pide que lea el archivo. El guion necesita permiso de lectura; no requiere su propio bit de ejecución. Bash trata la línea de intérprete como un comentario porque el intérprete ya se ha elegido.

El segundo comando añade permiso de ejecución para el propietario del archivo. En una cadena de permisos como -rwxr--r--, la x del propietario indica que es ejecutable. El tercer comando ejecuta el archivo como programa y usa su línea de intérprete. chmod +x también es habitual; si no se indica una clase de permisos, umask limita qué clases reciben permiso de ejecución. chmod u+x selecciona explícitamente al propietario.

Si ./backup-notes.sh informa «Permission denied», comprueba el permiso de ejecución y el acceso a la ruta. Que bash backup-notes.sh funcione no demuestra que la ejecución directa tenga los permisos necesarios.

Comprende la búsqueda de comandos

./ significa el directorio actual. Cuando un comando contiene una barra, Bash sigue esa ruta. Cuando escribes un nombre sin barra, Bash busca en los directorios de PATH. El directorio actual normalmente no está en esa lista, por lo que estar dentro del directorio de un guion no basta para ejecutarlo solo por su nombre.

echo "$PATH"
command -v backup-notes.sh
type backup-notes.sh

PATH es una lista separada por dos puntos, como /home/sam/.local/bin:/usr/local/bin:/usr/bin:/bin. Se usa el primer ejecutable que coincide. Los dos últimos comandos ayudan a identificar qué se ejecutará para un nombre, incluida una copia más antigua en otro lugar de PATH.

Para que un guion personal esté disponible por su nombre, colócalo en un directorio de tu PATH. Muchas distribuciones añaden ~/bin o ~/.local/bin al iniciar sesión si ese directorio existe; comprueba tu PATH real. /usr/local/bin es una ubicación habitual para guiones compartidos por los usuarios y requiere permisos de administrador para escribir en él.

Elige entre un intérprete hijo y el intérprete actual

Ejecutar ./settings.sh o bash settings.sh inicia un proceso hijo de Bash. Sus variables y cambios de directorio pertenecen a ese proceso hijo. Un guion que contiene cd /var/log no desplaza el terminal que lo inició. Cuando termina, sigues en el directorio original del terminal.

La ejecución de un archivo en el intérprete actual (sourcing) lee comandos en el intérprete actual:

source ./settings.sh
# Equivalent short form:
. ./settings.sh

Úsala para un archivo de configuración destinado a cambiar tu sesión. Esta forma de ejecución necesita permiso de lectura, no de ejecución, y la línea de intérprete no inicia un intérprete separado. Por tanto, ejecutar así un archivo de configuración de Bash presupone que el intérprete actual entiende la sintaxis de Bash.

Lee el resultado de una ejecución

Inmediatamente después de que termine un guion, echo $? muestra su estado de salida. Salvo que el guion use exit con un código elegido, su estado procede del último comando. Por tanto, un listado final correcto puede ocultar una copia que falló antes; las comprobaciones de errores que verás más adelante permitirán que el guion indique el resultado real de la tarea.

Una variable da un nombre a un valor para que el mismo guion pueda reutilizarlo. Las variables de Bash normalmente contienen texto, incluso cuando ese texto parece un número. Asignas el valor una vez y expandes el nombre dondequiera que un comando necesite ese valor.

Asigna sin espacios

city=Lisbon
greeting="Good morning"
echo "$greeting from $city"

La salida es «Good morning from Lisbon». No hay espacios alrededor del = de asignación. En city = Lisbon, Bash trata city como un comando y las demás palabras como argumentos. Las comillas alrededor de "Good morning" mantienen ambas palabras en un solo valor.

Usa letras, dígitos y guiones bajos en los nombres de variables, con una letra o un guion bajo al principio. Los nombres distinguen entre mayúsculas y minúsculas: file, File y FILE son distintos. Elige nombres en minúsculas como backup_dir para los valores propios de tu guion. Esto ayuda a evitar que se sustituyan variables de entorno como PATH o HOME. Establecer PATH=/data cambia la resolución de comandos y puede hacer que dejen de encontrarse comandos habituales.

Indica dónde termina un nombre

Un signo de dólar introduce una expansión. Las llaves muestran el límite cuando sigue más texto inmediatamente:

file=report
echo "${file}_old"

Esto muestra «report_old». Con "$file_old", Bash busca una variable llamada file_old, no file seguido de _old. Sin set -u, un nombre no establecido se expande a texto vacío. Por tanto, un error de escritura puede producir una ruta o un mensaje vacío sin un error inmediato.

Un valor como count=5 almacena el texto «5». Añadir texto junto a una expansión no calcula: echo "$count+1" muestra «5+1». La expansión aritmética da a los números una función diferente cuando se necesitan cálculos.

Lee una línea de entrada

read -r -p "Your name: " name
echo "Hello, $name"

read almacena la línea introducida en name. -p proporciona la indicación y -r conserva las barras invertidas. Con la entrada «Lee Kim», el saludo es «Hello, Lee Kim». Un guion ejecutado sin una persona presente necesita obtener su entrada de argumentos, archivos o valores predeterminados; una indicación no puede proporcionar de forma fiable un valor que falta.

Exporta valores para programas hijos

Una variable ordinaria del intérprete de comandos pertenece al intérprete donde se establece. La exportación la marca para incluirla en el entorno que se copia a los programas que inicia ese intérprete:

export BACKUP_DIR=/mnt/usb
bash backup-notes.sh

El proceso hijo de Bash puede ahora leer BACKUP_DIR. Si ese proceso hijo asigna otro valor, el proceso padre conserva el suyo. La herencia del entorno va del padre al hijo; no envía los cambios posteriores de vuelta al padre.

env o printenv muestra las variables de entorno. unset name elimina la variable llamada name; no asigna una cadena vacía. Con una expansión normal ambas pueden parecer vacías, pero una comprobación de variables no establecidas puede distinguir una variable ausente de una establecida.

Bash lee un comando antes de que el programa reciba sus argumentos. Los espacios separan palabras y caracteres como *, ?, $, ;, &, |, < y > tienen funciones especiales. La protección mediante comillas controla cuáles de esas funciones permanecen activas.

Elige qué debe expandirse

Con HOME=/home/sam, compara:

echo 'Home: $HOME *'
echo "Home: \$HOME *"

El primero muestra «Home: $HOME *». El segundo muestra «Home: /home/sam *». El asterisco permanece literal en ambos, pero solo las comillas dobles permiten que la variable se expanda. Una comilla simple no puede colocarse directamente dentro de una cadena protegida por comillas simples.

Dentro de comillas dobles, las barras invertidas pueden proteger un signo de dólar, un acento grave, una comilla doble o una barra invertida. Por ejemplo, echo "Price: \$5" muestra «Price: $5». Fuera de comillas, echo 5 \* 3 muestra «5 * 3» y touch my\ file.txt crea un archivo con un espacio en su nombre.

Sigue un valor sin comillas por Bash

file="my report.txt"
cp $file backup/

Primero Bash expande la variable. Después, la división en palabras divide su valor en espacios, tabulaciones y saltos de línea. El comando recibe my, report.txt y backup/ como argumentos separados. Intenta copiar dos archivos de origen en lugar del único archivo deseado.

Si una palabra resultante contiene caracteres comodín, la expansión de nombres de archivo la sustituye después por los nombres coincidentes. Un valor almacenado como *.txt puede convertirse en varios argumentos de archivo al expandirse sin comillas. Estos pasos adicionales ocurren antes de que comience cp; el programa no puede recuperar la agrupación que pretendías.

cp "$file" backup/

Ahora el valor expandido sigue siendo un argumento, «my report.txt». Bash elimina los propios caracteres de comillas; son instrucciones para el análisis, no parte de la ruta que se pasa a cp. Pon comillas dobles alrededor de las expansiones de variables y las sustituciones de comandos siempre que su valor completo deba permanecer unido.

Conserva un valor vacío

Las comillas también importan cuando un valor está vacío. En [ $answer = yes ], un answer vacío desaparece y deja una prueba no válida. [ "$answer" = yes ] pasa una cadena vacía como un argumento, por lo que la prueba es válida y falsa.

La misma regla de agrupación se aplica a palabras literales. mkdir new folder crea dos directorios, mientras que mkdir "new folder" crea uno. Proteger una ruta completa con comillas es útil tanto si su espacio se escribió directamente como si procede de una variable.

Combina texto literal y expandido

Las partes contiguas protegidas por comillas sin un espacio que las separe forman una sola palabra. Con price=8, echo 'Price: $'"$price" muestra «Price: $8». La parte fija está entre comillas simples y la parte variable entre comillas dobles. Un patrón de búsqueda también puede mantenerse fijo: grep 'cost: \$[0-9]' prices.txt pasa su patrón sin expansión por el intérprete de comandos y deja que grep lo interprete.

Los comandos suelen producir un valor que necesita otro paso. Bash puede capturar esa salida, colocarla dentro de un texto o usarla en un cálculo. La sustitución de comandos y la expansión aritmética tienen una puntuación similar, pero realizan tareas distintas.

Captura la salida estándar

today=$(date +%F)
cp notes.txt "notes-${today}.txt"

$(...) ejecuta un comando y sustituye la expresión por su salida estándar. El 2026-10-22, today contiene «2026-10-22» y la copia se llama notes-2026-10-22.txt. Una fecha en orden año-mes-día mantiene los nombres de archivo ordenados por fecha cuando se ordenan por nombre. También puedes poner la sustitución directamente en el nombre: "notes-$(date +%F).txt".

Los caracteres de salto de línea finales se eliminan de la salida capturada. La forma más antigua con acentos graves también captura la salida, pero $(...) es más fácil de leer y anidar. Protege con comillas una sustitución usada como argumento de un comando, como "$(date +%F)", para mantener unido su resultado.

La sustitución de comandos captura solo la salida estándar. Los errores enviados a la salida de error estándar siguen yendo a su destino habitual. result=$(some_command 2>&1) combina ambos flujos dentro de la captura cuando eso es lo que necesita el guion. Mezclar errores en un valor destinado a contener un número haría fallar los cálculos posteriores.

Captura un recuento sin nombre de archivo

lines=$(wc -l < access.log)
echo "Lines: $lines"

Si el archivo contiene 342 caracteres de salto de línea, wc proporciona el recuento 342. Al redirigir el archivo a wc, su salida contiene solo el recuento; wc -l access.log también muestra el nombre del archivo. Un resultado que parece numérico puede reutilizarse después, siempre que el comando haya tenido éxito.

Calcula con números enteros

$(( ... )) realiza una expansión aritmética:

echo "$(( 17 / 5 ))"
echo "$(( 17 % 5 ))"

Los resultados son 3 y 2. La división entera descarta el resto; % lo devuelve. La suma, la resta y la multiplicación usan +, - y *. Los nombres de variables pueden aparecer sin signo de dólar dentro de la expresión: total=$(( price * qty )).

Con a=5, echo "$a+3" muestra «5+3» como texto. echo "$(( a + 3 ))" calcula y muestra 8. Los paréntesis adicionales seleccionan la aritmética; $(a + 3) intentaría ejecutar un comando llamado a.

Un contador comienza con un valor como count=0 y se actualiza con count=$(( count + 1 )). Bash también ofrece (( count++ )); este es un comando aritmético con su propio estado de salida, que importa en guiones que usan opciones de tratamiento de errores.

Conserva la precisión necesaria

La aritmética de Bash usa números enteros. 7 / 2 da 3 y un valor decimal como 2.5 provoca un error de sintaxis aritmética. Una herramienta independiente puede calcular decimales:

echo "scale=2; 7 / 2" | bc

Esto produce 3.50. En la aritmética entera, multiplica antes de dividir cuando el producto conserve una fracción que aún necesitas. Para 45 de 60, $(( 45 * 100 / 60 )) da 75. Dividir primero da cero para 45 / 60, por lo que $(( 45 / 60 * 100 )) sigue siendo cero; la fracción perdida no puede recuperarse mediante una multiplicación posterior.

Un comando comunica su resultado de dos formas: puede mostrar texto y devuelve un estado de salida. Los programas usan ese estado para decidir qué ocurre después. Un guion puede mostrar un mensaje tranquilizador y aun así haber fallado, o no mostrar nada y tener éxito.

Lee un estado antes de que cambie

Un estado de salida es un número entero entre 0 y 255. Cero significa éxito. Un valor distinto de cero indica un fallo u otro resultado documentado. grep, por ejemplo, usa 0 para una coincidencia, 1 si no hay coincidencias y 2 para un error. Una búsqueda sin coincidencias puede ser un resultado normal para tu tarea aunque su estado sea distinto de cero.

$? contiene el estado del comando más reciente:

grep -q root /etc/passwd
status=$?
echo "Search status: $status"

La asignación guarda el resultado antes de que otro comando lo sustituya. En ls /missing; echo $?; echo $?, GNU ls devuelve 2 para la ruta inaccesible indicada en la línea de comandos. El primer echo muestra 2 y después termina correctamente. El segundo muestra 0, el estado de ese echo, no el del listado original.

Termina con un resultado útil

exit 1 termina inmediatamente un guion y comunica 1 a quien lo llamó. exit 0 comunica éxito. Un exit sin número usa el estado del comando anterior; llegar al final normalmente usa el estado del último comando. Elige códigos entre 0 y 255: exit 256 vuelve a 0 e indicaría incorrectamente que hubo éxito.

Algunos estados proceden del propio Bash:

Ctrl+C envía la señal 2, por lo que un comando terminado de esa forma suele comunicar 130. Los programas ordinarios también documentan sus propios códigos; 1 y 2 no tienen un significado universal para todas las herramientas.

Encadena comandos dependientes

mkdir -p ~/backup && cp notes.txt ~/backup/
cd /data/reports || exit 1

&& ejecuta el siguiente comando solo después de un éxito. Aquí la copia depende de crear o encontrar el directorio de copia de seguridad. || ejecuta el siguiente comando solo después de un fallo. Aquí, un cambio de directorio fallido detiene el guion antes de que los comandos posteriores usen el directorio de trabajo equivocado.

true devuelve 0; false devuelve 1. Un ! inicial invierte el éxito o el fallo de un comando. ! grep -q ERROR app.log tiene éxito cuando la búsqueda no encuentra ninguna línea coincidente, aunque también tiene éxito si grep falla con un error; usa comprobaciones explícitas del estado cuando debas distinguir esos resultados.

Comprueba una cadena de comandos completa

grep ERROR missing.log | wc -l

De forma predeterminada, una cadena de comandos conectados por tuberías tiene el estado de su último comando. grep falla porque falta el archivo, pero wc lee un flujo vacío, muestra 0 y tiene éxito. Por tanto, el estado de la cadena es 0.

set -o pipefail hace que una cadena falle cuando falle cualquiera de sus comandos. Devuelve el estado distinto de cero situado más a la derecha, o 0 si todos los comandos tienen éxito. Esto hace que los errores de los comandos anteriores sean visibles para if, &&, || y quien llamó al guion. Así, un programador de tareas puede distinguir un informe correcto de uno que nunca leyó su entrada.

Bash normalmente continúa después de que falle un comando. Si el siguiente comando depende de ese trabajo, continuar puede convertir un pequeño fallo en un problema mayor. Comprueba explícitamente los pasos de los que dependen otros y usa la comprobación de sintaxis y el trazado para averiguar por qué una ejecución se comporta de forma distinta a la prevista.

Detén el guion antes de que se propaguen los efectos de un fallo

cd /backups || exit 1

Ahora, los comandos posteriores solo pueden ejecutarse si el cambio de directorio tiene éxito. Esto importa antes de las operaciones con archivos: si falla un cambio de directorio y el guion continúa, las rutas relativas siguen apuntando al directorio anterior. Comprueba el destino antes de ejecutar comandos que modifiquen o eliminen archivos.

Un mensaje de error y un estado de fallo sirven a destinatarios distintos:

echo "Error: $file not found" >&2
exit 1

El mensaje va a la salida de error estándar, dejando la salida estándar disponible para los datos. Con ./report.sh > report.txt, el mensaje sigue siendo visible en el terminal mientras la salida normal entra en el archivo. El estado distinto de cero permite que otro programa detecte el error sin leer la frase.

Comprueba la sintaxis y después traza la ejecución

La ausencia de fi, done o una comilla de cierre es un problema de sintaxis. bash -n puede localizarlo, a menudo mediante un mensaje «unexpected end of file». Una ruta de archivo válida desde el punto de vista sintáctico, pero mal escrita, necesita una comprobación durante la ejecución.

El trazado antepone + a los comandos. Una línea como cp "$src" "$dest" revela las rutas reales que recibió. set -x y set +x activan y desactivan el trazado alrededor de una sección.

Comprende las opciones de tratamiento de errores

set -euo pipefail combina tres controles:

• -e termina el guion después de un fallo de comando no tratado.
• -u informa del uso de una variable no establecida como un error.
• pipefail hace que los comandos fallidos de una cadena conectada por tuberías afecten a su estado.

-e permite fallos esperados en las condiciones de if, while y until, en comandos negados y en comandos que no son los últimos de listas con && o ||. Sin pipefail, un fallo anterior al último comando de la cadena no provoca la salida. Las comprobaciones explícitas siguen siendo útiles porque indican qué debe hacer el guion cuando falla un paso concreto.

Un comando aritmético también comunica verdadero o falso. (( count++ )) devuelve el estado 1 cuando el valor anterior es 0, por lo que un uso no tratado con -e puede detener el guion aunque se haya producido el incremento. La asignación count=$(( count + 1 )) evita ese estado del comando aritmético.

-u detecta un error de escritura como $filname cuando solo se ha establecido filename. No rechaza una variable que existe pero está vacía. ${dir:?not set} comprueba si dir falta o está vacía en esa expansión. Un resultado esperado sin coincidencias puede gestionarse con una prueba; command || true suprime todos los fallos de ese comando, por lo que debes usarlo solo cuando todos esos fallos sean aceptables.

Lee los mensajes y limpia los archivos temporales

«Command not found» señala un problema con el nombre, el programa instalado o PATH. «Permission denied» señala un problema de ejecución o de acceso a un archivo. «Unary operator expected» suele deberse a un valor vacío sin comillas en [ ]; «integer expression expected» significa que una prueba numérica recibió texto.

Un manejador de eventos EXIT establece una limpieza, por ejemplo trap 'rm -f "$tmpfile"' EXIT, después de asignar tmpfile. El comando entre comillas se ejecuta cuando Bash termina, incluso con un exit explícito o una salida por error con -e. ShellCheck también puede inspeccionar guiones en busca de errores habituales de protección mediante comillas y de lógica antes de ejecutarlos.

Una condición en Bash es un comando cuyo estado significa verdadero o falso. Las pruebas permiten hacer preguntas sobre rutas, texto y números. Elige un operador para el tipo de valor que tienes; los mismos caracteres mostrados pueden tener distintos significados como texto y como número.

Separa los elementos de la prueba

test -f notes.txt y [ -f notes.txt ] preguntan si una ruta apunta a un archivo regular existente. [ es un comando y su último argumento debe ser ]. Los espacios separan sus argumentos:

[ -f "$file" ]

Sin el espacio después de [, Bash puede buscar un comando llamado [-f. En [ "$a"="$b" ], la falta de espacios alrededor de = forma una sola palabra no vacía, cuya prueba da verdadero aunque los valores sean distintos. Los operadores deben ser argumentos separados.

Elige una prueba de archivo

Para un directorio llamado logs, -e y -d tienen éxito, mientras que -f falla. Las pruebas de archivos normalmente siguen un enlace simbólico hasta su destino; -L comprueba el propio enlace. Por tanto, un enlace roto puede satisfacer -L y fallar en -e.

Compara texto o números enteros

Las pruebas de cadenas usan = y != para comprobar la igualdad y la desigualdad. -z comprueba si la longitud es cero y -n si es distinta de cero. [ "$answer" = yes ] coincide exactamente con «yes»; «Yes» y «yes » son textos distintos. Las comillas dobles mantienen un valor vacío en la prueba.

Las comparaciones de enteros usan -eq, -ne, -lt, -le, -gt y -ge: igual, distinto, menor que, menor o igual que, mayor que y mayor o igual que. [ "$count" -gt 100 ] pregunta si el número supera 100.

[ 07 -eq 7 ]
[ 07 = 7 ]

La comparación numérica tiene éxito porque los valores son iguales. La comparación de cadenas falla porque uno de los textos empieza con un cero adicional.

No uses > sin protección para una prueba numérica dentro de [ ]. En [ 10 > 9 ], Bash redirige la salida a un archivo llamado 9 y comprueba la palabra no vacía que queda. En [[ 10 < 9 ]] de Bash, el operador compara cadenas, por lo que el carácter inicial 1 se ordena antes que 9. Usa -lt o -gt para comparaciones numéricas, o aritmética de Bash como (( count > 100 )).

Combina condiciones

[ ! -d "$dir" ] tiene éxito cuando la ruta no es un directorio existente; puede ser un archivo regular o no existir. [ -f "$f" ] && [ -r "$f" ] tiene éxito solo cuando ambas pruebas tienen éxito. Las pruebas separadas y unidas por || tienen éxito cuando al menos una lo tiene.

Bash también tiene la palabra clave condicional [[ ... ]]. Evita la división en palabras de sus expansiones de variables y permite && y || en su interior. Un patrón sin comillas a la derecha de == busca coincidencias con el patrón: [[ $file == *.log ]] coincide con «app.log». Proteger ese patrón con comillas haría que se tratara literalmente. Esta sintaxis necesita Bash; dash no la implementa.

Las condiciones resultan útiles cuando seleccionan acciones. Un bloque if elige una rama a partir de los resultados de comandos. Un bloque case selecciona una rama comparando un valor con patrones. Ambos muestran las acciones disponibles en el guion.

Deja que un comando elija una rama

if grep -q ERROR app.log; then
  echo "Errors found"
else
  echo "No successful match"
fi

if ejecuta el comando y entra en la primera rama cuando devuelve 0. En caso contrario, entra en else. La propia búsqueda es la condición; no es necesario ejecutarla, mostrar algo y después examinar $?. Un error de grep también produce un valor distinto de cero, por lo que este ejemplo describe la rama else como ausencia de una coincidencia satisfactoria, no como prueba de que el archivo no contiene errores.

then debe comenzar un comando nuevo: colócalo en la línea siguiente o después de un punto y coma. fi cierra el bloque. La falta de fi suele producir un error de sintaxis al final del archivo porque Bash sigue esperando que se cierre el bloque.

Ordena las condiciones que se solapan

elif añade una prueba que se ejecuta solo cuando han fallado las pruebas anteriores. Para un porcentaje entero de uso del disco:

if [ "$usage" -ge 90 ]; then
  echo "CRITICAL: disk ${usage}% full"
elif [ "$usage" -ge 75 ]; then
  echo "WARNING: disk ${usage}% full"
else
  echo "OK: disk ${usage}% full"
fi

Con usage=82, la primera prueba falla y la segunda tiene éxito, lo que produce «WARNING: disk 82% full». Con 95, se ejecuta la primera rama y se omite la rama de advertencia. Si la prueba de 75 fuera primero, 95 coincidiría con ella y nunca llegaría a la prueba crítica. Ordena los rangos que se solapan de modo que se compruebe la condición más restrictiva.

Solo se ejecuta la primera rama cuya prueba tiene éxito. else no necesita condición y se ocupa de los casos restantes. Se puede omitir elif o else cuando la tarea no lo necesite.

Compara un valor con case

case "$1" in
  start) echo "Starting" ;;
  stop) echo "Stopping" ;;
  y|Y|yes) echo "Confirmed" ;;
  *) echo "Usage: $0 start|stop|y|Y|yes" >&2; exit 2 ;;
esac

Cada patrón termina con ), cada rama termina con ;; y esac cierra el bloque. El | dentro de un patrón ofrece alternativas. El * final es el patrón de coincidencia universal y debe ir al final porque coincide con cualquier valor.

case usa patrones de nombres de archivo, no expresiones regulares. *.jpg coincide con un valor que termina en .jpg. [0-9]* coincide con un valor cuyo primer carácter es un dígito; el * puede coincidir después con cualquier texto, por lo que también coincide con «7draft». No demuestra que todo el valor contenga solo dígitos.

Elige la estructura adecuada

Usa case cuando una entrada, como un subcomando o una respuesta, tenga varias formas identificadas. Usa if cuando las condiciones examinen cosas distintas, como si existe un archivo y si un recuento supera un límite. Una coincidencia con un patrón se refiere a los caracteres de un valor; una prueba de archivo se refiere a la ruta en el disco. Un nombre terminado en .log puede coincidir con un patrón aunque no exista ningún archivo con ese nombre.

Un bucle for proporciona un nuevo valor al mismo cuerpo de comandos en cada iteración. La lista puede contener palabras literales, nombres de archivo coincidentes, un rango de números o los argumentos del guion. Bash asigna un elemento de la lista a la variable del bucle antes de ejecutar el cuerpo.

Recorre una lista fija

for host in web1 web2 db1; do
  echo "Checking $host"
done

La primera iteración tiene host=web1, la segunda host=web2 y la tercera host=db1. El bucle muestra tres líneas. do abre el cuerpo y done lo cierra. La variable sigue disponible después del bucle y contiene el último valor asignado.

Un bucle también puede acumular un resultado:

total=0
for n in 4 8 15; do
  total=$(( total + n ))
done
echo "$total"

El total almacenado cambia de 0 a 4, después a 12 y luego a 27. Inicializa el total antes del bucle para que la primera suma tenga un valor inicial definido.

Recorre los archivos coincidentes

for f in *.log; do
  [ -f "$f" ] || continue
  gzip -- "$f"
done

Bash expande el patrón en nombres coincidentes antes de ejecutar el cuerpo del bucle. Cada nombre de archivo coincidente sigue siendo un elemento de la lista, incluso si contiene espacios. Proteger "$f" con comillas dentro del cuerpo mantiene unido ese elemento cuando se pasa a gzip. Aquí, la prueba de archivo regular también omite los directorios cuyo nombre termina en .log.

Con la configuración predeterminada de expansión de nombres de archivo de Bash, un *.log sin coincidencias permanece literal. Un bucle sin una comprobación se ejecutaría una vez sobre los caracteres *.log y el comando fallaría. [ -e "$f" ] || continue omite las rutas inexistentes; usa -f cuando solo quieras archivos regulares.

No construyas un bucle de nombres de archivo a partir de $(ls). Su salida es texto, por lo que la división en palabras puede convertir «my report.txt» en dos elementos de la lista. Un patrón de nombres de archivo ya proporciona los nombres con sus límites intactos.

Crea un nombre nuevo a partir de cada nombre anterior

for f in *.jpeg; do
  [ -f "$f" ] || continue
  mv -- "$f" "${f%.jpeg}.jpg"
done

${f%.jpeg} elimina la terminación .jpeg del valor. Para «beach day.jpeg», el destino pasa a ser «beach day.jpg». Los dos argumentos protegidos con comillas mantienen intactas ambas rutas. -- indica a mv que los argumentos posteriores son nombres, incluso si uno empieza por -. Usa un directorio de destino sin nombres que entren en conflicto al probar el ejemplo, ya que mv puede reemplazar un destino existente.

Recorre un rango contando

for i in {1..5} proporciona del 1 al 5. Bash expande las llaves antes de expandir las variables, por lo que {1..$n} no produce un rango de longitud variable. Para un límite almacenado, usa la forma aritmética:

for (( i = 1; i <= n; i++ )); do
  echo "$i"
done

La primera expresión inicializa el contador, la del medio lo comprueba antes de cada iteración y la última lo actualiza. for i in $(seq 1 "$n") también produce una lista de números para un límite entero positivo adecuado. La sustitución sin comillas es deliberada y proporciona números separados.

Para los argumentos, for arg in "$@" proporciona un elemento por cada argumento original. La forma más corta for arg; do significa lo mismo y también conserva los espacios dentro de cada argumento.

Algunas repeticiones terminan cuando cambia una condición, no cuando se agota una lista. while y until comprueban la condición antes de cada iteración. El cuerpo de while se ejecuta mientras su condición tiene éxito; el de until se ejecuta mientras su condición falla. Cualquiera de los dos bucles puede ejecutarse cero veces.

Actualiza aquello de lo que depende la condición

i=1
while [ "$i" -le 3 ]; do
  echo "Attempt $i"
  i=$(( i + 1 ))
done

La condición primero encuentra 1, después 2 y luego 3. El cuerpo muestra esos tres números de intento y aumenta el contador cada vez. Después de actualizarlo a 4, la siguiente prueba falla y el bucle termina. Si faltara la actualización, i permanecería en 1 y el bucle seguiría ejecutándose. Ctrl+C detiene un bucle que se ejecuta en primer plano.

Para esperar a un archivo:

until [ -f /tmp/export.done ]; do
  sleep 5
done

Si el archivo ya existe, el cuerpo del bucle nunca se ejecuta. En caso contrario, sleep 5 hace una pausa de cinco segundos antes de la siguiente comprobación. Una pausa evita que el bucle compruebe continuamente y desperdicie tiempo de procesador.

Lee los registros como líneas

while IFS= read -r line; do
  echo "Host: $line"
done < hosts.txt

read proporciona una línea en cada iteración y devuelve un estado de fallo al final del archivo. IFS= conserva los espacios al principio y al final de la línea; -r conserva las barras invertidas. La redirección de entrada después de done proporciona datos a todo el bucle, no solo a su último comando.

Una línea como «web1 production» permanece como un solo valor. for line in $(cat hosts.txt) dividiría en espacios, tabulaciones y saltos de línea, tratando esas dos palabras como iteraciones separadas. Esa forma no puede conservar registros arbitrarios basados en líneas.

Conserva los cambios después del bucle

Una tubería que envía datos a un bucle, como cat hosts.txt | while read -r line; do ...; done, normalmente ejecuta el bucle en un proceso hijo en Bash. Un contador modificado allí se pierde para el proceso padre cuando termina el hijo. Redirige el archivo al bucle cuando los comandos posteriores necesiten sus valores acumulados:

count=0
while IFS= read -r line; do
  count=$(( count + 1 ))
done < hosts.txt
echo "$count"

Esto procesa las líneas terminadas en un salto de línea y conserva el recuento actualizado en el intérprete de comandos actual. Ninguna cadena de comandos crea un proceso hijo para el bucle.

Gestiona el último registro y las salidas anticipadas

Un archivo puede terminar con texto pero sin un salto de línea final. read almacena ese último texto, pero indica un fallo, por lo que un while read simple no entra en su cuerpo para ese registro. Añade una segunda prueba para aceptar el texto no vacío almacenado:

while IFS= read -r line || [ -n "$line" ]; do
  echo "Host: $line"
done < hosts.txt

break sale del bucle inmediatamente. continue omite los comandos restantes de la iteración actual y vuelve a comprobar la condición para la siguiente. Por tanto, un bucle while true necesita un break, un exit o una señal para terminar; puede servir para un menú que sale del bucle cuando la entrada es «q». En un bucle con contador, coloca una actualización antes de cualquier continue que de otro modo la omitiría, o esa iteración podría repetirse indefinidamente.

Los argumentos convierten un guion con entrada fija en un comando reutilizable. Bash coloca las palabras que siguen al nombre del guion en parámetros posicionales. Sus límites los establece el intérprete de comandos que hace la llamada, por lo que las comillas importan tanto al llamar al guion como cuando este usa esos valores.

Identifica los parámetros

./backup.sh /home/sam/docs /mnt/usb

Dentro del guion, $0 es ./backup.sh, $1 es /home/sam/docs y $2 es /mnt/usb. $# es 2, el número de argumentos. El guion puede usar cp -r "$1" "$2" para copiar el directorio de origen al destino sin fijar ninguna de las dos rutas en el código.

$0 describe el nombre usado para iniciar el guion; no se cuenta en $#. Con ./greet.sh Ana "Lee Kim", el primer argumento es «Ana» y el segundo es «Lee Kim». Sin las comillas alrededor del segundo nombre, el guion recibiría tres argumentos.

Usa llaves después del noveno argumento

De $1 a $9 se nombran los primeros nueve parámetros posicionales. El décimo necesita ${10} y las posiciones posteriores siguen la misma forma. $10 significa la expansión de $1 seguida del carácter literal 0. Si el primer argumento es «Ana», $10 se convierte en «Ana0» incluso cuando existe un décimo argumento.

Un parámetro omitido se expande a texto vacío con la configuración normal. Con dos argumentos, falta $3; con set -u, expandirlo provoca un error de variable no establecida. Comprueba el número antes de leer las posiciones obligatorias o usa una expansión que proporcione un valor predeterminado.

Conserva todos los límites de los argumentos

Supón que un guion recibe "a b" y c. Compara:

"$@" es la opción habitual para pasar argumentos a otro comando:

for arg in "$@"; do
  echo "Argument: $arg"
done

El bucle se ejecuta dos veces para esa llamada, una por cada argumento original. Sin argumentos se ejecuta cero veces. Poner "$@" entre comillas dobles tiene un significado especial: cada parámetro posicional sigue siendo una palabra separada, por lo que las comillas no unen toda la lista en una palabra.

"$*" une los valores usando el primer carácter de IFS, que normalmente es un espacio. Esto puede ser útil para una sola cadena destinada a mostrarse, pero pierde los límites individuales que puede necesitar un comando posterior.

Procesa parámetros con shift

shift elimina el primer parámetro posicional, desplaza los posteriores y reduce $#. En la llamada de copia de seguridad, un desplazamiento hace que $1 pase a ser /mnt/usb y que el recuento pase a ser 1. shift 2 elimina los dos primeros parámetros a la vez.

Esto permite crear un bucle que examine $1, lo procese y después desplace los parámetros antes de la siguiente iteración. Comprueba que queden argumentos con [ "$#" -gt 0 ]; de lo contrario, el guion puede leer un valor ausente o intentar desplazar más argumentos de los disponibles. El desplazamiento no cambia $0 ni puede cambiar la lista de argumentos del intérprete de comandos padre que inició el guion.

Un guion debe asegurarse de que su entrada sea válida antes de empezar a trabajar. Comprueba el número de argumentos y después su significado. Las entradas opcionales pueden tener valores predeterminados; las entradas obligatorias ausentes necesitan un mensaje de diagnóstico claro y un estado de salida distinto de cero.

Explica la llamada esperada

if [ "$#" -ne 2 ]; then
  echo "Usage: $0 SOURCE DEST" >&2
  exit 2
fi

Esto comprueba el número antes de expandir $1 o $2, por lo que también funciona con set -u. El mensaje de uso va a la salida de error estándar. Las mayúsculas nombran valores que proporciona el usuario, [DEST] indicaría un destino opcional y FILE... significa uno o más argumentos de archivo. Una opción de ayuda como -h normalmente muestra las instrucciones de uso y termina con 0 porque pedir ayuda es un uso correcto.

El número de argumentos por sí solo no puede indicar si un origen es válido. [ -d "$1" ] comprueba si existe un directorio. Una prueba de archivo regular puede seleccionar archivos, pero la operación en sí sigue necesitando una comprobación del resultado: los permisos u otros errores pueden impedir la lectura.

Usa un valor predeterminado o exige un valor

logdir=${1:-/var/log}
src=${1:?Usage: backup.sh SOURCE [DEST]}

La primera forma usa /var/log cuando el primer parámetro falta o está vacío. La segunda detiene un guion no interactivo en cualquiera de los dos casos y muestra su mensaje en la salida de error estándar. Los dos puntos forman parte de ambas formas. Un valor predeterminado se usa para esta expansión; ${1:-...} no añade un argumento a la lista de parámetros posicionales.

Registra un fallo parcial

Un guion que cuenta líneas en archivos puede continuar después de una entrada incorrecta y aun así comunicar que la tarea completa quedó incompleta:

#!/bin/bash
if [ "$#" -eq 0 ]; then
  echo "Usage: $0 FILE..." >&2
  exit 2
fi
status=0
for f in "$@"; do
  if [ -f "$f" ]; then
    if lines=$(wc -l < "$f"); then
      echo "$f: $lines lines"
    else
      echo "$f: could not count lines" >&2
      status=1
    fi
  else
    echo "$f: not a regular file" >&2
    status=1
  fi
done
exit "$status"

Para notes.txt missing.txt, el guion muestra el recuento del archivo legible e informa del archivo ausente y después termina con 1. La asignación se comprueba directamente, por lo que un fallo de lectura no se convierte en un recuento vacío considerado correcto. Un éxito posterior nunca restablece a 0 el indicador de fallo almacenado.

Gestiona opciones sencillas antes de los nombres de archivo

verbose=0
while [ "$#" -gt 0 ]; do
  case "$1" in
    -v) verbose=1; shift ;;
    -h) echo "Usage: $0 [-v] FILE..."; exit 0 ;;
    --) shift; break ;;
    -*) echo "Unknown option: $1" >&2; exit 2 ;;
    *) break ;;
  esac
done

Cada opción reconocida se procesa y elimina con shift. El primer argumento ordinario termina el análisis de opciones; -- también lo termina y se elimina. El "$@" restante contiene los nombres de archivo, incluido un nombre que empiece por - después de --. getopts de Bash admite un análisis más completo de opciones cortas.

Un guion sin supervisión necesita obtener todas las entradas obligatorias de argumentos, valores predeterminados o configuración. read puede quedar bloqueado esperando un terminal o fallar inmediatamente al llegar al fin de archivo. Sustituir un argumento ausente por una indicación dejaría a una tarea programada sin una forma fiable de continuar.

Cron inicia comandos a las horas que coinciden con la programación. La tabla de cron de cada usuario guarda su programación y las tareas se ejecutan con su identidad. Un guion programado necesita tanto una expresión de tiempo correcta como un entorno que proporcione sus rutas, entradas y destino de salida.

Lee los cinco campos

Usa crontab -e para editar tu tabla y crontab -l para inspeccionarla. crontab -r elimina toda la tabla sin preguntar; usa el editor para eliminar una sola tarea.

30 2 * * * /home/sam/bin/backup.sh

Esto se ejecuta todos los días a las 02:30. Los asteriscos aceptan todos los valores de un campo. 0 9 * * 1-5 selecciona las 09:00 de lunes a viernes y 0 0 1 * * selecciona la medianoche del primer día de cada mes. Las horas usan la zona horaria del sistema salvo que la configuración de cron especifique otra zona admitida.

Combina rangos, listas e incrementos

Una coma enumera valores: 1,15 en el campo del día del mes selecciona el primero y el decimoquinto. Un guion indica un rango y / introduce un incremento. */15 en el campo de minutos selecciona 0, 15, 30 y 45.

*/20 8-10 * * * selecciona tres minutos en cada una de tres horas: nueve ejecuciones diarias, que comienzan a las 08:00 y terminan a las 10:40. Los incrementos vuelven a empezar dentro de su campo. */45 se ejecuta en el minuto 0 y el minuto 45 de cada hora; el intervalo hasta el minuto 0 de la hora siguiente es de solo 15 minutos.

Cuando tanto el día del mes como el día de la semana están restringidos, basta con que coincida cualquiera de los dos. 0 12 13 * 5 selecciona el mediodía del día 13 y de los viernes, no solo el viernes 13. Los demás campos también deben coincidir.

Las cadenas especiales sustituyen los cinco campos: @hourly, @daily, @weekly, @monthly, @yearly y @reboot. @daily significa medianoche, mientras que @reboot se ejecuta una vez al arrancar.

Proporciona rutas y conserva la salida

Cron normalmente usa /bin/sh para su línea de comandos, un PATH corto y ningún ajuste de inicio del intérprete de comandos interactivo. La propia línea de intérprete de Bash de un guion ejecutable sigue seleccionando Bash. Usa rutas absolutas para el guion y sus archivos, o establece PATH al principio de la tabla de cron.

30 2 * * * /home/sam/bin/backup.sh >> /home/sam/backup.log 2>&1

La tarea añade ambos flujos de salida al final del registro. Sin redirección, cron envía la salida por correo cuando está configurado, incluso mediante MAILTO; de lo contrario, la salida puede perderse. Un signo de porcentaje tiene una función especial en un comando de crontab: inicia un salto de línea y la entrada posterior. Escapa un formato de fecha en ese contexto, como en date +\%F. Un comando de fecha dentro de un guion separado usa el %F ordinario.

Distingue las programaciones del sistema y las tareas pendientes

/etc/crontab y los archivos de /etc/cron.d/ añaden un campo de usuario después de los cinco campos de tiempo. Por ejemplo, 30 2 * * * root /usr/local/bin/backup.sh se ejecuta como superusuario. No añadas ese campo de usuario a una tabla de cron personal.

Muchas distribuciones también ejecutan los archivos ejecutables que cumplen los requisitos en /etc/cron.daily/, /etc/cron.weekly/ y /etc/cron.monthly/. Las reglas predeterminadas de nombres de run-parts en Debian omiten los nombres que contienen puntos, así que usa allí backup-notes, no backup-notes.sh. Cron pierde las ejecuciones cuya hora pasa mientras el equipo está apagado. Anacron puede ejecutar tareas periódicas diarias, semanales o mensuales pendientes después del arranque.

Systemd separa el trabajo de su programación. Una unidad de servicio describe el comando que se debe ejecutar. Una unidad de temporizador describe cuándo iniciarlo. De forma predeterminada, backup.timer activa backup.service, usando el nombre base compartido para conectar ambos.

Escribe el servicio y la programación de calendario

Coloca estas unidades del sistema en /etc/systemd/system/:

# backup.service
[Unit]
Description=Nightly backup

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

Type=oneshot es adecuado para un guion que se ejecuta una vez y termina. Usa una ruta absoluta para el comando y haz que el guion sea ejecutable con una línea de intérprete de Bash. El temporizador proporciona la programación:

# backup.timer
[Unit]
Description=Run backup.service daily at 02:30

[Timer]
OnCalendar=*-*-* 02:30:00
Persistent=true

[Install]
WantedBy=timers.target

OnCalendar busca coincidencias con fechas y horas del reloj. Aquí, la fecha con comodines acepta todos los días. Persistent=true permite recuperar tareas pendientes después de que el temporizador haya estado inactivo: si se perdió al menos una ejecución de calendario, inicia el servicio una vez al reactivarse. No repite cada ejecución perdida.

Carga y activa el temporizador

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer

Recarga las definiciones después de crear o cambiar archivos de unidad. enable --now inicia el temporizador inmediatamente y lo habilita para futuros arranques. Habilitar solo el servicio no crea una programación. Prueba el trabajo por separado con sudo systemctl start backup.service.

Elige entre hora del reloj y tiempo transcurrido

Las expresiones de calendario pueden usar daily para la medianoche de cada día o weekly para el lunes a medianoche. Comprueba una expresión con systemd-analyze calendar "Mon..Fri 09:00" para ver su interpretación y su próxima ocurrencia.

Los dos últimos ajustes son temporizadores monotónicos: miden el tiempo transcurrido desde un evento. Combínalos para una primera ejecución después del arranque y activaciones posteriores cada hora. Persistent=true se aplica a los temporizadores de calendario; no añade la recuperación de ejecuciones de calendario a los temporizadores monotónicos.

Inspecciona por separado la programación y los resultados

systemctl list-timers muestra las próximas y las últimas activaciones. systemctl status backup.service muestra el resultado del servicio y journalctl -u backup.service muestra su salida y sus errores. Una próxima ejecución en la lista demuestra que una programación está activa, no que la tarea anterior del guion haya tenido éxito.

Los temporizadores tienen un margen de activación. AccuracySec tiene un valor predeterminado de un minuto; AccuracySec=1s reduce el margen de agrupación. RandomizedDelaySec añade deliberadamente un retraso aleatorio para distribuir el trabajo entre máquinas. Estos ajustes no garantizan un segundo de inicio exacto cuando hay carga.

Ejecuta un temporizador propio de usuario

Los archivos de unidad de usuario se guardan en ~/.config/systemd/user/ y los comandos usan systemctl --user, incluidos daemon-reload, enable --now y list-timers. Un gestor de usuario normalmente se ejecuta con la sesión de ese usuario. Un administrador puede habilitar la persistencia del gestor de usuario sin sesión abierta con loginctl enable-linger username para mantenerlo disponible sin iniciar sesión.

Cron necesita una línea de tiempo compacta y funciona sin systemd. Los temporizadores añaden un resultado de servicio y un registro, recuperación de ejecuciones de calendario y más control. Ninguno carga normalmente ~/.bashrc; ambos necesitan guiones que funcionen con rutas explícitas y sin indicaciones interactivas.