Comodines en Linux: guía rápida y avanzada

Mascota de Linux usando un portátil con varias terminales multiplexadas alrededor.

Enlaces rápidos

Qué son los comodines?
Especificar un solo carácter: “?”
Coincidir varios caracteres con “*”
Coincidir rangos con corchetes
Coincidencias alternas con paréntesis
Excluir coincidencias con “!” y “^”
Desactivar comodines con comillas

Important: El shell realiza la expansión de comodines antes de ejecutar el programa. El programa recibe la lista de archivos ya expandida; no “ve” los comodines.

Qué son los comodines?

Un comodín es un carácter especial que representa uno o más caracteres en nombres de archivos o rutas. También se les llama metacaracteres. Piensa en ellos como cartas comodín en un juego: sustituyen otros caracteres para formar coincidencias.

Definición rápida: expansión de comodines = reemplazo de patrones por nombres de archivos por parte del shell.

Cómo funciona: cuando escribes una expresión que contiene comodines, el shell la evalúa y la sustituye por los nombres de archivo que coinciden antes de invocar el comando. Si no hay coincidencias, el comportamiento depende del shell y de sus opciones (por ejemplo, error, dejar sin expandir, o expandir a nada).

Compatibilidad: los comodines básicos (“?” y “*”) funcionan en la mayoría de shells. Algunas expansiones avanzadas necesitan opciones como extglob en Bash o están integradas en zsh.

Sugerencia: si no estás seguro de lo que hará una expansión, pon el comando dentro de echo primero (por ejemplo, echo *.log) para ver la lista resultante antes de ejecutar operaciones destructivas.

Especificar un solo carácter: “?”

El comodín “?” coincide exactamente con un carácter.

Ejemplo práctico: supón que tienes archivos con extensiones .pl y .py y fotos con nombres photo_01, photo_02…

ls photo.0?.jpg

Esto listará archivos como photo.01.jpg o photo.02.jpg donde el signo de interrogación sustituye un solo carácter.

Nota: si no hay coincidencias podrías recibir una línea en blanco o un mensaje de error según la configuración del shell.

Coincidencia de un solo carácter con ls usando el comodín

Coincidir varios caracteres con “*”

El comodín más usado es “*” (asterisco). Coincide con cero o más caracteres.

Ejemplos comunes:

ls *.jpg

lista todos los JPEG del directorio actual.

Para subdirectorios:

