Variables, comillas y exit codes en shell: bash vs zsh
Variables, comillas, $?, set -euo pipefail, bucles y funciones en bash 3.2 y zsh 5.9: errores reales y los casos que el modo estricto deja pasar.
Serie: curso de línea de comandos 4/6 (intermedio). Para quien ya se mueve por la terminal y encadena comandos con pipes, y ahora quiere convertir esos comandos en un script que falle haciendo ruido en lugar de hacer lo incorrecto en silencio.
Si alguna vez escribiste un script de shell que funcionaba en tu terminal y después borró el archivo equivocado, generó un reporte vacío o "terminó bien" con exit code 0 sin hacer nada, este curso es para ti: le pasa al freelancer que automatiza los respaldos de un cliente, a quien arma el script de deploy en su primer trabajo y al estudiante que entrega una práctica de sistemas operativos. La mayoría de esos bugs vienen de tres cosas: cómo se expanden las variables, qué contiene de verdad $? y qué no atrapa set -euo pipefail. Ejecutamos cada fragmento de abajo en las dos shells que trae una Mac, porque un script que pruebas en zsh y luego corres con bash puede comportarse distinto en la misma línea.
Entorno: macOS 26 en una Mac con Apple Silicon (M1 Pro), zsh 5.9 y GNU bash 3.2.57 (el /bin/bash que trae Apple). Los archivos se crearon en una carpeta de pruebas que mostramos como ~/demo/ws. Las distribuciones Linux traen bash 5.x; donde eso cambia el resultado, lo decimos y lo marcamos como "no ejecutado aquí".
¿Recién llegas a la serie? Empieza por la ruta de aprendizaje de programación. El curso anterior, find, xargs, sed y awk, es de donde salieron los one-liners; este los envuelve en scripts.
Variables: sin espacios alrededor del =
Una variable de shell es solo un nombre que guarda un string. Se asigna con name=value y se lee con $name. La primera trampa es la que casi todo el mundo pisa el primer día:
# t1.sh
name = demo
echo "exit: $?"
name=demo
echo "hello $name"
echo 'hello $name'
echo "file: ${name}_log.txt / $name_log.txt"
## bash
t1.sh: line 1: name: command not found
exit: 127
hello demo
hello $name
file: demo_log.txt / .txt
## zsh
t1.sh:1: command not found: name
exit: 127
hello demo
hello $name
file: demo_log.txt / .txt
Con espacios, la shell lee name = demo como "ejecuta el comando name con dos argumentos, = y demo". Ese comando no existe, así que obtienes el exit code 127. Tres lecciones más en cinco líneas:
- Las comillas dobles expanden variables; las comillas simples dejan el texto tal cual (
'hello $name'). $name_loges otra variable (name_log, que está vacía). Usa llaves:${name}_log.txt.- Una variable vacía no es un error por defecto. El script imprimió
.txty siguió. Lo arreglamos más abajo conset -u.
Comillas: la diferencia entre bash y zsh que tienes que ver una vez
Esta es la línea que hace que la gente diga "en mi computadora funciona". Existen dos archivos: my report.txt y other.txt.
# split.sh
f="my report.txt"
ls $f
echo "rc=$?"
ls "$f"
list="a b c"
for x in $list; do echo "item: $x"; done
arr=(one two three)
echo "first=${arr[1]} count=${#arr[@]}"
pat="*.txt"
echo $pat
## bash
ls: my: No such file or directory
ls: report.txt: No such file or directory
rc=1
my report.txt
item: a
item: b
item: c
first=two count=3
my report.txt other.txt
## zsh
my report.txt
rc=0
my report.txt
item: a b c
first=one count=3
*.txt
Cuatro diferencias en una sola pantalla:
- Separación de palabras (word splitting). bash separa en los espacios un
$fsin comillas, así quelsrecibió dos argumentos,myyreport.txt. zsh no separa por defecto las variables sin comillas. - Globbing. bash expandió el
*.txtde la variable a nombres de archivo; zsh lo imprimió literal. - Bucles sobre un string.
for x in $listdio tres elementos en bash y uno en zsh. Si quieres una lista, usa un array:for x in "${arr[@]}". - Índices de arrays. Los arrays de bash empiezan en 0 (
${arr[1]}estwo); los de zsh empiezan en 1 (one).
Cuando corrimos el mismo archivo con zsh -c 'emulate sh; source ./split.sh', zsh se comportó exactamente como bash. O sea, decide la shell que ejecuta el script, no aquella en la que lo escribiste. La línea #!/bin/bash al inicio del archivo importa.
La regla que elimina todo esto: pon comillas en cada expansión ("$f", "${arr[@]}", "$@") y usa arrays para las listas. Así bash y zsh dan la misma respuesta.
La misma regla vale para los argumentos de funciones. $* y $@ se parecen, pero no son lo mismo:
# args.sh
count_args() { echo "$# args"; }
show() {
count_args $*
count_args "$*"
count_args "$@"
}
show "my report.txt" other.txt
## bash ## zsh
3 args 2 args
1 args 1 args
2 args 2 args
Solo "$@" pasa los dos argumentos intactos en ambas shells.
Exit codes y $?
Todo comando termina con un exit code (código de salida), un número de 0 a 255. Cero significa éxito; cualquier otro valor, algún tipo de falla. $? guarda el exit code del último comando, así que léelo enseguida, antes de ejecutar cualquier otra cosa (incluso echo lo reinicia).
# codes.sh
true; echo "true -> $?"
false; echo "false -> $?"
ls nope.txt; echo "ls missing -> $?"
grep -q zzz other.txt; echo "grep no match -> $?"
grep -q zzz nope.txt; echo "grep missing file -> $?"
nosuchcmd; echo "unknown command -> $?"
printf 'echo hi\n' > noexec.sh; ./noexec.sh; echo "not executable -> $?"
sh -c 'exit 300'; echo "exit 300 -> $?"
true -> 0
false -> 1
ls: nope.txt: No such file or directory
ls missing -> 1
grep no match -> 1
grep: nope.txt: No such file or directory
grep missing file -> 2
codes.sh: line 6: nosuchcmd: command not found
unknown command -> 127
codes.sh: line 7: ./noexec.sh: Permission denied
not executable -> 126
exit 300 -> 44
Los números fueron idénticos en bash y zsh (solo cambia el formato del mensaje: zsh imprime command not found: nosuchcmd y permission denied: ./noexec.sh). Lo que vale la pena recordar:
| Código | Significado | Visto aquí |
|---|---|---|
| 0 | éxito | true |
| 1 | falla general / "no" | false, ls sobre un archivo que no existe, grep sin coincidencias |
| 2 | mal uso o un error real (depende de la herramienta) | grep sobre un archivo que no existe |
| 126 | encontrado pero no ejecutable | ./noexec.sh sin chmod +x |
| 127 | comando no encontrado | error de tipeo o problema con el PATH |
| 128+N | terminado por la señal N | ver el curso 5 (130, 137, 143) |
Dos sorpresas: grep devuelve 1 cuando no hay coincidencias, lo cual no es un error, y solo 2 significa que falló de verdad. Y los exit codes dan la vuelta en 256: exit 300 llegó como 44 (300 − 256). Nunca uses exit codes por encima de 125 para tus propios errores.
set -euo pipefail: lo que sí atrapa
Por defecto, un script de shell sigue adelante después de una falla. Este archivo tiene tres bugs y aun así termina con 0:
# strict1.sh
echo "user is $USERNAME_TYPO"
cp nope.txt backup/
echo "after cp, rc=$?"
false | sort
echo "pipeline rc=$?"
echo "reached the end"
user is
cp: backup: No such file or directory
after cp, rc=1
pipeline rc=0
reached the end
[exit 0]
El "modo estricto" son tres opciones. Pusimos cada una en su propio archivo con set -euo pipefail en la línea 1:
| Opción | Atrapa | Mensaje real (bash 3.2) | zsh 5.9 | Exit |
|---|---|---|---|---|
-e (errexit) |
un comando simple que falla | cp: backup: No such file or directory |
igual | 1 |
-u (nounset) |
leer una variable no definida | strict3.sh: line 2: USERNAME_TYPO: unbound variable |
strict3.sh:2: USERNAME_TYPO: parameter not set |
1 |
-o pipefail |
una falla en cualquier parte de un pipeline | (no imprime nada, el script simplemente se detiene) | igual | 1 |
Sin pipefail, el exit code de un pipeline es el de su último comando, así que false | sort contó como éxito porque sort funcionó.
Cuando quieres un valor por defecto para una variable no definida bajo -u, dilo de forma explícita: ${MISSING:-fallback} imprime fallback, y : "${DIR:?DIR is not set}" detiene el script con DIR: DIR is not set (exit 1 en ambas shells). Esa segunda forma es la protección que tienes que poner antes de cualquier rm -rf "$DIR/...".
Error común: confiar en que set -e lo atrapa todo
Esta es la sección que un resumen de una línea no te va a dar. Cada línea de abajo falla, y aun así el script sigue corriendo:
# gotcha.sh
set -euo pipefail
f() { local out=$(false); echo "A: local hid the failure"; }
f
g() { false; echo "B: still running inside g"; }
if g; then echo "B2: g counted as success"; fi
false && echo no
echo "C: 'false && ...' did not stop the script"
echo "D: default -> ${MISSING:-fallback}"
n=$(printf 'a\nb\n' | grep -c zzz || true); echo "E: matches=$n"
count=0
((count++))
echo "F: never printed in bash"
## bash ## zsh
A: local hid the failure A: local hid the failure
B: still running inside g B: still running inside g
B2: g counted as success B2: g counted as success
C: 'false && ...' did not stop the script C: 'false && ...' did not stop the script
D: default -> fallback D: default -> fallback
E: matches=0 E: matches=0
F: never printed in bash [exit 1]
[exit 0]
Lo que pasa en realidad:
- A.
local out=$(false): el exit code que ves es el delocal, que funcionó. Solución: declara y asigna en líneas separadas:local out; out=$(false). - B/B2. Dentro de una función que se llama como condición de un
if,set -equeda desactivado para todo el cuerpo de la función.falseno detuvo ag, ygdevolvió 0 porque su último comando (echo) funcionó. Solución: no dependas de-edentro de funciones que usas en condiciones; termina la función con unreturnexplícito. - C. Un comando que falla a la izquierda de
&&o||nunca dispara-e, por diseño. Ojo con la trampa opuesta: sifalse && echo noes la última línea de un script, el exit code del script pasa a ser 1. - E.
grep -cimprime0y sale con 1 cuando no hay coincidencias. Conpipefaileso mataría el script, así que|| truees la solución correcta aquí, pero solo donde "sin coincidencias" de verdad está bien. - F.
((count++))devuelve 1 cuando el valor anterior es 0. zsh 5.9 se detuvo; bash 3.2 no (revisamos$?, era 1, y el script continuó). Las versiones más nuevas de bash también salen aquí (no ejecutado aquí). Escribecount=$((count + 1)), que siempre funciona, y el script se comporta igual en todas partes.
La lección no es "no uses el modo estricto". Atrapa bugs reales (los tres de strict1.sh). La lección es: el modo estricto es una red de seguridad, no manejo de errores. Para los comandos cuya falla importa, compruébalos de forma explícita:
if ! cp "$src" "$dst"; then
echo "error: copy failed: $src" >&2
exit 1
fi
if, test y [[ ]]
if ejecuta un comando y mira su exit code. [ también es un comando (se llama literalmente [), y por eso importan los espacios y por eso una variable vacía puede romperlo:
# tests.sh
answer=""
if [ $answer = yes ]; then echo yes; else echo "not yes"; fi
if [ "$answer" = yes ]; then echo yes; else echo "quoted: not yes"; fi
x=10
if [ "$x" -gt 9 ]; then echo "10 > 9 numerically"; fi
if [ "$x" \> 9 ]; then echo "string compare says 10 > 9"; else echo "string compare says 10 < 9"; fi
## bash
tests.sh: line 2: [: =: unary operator expected
not yes
quoted: not yes
10 > 9 numerically
string compare says 10 < 9
## zsh
tests.sh:2: parse error: condition expected: =
not yes
quoted: not yes
10 > 9 numerically
tests.sh:6: condition expected: >
string compare says 10 < 9
El $answer vacío y sin comillas desapareció, dejando [ = yes ], que está mal formado; el if tomó la rama else con un mensaje de error, y sin set -e nadie se entera. Fíjate también en que > compara strings ("10" va antes que "9" al ordenar), y el [ de zsh ni siquiera acepta \>. Usa -gt, -lt, -eq para números, o (( x > 9 )). En scripts que solo son de bash/zsh, [[ $answer == yes ]] no separa las variables y es más seguro, pero no es sh POSIX.
Bucles, y la variable de while read que desaparece
total=0
printf '3\n4\n5\n' | while read n; do total=$((total + n)); done
echo "pipe+while total=$total"
total=0
while read n; do total=$((total + n)); done < <(printf '3\n4\n5\n')
echo "process-substitution total=$total"
## bash ## zsh
pipe+while total=0 pipe+while total=12
process-substitution total=12 process-substitution total=12
En bash, cada parte de un pipeline corre en una subshell (una copia hija de la shell), así que el total que se actualizó dentro del bucle se perdió. zsh ejecuta la última parte del pipeline en la shell actual, así que conservó 12. La solución portable es alimentar el bucle con una redirección (< file o < <(cmd)) en lugar de un pipe.
Funciones: código de retorno contra salida
Las funciones reciben los argumentos como $1, $2, … y "$@". Devuelven un exit code con return N (0–255), y "devuelven" datos imprimiéndolos:
greet() { echo "hi $1"; return 3; }
msg=$(greet tom); echo "msg=[$msg] rc=$?"
x=1; change() { x=2; local y=5; }; change; echo "x=$x y=${y:-unset}"
msg=[hi tom] rc=3
x=2 y=unset
Las variables son globales salvo que escribas local. Es una fuente frecuente de bugs del tipo "mi contador del bucle cambió solo" cuando dos funciones usan i.
Medido: aritmética integrada contra lanzar un proceso
Cada $(...) que ejecuta un programa externo cuesta un fork y un exec. Dentro de un bucle, eso se acumula. Contamos hasta 10,000 de tres maneras: i=$(expr "$i" + 1) (programa externo), i=$(echo $((i + 1))) (subshell, sin exec) e i=$((i + 1)) (puro builtin). Cada una se ejecutó 3 veces con /usr/bin/time -p; la tabla muestra la mediana.
| Bucle de 10,000 | bash 3.2 | zsh 5.9 |
|---|---|---|
$(expr ...) |
28.04 s | 25.22 s |
$(echo $((...))) |
7.32 s | 8.79 s |
$((...)) |
0.04 s | 0.02 s |
La máquina estaba ocupada con otros trabajos (load average de alrededor de 9–12 en 8 núcleos), así que los tiempos absolutos están inflados; las ejecuciones individuales variaron hasta un 25%. Lo que importa es la proporción: unas 700 veces más lento cuando cada iteración lanza un proceso. Aquí eso son unos 2.8 ms por llamada a expr. Lo mismo aplica a $(date), $(basename ...) o $(cat file) dentro de bucles; el curso 6 lo mide para los timestamps de los logs.
Límites honestos y notas de versión
- Probado solo en macOS con bash 3.2.57 y zsh 5.9. En bash 3.2 faltan los arrays asociativos (
declare -A),mapfiley${x^^}; obtuvimosdeclare: -A: invalid option,mapfile: command not foundybad substitution. Los tres llegaron en bash 4.0 (según el archivo NEWS de bash; no ejecutado aquí). - Que
((count++))detenga el script bajoset -ees comportamiento de bash más nuevo y de zsh; bash 3.2 continuó. No dependas de ninguno de los dos; usacount=$((count + 1)). pipefailfuncionó en/bin/shen esta Mac (que ejecuta bash 3.2 en modo sh). En Debian/Ubuntu,/bin/shes dash, no bash; si aceptaset -o pipefaildepende de la versión de dash, así que pruébalo ahí (no ejecutado aquí). Si usas funciones de bash, pon#!/bin/bash(o#!/usr/bin/env bash) al inicio y ejecuta el archivo, en lugar desh script.sh.- Los programas de shell reales tienen muchos más casos límite con
set -eque los que mostramos aquí; la lista de arriba es el conjunto que reprodujimos.
Ejercicios
- Un script contiene
dir=$1y más adelanterm -rf "$dir/cache". ¿Qué pasa cuando se ejecuta sin argumento, y qué protección de una línea lo evita? - Reescribe
cat names.txt | while read n; do count=$((count+1)); done; echo $countpara que imprima el número correcto en bash.
Respuestas
$direstá vacío, así que el comando se convierte enrm -rf "/cache". Agrega: "${1:?usage: $0 DIR}"(oset -umásdir=$1, que también falla conunbound variableen bash 3.2) antes de usarlo.count=0; while IFS= read -r n; do count=$((count + 1)); done < names.txt; echo "$count". La redirección mantiene el bucle en la shell actual, eIFS=y-rconservan intactos los espacios iniciales y las barras invertidas.
Anterior: Curso 3: find, xargs, sed y awk · Siguiente: Curso 5: procesos, jobs y señales · Curso 6: scripts robustos, cron y logging (en inglés)
Preguntas frecuentes
¿Por qué una variable sin comillas con un espacio falla en bash pero funciona en zsh?
bash separa el valor de un $f sin comillas en los espacios y expande los comodines (globs) que contenga, así que ls $f con f="my report.txt" ejecuta ls my report.txt y falla dos veces. zsh no separa por defecto los parámetros sin comillas, así que la misma línea funciona ahí. Pon comillas en cada expansión ("$f") y el script se comporta igual en las dos shells.
¿set -e detiene el script en cualquier comando que falle?
No. set -e se ignora dentro de la condición de un if, a la izquierda de && o ||, en una función llamada desde un if, y cuando la falla queda oculta por local x=$(cmd). Ejecutamos todos estos casos: en cada uno el script siguió corriendo. pipefail y -u atrapan otras clases de bugs, pero igual necesitas comprobaciones explícitas para los comandos importantes.
¿Qué significan los exit codes 126 y 127 en la terminal?
127 significa que la shell no encontró el comando (un error de tipeo o un problema con el PATH). 126 significa que encontró el archivo pero no pudo ejecutarlo, normalmente porque le falta el permiso de ejecución. Los dos salieron idénticos en bash 3.2 y zsh 5.9 en macOS.