if, test y [[ ]]

1. La estructura de if

Como vimos en el tema 10, if no evalúa expresiones: ejecuta un comando y mira su código de salida. Si es 0, ejecuta el bloque de then; si no, el de else, cuando lo hay. La palabra fi, que es if al revés, cierra la estructura.

if comando; then
  # se ejecuta si comando terminó con código 0
else
  # se ejecuta en cualquier otro caso (opcional)
fi

El ; antes de then separa el comando de la palabra siguiente; también podría ir un salto de línea. Como establecimos en el tema 4, en este curso then va en la misma línea que if, y el contenido de cada bloque con dos espacios de sangría. Los bloques no pueden estar vacíos: si hace falta uno sin contenido, se usa el comando :, que no hace nada.

Cualquier comando sirve de condición, y muchos scripts no necesitan otra cosa:

if grep -q "^$usuario:" /etc/passwd; then
  echo "El usuario $usuario ya existe"
fi

if ! mkdir -p "$destino"; then
  echo "No se pudo crear $destino" >&2
  exit 1
fi

Pero muchas preguntas no las responde ningún programa en particular: si dos textos son iguales, si un número es mayor que otro, si un archivo existe. Para esas existe un comando especial.

2. test y [: un comando que responde

El comando test evalúa una expresión que recibe como argumentos, y termina con código 0 si es cierta y 1 si es falsa. No muestra nada: su única respuesta es el código.

$ test -f /etc/hostname; echo $?          # ¿es un archivo común?
0
$ test 5 -gt 8; echo $?                   # ¿5 es mayor que 8?
1

El mismo comando tiene un segundo nombre: [. Con ese nombre exige que su último argumento sea ], de modo que la expresión queda entre corchetes y se lee como una condición:

$ [ -f /etc/hostname ]; echo $?
0
$ type -a [
[ is a shell builtin
[ is /usr/bin/[

Esta es la clave para entender sus reglas, que de otro modo parecen caprichosas: [ no es un signo de puntuación, es un comando, y lo que hay dentro son sus argumentos. Por eso:

• Necesita espacios alrededor, como cualquier comando y sus argumentos. [-f archivo] busca un comando llamado [-f.
• El ] final es un argumento más, y también va separado: [ -f archivo] da el error missing `]'.
• Lo que hay dentro pasa por todas las expansiones del tema 3, antes de que [ lo reciba. Una variable sin comillas se divide en palabras, y una vacía desaparece.

La última consecuencia es la que más errores produce:

$ respuesta=""
$ [ $respuesta = si ]                     # [ recibe: = si ]
bash: [: =: unary operator expected
$ archivo="mi informe.txt"
$ [ -f $archivo ]                         # [ recibe: -f mi informe.txt ]
bash: [: mi: binary operator expected
$ [ -f "$archivo" ]                       # correcto

Con [, todas las variables van entre comillas, sin excepción. Peor que los errores es cuando no hay error: [ -n $vacia ] con la variable vacía se convierte en [ -n ], que es una prueba con una sola palabra, -n, y una sola palabra no vacía es siempre cierta. La condición dice «tiene contenido» precisamente cuando no lo tiene.

3. [[ ]]: la versión de Bash

Para evitar esas trampas, Bash incorporó [[ ]]. Se parece a [ ], pero no es un comando sino una palabra reservada, parte de la sintaxis del lenguaje, como if o for. Bash la analiza antes de hacer las expansiones, y eso le permite comportarse de forma más sensata:

$ respuesta=""
$ [[ $respuesta = si ]]; echo $?          # sin error: simplemente es falso
1
$ archivo="mi informe.txt"
$ [[ -f $archivo ]]; echo $?             # la variable no se divide
0

Los espacios siguen siendo obligatorios, porque [[ y ]] deben ser palabras separadas. Y aunque dentro de [[ ]] las comillas no son necesarias para las variables, ponerlas no hace daño, y mantiene la costumbre que exigen [ ] y el resto del lenguaje. En este curso las seguiremos poniendo, con una excepción que veremos en la sección 5.

4. Comparar cadenas

if [[ "$USER" == "root" ]]; then
  echo "No ejecutes este script como administrador." >&2
  exit 1
fi

if [[ -z "$destino" ]]; then
  echo "Falta el destino." >&2
  exit 2
fi

Las comparaciones distinguen mayúsculas de minúsculas: Si y si son distintas. Si no importa, se normaliza antes con ${var,,}, como en el tema 6. Y < y > comparan texto, según el orden alfabético de la configuración regional; con números dan resultados sorprendentes, como veremos en la sección 6.

5. Patrones con ==

Dentro de [[ ]], el lado derecho de == y != es un patrón, con los comodines de los nombres de archivo: *, ? y […]. Es una de las características más útiles de [[ ]]:

$ f="informe.pdf"
$ [[ $f == *.pdf ]] && echo "es un PDF"
es un PDF
$ [[ $f == "*.pdf" ]] || echo "no se llama literalmente *.pdf"
no se llama literalmente *.pdf

Aquí está la excepción a la costumbre de entrecomillar: las comillas en el lado derecho desactivan el patrón, y la comparación pasa a ser literal. Así se elige entre los dos comportamientos: patrón sin comillas, texto exacto con comillas. Cuando el valor de la derecha viene de una variable y debe compararse literalmente, va entre comillas: [[ $a == "$b" ]]. Si no, un * en $b funcionaría como comodín.

Los patrones de [[ ]] coinciden con la cadena completa: *.pdf exige que termine en .pdf, y pdf solo coincide con la palabra exacta. Para buscar un texto en cualquier posición se rodea de asteriscos: *error*. Y, a diferencia de los nombres de archivo, en [[ ]] el * sí coincide con las barras.

6. Comparar números

Para comparar números, [ ] y [[ ]] usan operadores con letras, heredados de la shell original. Ya conoces la alternativa más legible, (( )), del tema 7:

if [ "$uso" -ge 90 ]; then      # portable a sh
if [[ $uso -ge 90 ]]; then      # Bash
if (( uso >= 90 )); then        # Bash, la más legible: la que usa este curso

Lo que no hay que hacer es comparar números con los operadores de cadenas, porque comparan carácter por carácter, como en un diccionario:

$ [[ 10 < 9 ]] && echo "10 < 9, como texto"    # «1» va antes que «9»
10 < 9, como texto
$ (( 10 < 9 )) || echo "falso, como números"
falso, como números
$ [ 5 > 3 ]                                    # en [ ], > es una redirección
$ ls
3

El último caso merece atención: dentro de [ ], > 3 es una redirección, que crea un archivo llamado 3, y la condición [ 5 ] es siempre cierta. No hay ningún mensaje de error.

Si un operando no es un número, [ ] da un error, y [[ ]] y (( )) lo evalúan como una expresión aritmética, con las sorpresas que vimos en el tema 7: una palabra cualquiera vale 0. Por eso, como allí, los números que vienen de afuera se validan antes de comparar.

$ [ abc -eq 1 ]
bash: [: abc: integer expression expected
$ [[ abc -eq 0 ]] && echo "cierto, en silencio"
cierto, en silencio

7. Comprobar archivos y directorios

La familia más numerosa de pruebas pregunta por archivos. Son las que más usa un script de automatización, que antes de actuar debe saber si lo que va a tocar existe y es lo que espera:

if [[ ! -d "$origen" ]]; then
  echo "No existe el directorio $origen" >&2
  exit 1
fi

if [[ -e "$destino" ]]; then
  echo "$destino ya existe; no lo sobrescribo" >&2
  exit 1
fi

if [[ ! -w "$(dirname "$destino")" ]]; then
  echo "No tengo permiso para escribir en $(dirname "$destino")" >&2
  exit 1
fi

El signo ! delante de una prueba la invierte: ! -d pregunta si no es un directorio. Tres detalles evitan confusiones:

• -f y -d siguen los enlaces simbólicos. Un enlace a un archivo da cierto con -f. Para saber si algo es un enlace, se pregunta con -L, y un enlace roto da falso con -e pero cierto con -L.
• -r, -w y -x responden por el usuario que ejecuta el script. Un archivo que tú puedes escribir puede no serlo para el usuario de cron o de un servicio. Y para root son casi siempre ciertas.
• Que una prueba sea cierta no garantiza que la operación funcione. Entre la comprobación y la acción, otro proceso puede borrar o crear el archivo. Para operaciones críticas conviene además comprobar el código de salida de la acción misma, y usar opciones como mv -n o mkdir sin -p, que fallan si algo cambió.

8. Comparar archivos entre sí

Tres pruebas comparan dos archivos. Las dos primeras, por fecha de modificación, son la base de cualquier tarea que deba rehacer algo solo si su origen cambió, como veremos al automatizar compilaciones en el tema 36:

if [[ informe.md -nt informe.pdf ]]; then
  pandoc informe.md -o informe.pdf
  echo "PDF actualizado"
else
  echo "El PDF ya está al día"
fi

La regla para archivos inexistentes es justo la que hace falta aquí: si informe.pdf todavía no existe, informe.md -nt informe.pdf es cierto, y el PDF se genera por primera vez.

9. Comprobar variables

Para saber si una variable tiene valor se usan -z y -n. Para saber si existe, aunque esté vacía, -v, que recibe el nombre sin $, como vimos en el tema 5. Con set -u activo, leer una variable que puede no existir requiere el valor por defecto vacío del tema 6:

if [[ -n "${DEPURAR:-}" ]]; then        # ¿tiene valor? sin error si no existe
  set -x
fi

if [[ -v CONFIG ]]; then                # ¿existe, aunque esté vacía?
  source "$CONFIG"
fi

10. Cuál usar

Bash ofrece tres formas de condición, y cada una tiene su terreno:

La última fila corrige una confusión frecuente: los corchetes no son parte de la sintaxis de if. Escribir if [ grep -q x f ] no ejecuta grep: le pasa a [ la palabra grep y otras, y da un error. Los corchetes solo se usan cuando la pregunta es de las que responde test.

11. Un script completo

Un respaldo que falla en silencio es peor que no tener ninguno, porque da una falsa seguridad. Este script comprueba que un archivo de respaldo sea razonable: que exista, sea un archivo común, se pueda leer, no esté vacío, tenga un tamaño mínimo y sea reciente. Los límites se pueden cambiar con variables de entorno.

#!/usr/bin/env bash
#
# comprobar-respaldo — verifica que un archivo de respaldo exista, no esté
# vacío, tenga un tamaño mínimo y sea reciente.
#
# Uso:     comprobar-respaldo ARCHIVO
# Entorno: HORAS_MAX  antigüedad máxima en horas (26)
#          KIB_MIN    tamaño mínimo en KiB (1)
# Salida:  0 si el respaldo es válido; 1 si no.
#
set -euo pipefail

readonly HORAS_MAX="${HORAS_MAX:-26}"
readonly KIB_MIN="${KIB_MIN:-1}"

archivo="${1:?Uso: comprobar-respaldo ARCHIVO}"

falla() {
  printf 'FALLA  %s: %s\n' "$archivo" "$*" >&2
  exit 1
}

if [[ ! -e "$archivo" ]]; then
  falla "no existe"
fi
if [[ ! -f "$archivo" ]]; then
  falla "no es un archivo común"
fi
if [[ ! -r "$archivo" ]]; then
  falla "no se puede leer"
fi
if [[ ! -s "$archivo" ]]; then
  falla "está vacío"
fi

kib=$(( $(stat -c %s "$archivo") / 1024 ))
if (( kib < KIB_MIN )); then
  falla "ocupa $kib KiB; se esperaban al menos $KIB_MIN"
fi

horas=$(( ( $(date +%s) - $(stat -c %Y "$archivo") ) / 3600 ))
if (( horas > HORAS_MAX )); then
  falla "tiene $horas horas; el máximo es $HORAS_MAX"
fi

printf 'OK     %s (%d KiB, %d horas)\n' "$archivo" "$kib" "$horas"

$ comprobar-respaldo /respaldos/web-2026-10-14.tgz
OK     /respaldos/web-2026-10-14.tgz (48213 KiB, 7 horas)
$ comprobar-respaldo /respaldos/web-2026-10-11.tgz
FALLA  /respaldos/web-2026-10-11.tgz: tiene 79 horas; el máximo es 26
$ comprobar-respaldo /respaldos/db.sql.gz
FALLA  /respaldos/db.sql.gz: está vacío
$ KIB_MIN=100000 comprobar-respaldo /respaldos/web-2026-10-14.tgz
FALLA  /respaldos/web-2026-10-14.tgz: ocupa 48213 KiB; se esperaban al menos 100000

• Las pruebas van de la más básica a la más específica. No tiene sentido medir el tamaño de algo que no existe: cada comprobación asume que las anteriores pasaron, y la función falla termina el script en la primera que no.
• Cada fallo dice cuál es el problema concreto. «No válido» obligaría a investigar; «tiene 79 horas» ya explica qué pasó: el respaldo dejó de ejecutarse hace tres días.
• stat -c %s y stat -c %Y dan el tamaño en bytes y la fecha de modificación en segundos desde 1970. Con la aritmética del tema 7 se convierten en KiB y en horas.
• Las comparaciones numéricas usan (( )) y las de archivos [[ ]], cada una en su terreno. En el tema 12 veremos cómo reunir estas comprobaciones en estructuras más compactas.

12. Errores frecuentes

13. Resumen

• if comando; then …; else …; fi elige según el código de salida del comando. Cualquier comando sirve de condición.
• test y [ son el mismo comando: evalúa una expresión y responde con su código. Sus argumentos pasan por las expansiones, así que necesitan espacios y comillas.
• [[ ]] es una palabra reservada de Bash: no divide las variables, no expande comodines, admite patrones, =~, && y ||.
• Las cadenas se comparan con ==, !=, -z, -n, < y >; distinguen mayúsculas.
• En [[ ]], el lado derecho de == sin comillas es un patrón, que debe coincidir con la cadena entera; con comillas, es texto literal.
• Los números se comparan con (( )), o con -eq, -lt, -gt y sus parientes. < y > en corchetes comparan texto, o redirigen.
• -e, -f, -d, -L, -s, -r, -w y -x preguntan por archivos; ! invierte cualquier prueba.
• -nt y -ot comparan fechas de modificación, y tratan un archivo inexistente como el más viejo.
• -n "${VAR:-}" y -v VAR comprueban variables opcionales sin chocar con set -u.
• En Bash: [[ ]] para cadenas y archivos, (( )) para números, el comando mismo para saber si funcionó, y [ ] solo por portabilidad.

14. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Compara [ $x = si ], [ "$x" = si ] y [[ $x = si ]] con x vacía, con x=si y con x="no lo sé".
2. Escribe un script que reciba un nombre y diga si es un archivo común, un directorio, un enlace simbólico o no existe, y si puedes leerlo y escribirlo.
3. Prueba [[ $f == *.txt ]] y [[ $f == "*.txt" ]] con f=notas.txt y con f='*.txt'.
4. Compara 2 y 10 con < dentro de [[ ]], con -lt y con (( )).
5. Crea dos archivos con touch, el segundo un segundo después, y compáralos con -nt y -ot. Prueba también contra un archivo que no existe.
6. Escribe un script que convierta un archivo .md en .txt (por ejemplo, copiándolo) solo si el .txt no existe o es más viejo que el .md.
7. Instala comprobar-respaldo y pruébalo con un archivo reciente, uno vacío, un directorio y un archivo modificado con touch -d '3 days ago'.