ls photos/*.jpg

Combinar con “?”:

ls *.p?

coincide con archivos que terminan en .pl y .py.

Buscar una letra en cualquier parte del nombre:

ls *d*

zsh y recursión: zsh soporta para búsqueda recursiva (siempre revisa la configuración):

ls ~/
ls /usr//bin

"." class="block w-auto max-w-full h-auto mx-auto py-2 rounded-xl "/>

Tres asteriscos: según configuración pueden seguir enlaces simbólicos además de subdirectorios.

MS-DOS vs Linux: en Windows era común usar “.“; en Linux basta con “*” para coincidir con todos los archivos.

Precaución destructiva: comandos como rm * son permanentes. Siempre verifica con echo o usa opciones interactivas (-i) antes de borrar en masa.

Coincidir rangos con corchetes

Los corchetes [] permiten listar un conjunto de caracteres posibles o rangos.

Coincidencias individuales:

[abc]

Rangos:

[a-z]
[A-Z]
[0-9]
[a-zA-Z0-9]

Ejemplo combinado:

ls *.p[ly]

coincide con .pl y .py.

Uso práctico: encontrar archivos que empiezan por un prefijo:

ls py*

Corchetes también sirven para negar conjuntos cuando se antepone ^ o ! (ver sección de exclusión).

Curly braces (llaves) para expansión de palabras: esto no es exactamente un comodín, sino una expansión de brace.

echo {cat,dog}
echo {a..d}
echo {1..10}

Estas expresiones generan listas de palabras antes de pasar al comando. Si combinas con ls, y un archivo no existe, recibirás un error.

Coincidencias alternas con paréntesis

En shells que soportan “extglob” o tienen sintaxis propia (zsh), puedes usar paréntesis y barras verticales para alternancia (or):

ls *.(pl|py)

También puedes usar construcciones como +(a|b) o ?(a|b) según la extensión de globbing activa. En Bash debes habilitar extglob:

shopt -s extglob   # Bash: activar globbing extendido
ls *.(pl|py)

Explicación rápida:

+(pat|pat2) — una o más repeticiones del patrón
*(pat|pat2) — cero o más repeticiones
?(pat|pat2) — cero o una repetición
@(pat|pat2) — exactamente una coincidencia de las alternativas
!(pat|pat2) — negación (todas las cadenas que NO coinciden)

Excluir coincidencias con “!” y “^”

Dentro de corchetes, ^ o ! niegan el conjunto:

ls [!a-z]
ls [^a-z]

En extglob puedes negar patrones completos:

shopt -s extglob
ls !(a|b|c)

Esto lista todo lo que no coincida con a, b o c.

Advertencia: la sintaxis y el soporte varían entre shells; comprueba la documentación de tu shell.

Desactivar comodines con comillas

Si quieres que el shell no expanda una cadena (por ejemplo, porque la estás buscando con grep o porque contiene variables), usa comillas.

Comillas simples: evitan cualquier expansión (ni variables ni comodines)
Comillas dobles: evitan el globbing pero permiten expansión de variables y ciertos escapes

Ejemplos:

grep '^foo' file.txt    # '^' está entre comillas simples
pattern="^foo"
grep "$pattern" file.txt  # comillas dobles permiten expandir $pattern

Si necesitas un literal que contenga comillas internas, usa combinaciones o escapes según el caso.

Opciones del shell que afectan a los comodines

Bash y zsh tienen opciones que cambian cómo se comportan los comodines.

Bash (shopt):

shopt -s nullglob   # los patrones sin coincidencias expanden a nada (en lugar de quedarse literales)
shopt -s failglob   # los patrones sin coincidencias causan error
shopt -s extglob    # habilita globbing extendido (+(...), !(...), etc.)

zsh: muchas de estas características están activadas por defecto; para replicar en Bash, habilita extglob y revisa las opciones.

Consejo: usa nullglob para scripts que no deban fallar por ausencia de archivos y failglob cuando prefieras detectar errores tempranamente.

Alternativas a los comodines

Los comodines son útiles y rápidos, pero no sustituyen a herramientas más potentes en búsquedas profundas o filtros complejos.

find: búsqueda recursiva con filtros potentes (por nombre, tipo, fecha, permisos)
rsync: copiar o sincronizar conjuntos de archivos con control fino
grep: filtrar contenido dentro de archivos
xargs: combinar listas de archivos con otros comandos cuando el número de archivos puede ser grande

Ejemplos:

find . -type f -name "*.log" -print0 | xargs -0 rm -v   # borrar con protección contra espacios en nombres
rsync -av --include='*/' --include='*.jpg' --exclude='*' src/ dst/  # sincronizar solo .jpg

find vs globbing: find recorre recursivamente el árbol y aplica filtros que el globbing simple no hace; usa find cuando necesitas criterios adicionales (fecha, tamaño, permisos).

Patrones avanzados y casos especiales

Coincidencias recursivas con : práctica en zsh y, en Bash 4+ con globstar activado (shopt -s globstar):

shopt -s globstar
ls /*.py

Símbolos especiales en nombres de archivos: si tus nombres contienen espacios, nuevos renglones o caracteres especiales, trabaja con NUL delimiters (find -print0 | xargs -0) o usa arrays en Bash.
Límite de argumentos: expandir un patrón puede producir demasiados argumentos para un comando; en ese caso usa find + xargs o un bucle.
Orden de expansión: la expansión de comodines ocurre antes que la expansión de variables (salvo dentro de comillas), y antes de la expansión de llaves.

Buenas prácticas y reglas de seguridad

Siempre prueba patrones con echo o printf antes de ejecutar comandos destructivos.

echo rm *.bak

En scripts, considera shopt -s nullglob o comprueba manualmente si la expansión produce elementos.
Para borrar, usa -i o –interactive cuando no estés seguro.
Evita rm -rf * en directorios ambiguos; comprueba pwd y usa rutas absolutas cuando sea necesario.
Para operaciones masivas de copia o sincronización, rsync suele ser más seguro que cp *.

Ejemplos prácticos y mini metodología

Mini-metodología para operaciones en lote:

Visualiza: usa echo y ls con el patrón.
Verifica: comprueba que la lista contiene lo esperado.
Prueba: ejecuta el comando en modo no destructivo (-n, –dry-run) o con echo.
Ejecuta: aplica la operación real.
Recupera: ten backups o puntos de restauración si trabajas con datos críticos.

Ejemplo — renombrado masivo seguro:

# ver qué cambiará
for f in *.JPG; do echo mv -- "$f" "${f%.JPG}.jpg"; done
# si está bien, ejecutar
for f in *.JPG; do mv -- "$f" "${f%.JPG}.jpg"; done

Ejemplo — uso de find para evitar problemas de límite de argumentos:

find . -name "*.tmp" -type f -print0 | xargs -0 rm -v

Cuando los comodines fallan: contraejemplos y límites

Nombres con saltos de línea: los comodines expanden por nombres completos, pero algunos comandos no toleran saltos de línea; usa -print0 y xargs -0.
Coincidencias inesperadas: puede coincidir con archivos ocultos? No, a menos que comience con un punto explícito (en shells típicas, ““ no coincide con archivos que empiezan por “.”). Para incluir ocultos usa dotglob/nullglob según el shell.
Shell diferente: un script que funciona en zsh puede fallar en Bash si depende de extglob por defecto.

Lista de comprobación por rol

Desarrollador:

[ ] Probar patrones con echo
[ ] Usar nullglob en scripts idempotentes
[ ] Evitar rm sin confirmación en CI

Administrador de sistemas:

[ ] Usar find para filtrado avanzado
[ ] Documentar scripts que usan extglob
[ ] Tener snapshots/backups antes de cambios masivos

Principiante:

[ ] Aprender ?, *, [] primero
[ ] Practicar con copias de ejemplo
[ ] Evitar comandos destructivos hasta estar seguro

Hoja de referencia rápida (cheat sheet)

? : coincide con exactamente un carácter
- : coincide con cero o más caracteres
[abc] : coincide con cualquiera de los caracteres a, b o c
[a-z] : rango de caracteres
{a,b} : expansión de lista (antes de la ejecución)
{1..10} : expansión de secuencia
** : recursivo (si está habilitado)
extglob (Bash): +(pat|pat) ?(pat|pat) *(pat|pat) @(pat|pat) !(pat|pat)

1-línea de glosario

Globbing: el proceso de expansión de comodines en el shell.
Nullglob: opción que hace que patrones sin coincidencia expandan a nada.
Extglob: extensión de globbing con patrones avanzados como !(pat).

Diagrama de decisión (Mermaid)

flowchart TD
  A[¿Buscas archivos simples en el directorio actual?] -->|Sí| B{¿Ocultos?}
  B -->|No| C[Usa * o ?]
  B -->|Sí| D[Habilitar dotglob o escribir patrón con .]
  A -->|No| E[¿Criterios complejos 'fecha, permisos'?]
  E -->|Sí| F[Usa find con -name/-mtime/-perm]
  E -->|No| G[¿Muchos archivos o límites de args?]
  G -->|Sí| H[Usa find -print0 | xargs -0]
  G -->|No| C

Casos de uso concretos

Listar todos los archivos .conf en /etc y subdirectorios:

shopt -s globstar
ls /etc/**/*.conf

(Si prefieres find):

find /etc -type f -name "*.conf"

Mover solo imágenes .jpg de src a dst conservando subdirectorios (rsync):

rsync -av --include='*/' --include='*.jpg' --exclude='*' src/ dst/

Borrar conjuntamente archivos temporales seguros:

find /var/tmp -type f -name "*.tmp" -mtime +30 -print0 | xargs -0 rm -v

Resumen

Los comodines facilitan trabajar con múltiples archivos sin teclear cada nombre.
Los básicos ? y * funcionan en casi todos los shells; las expansiones avanzadas requieren opciones o shells como zsh.
Nunca ejecutes comandos destructivos sin comprobar antes la expansión (echo/–dry-run).
Para búsquedas complejas o entornos con muchos archivos, combina globbing con find, xargs y rsync.

Notes: Practica en un directorio de prueba antes de aplicar patrones en sistemas de producción.

Con estas herramientas y prácticas, usarás comodines con seguridad y eficacia en la terminal Linux. Empieza por lo esencial y añade opciones avanzadas (extglob, globstar, find) cuando necesites más control.

Comodines en la terminal Linux: guía completa