Comodines, comillas y expansión

1. La shell reescribe la línea

En el tema 6 vimos un caso: al escribir ~/practica, el comando no recibe la virgulilla, sino /home/ana/practica. La shell hizo el reemplazo antes de ejecutar. No es un caso aislado, sino la regla general.

La expansión es el paso en que la shell, después de leer la línea y antes de ejecutar el comando, reemplaza ciertos caracteres y construcciones por otro texto. El comando recibe el resultado, nunca lo que escribiste.

Para estudiar las expansiones hace falta poder verlas, y la herramienta es un viejo conocido: echo. Como lo único que hace es escribir sus argumentos, muestra exactamente lo que la shell le entregó:

$ echo ~
/home/ana
$ echo ~/practica/*.txt
/home/ana/practica/informe.txt /home/ana/practica/notas.txt

A lo largo del tema usaremos echo como una lente: delante de cualquier línea, deja ver en qué la convierte la shell, sin ejecutar nada.

2. Un banco de pruebas

Los comodines se aprecian con varios archivos. Para no llenar el directorio de práctica, preparamos uno descartable en /tmp, que según el tema 8 es el lugar para eso:

$ mkdir /tmp/prueba
$ cd /tmp/prueba
$ touch notas.txt lista.txt informe.txt informe.pdf Datos.csv
$ touch foto1.jpg foto2.jpg foto3.jpg foto10.jpg .oculto
$ ls
Datos.csv  foto10.jpg  foto1.jpg  foto2.jpg  foto3.jpg  informe.pdf  informe.txt  lista.txt  notas.txt

touch crea archivos vacíos con los nombres que recibe; lo vemos en el tema 11. Quedan nueve archivos visibles y uno oculto. Todos los ejemplos de las secciones 3 a 8 se ejecutan en este directorio.

3. El asterisco

Un comodín es un carácter que, dentro de un nombre de archivo, no vale por sí mismo sino que representa a otros. Una palabra con comodines es un patrón, y la shell la reemplaza por la lista de nombres existentes que coinciden con él.

El más usado es el asterisco, que representa cualquier cantidad de caracteres cualesquiera, incluso ninguno:

$ echo *.txt                        # lo que termina en .txt
informe.txt lista.txt notas.txt
$ echo foto*                        # lo que empieza con foto
foto10.jpg foto1.jpg foto2.jpg foto3.jpg
$ echo informe.*                    # informe, con cualquier extensión
informe.pdf informe.txt
$ echo *for*                        # lo que contiene «for» en cualquier parte
informe.pdf informe.txt
$ echo *                            # todo
Datos.csv foto10.jpg foto1.jpg foto2.jpg foto3.jpg informe.pdf informe.txt lista.txt notas.txt

La parte «incluso ninguno» importa: foto* coincidiría también con un archivo llamado exactamente foto. Y el resultado no es para echo en particular. El patrón se usa con cualquier comando que reciba nombres de archivos:

$ ls -l *.jpg
-rw-rw-r-- 1 ana ana 0 oct 12 11:40 foto10.jpg
-rw-rw-r-- 1 ana ana 0 oct 12 11:40 foto1.jpg
-rw-rw-r-- 1 ana ana 0 oct 12 11:40 foto2.jpg
-rw-rw-r-- 1 ana ana 0 oct 12 11:40 foto3.jpg

4. El signo de interrogación

El signo de interrogación representa exactamente un carácter, cualquiera. Donde el asterisco es elástico, la interrogación cuenta posiciones:

$ echo foto?.jpg                    # foto, un carácter, .jpg
foto1.jpg foto2.jpg foto3.jpg
$ echo foto??.jpg                   # foto, dos caracteres, .jpg
foto10.jpg
$ echo *.???                        # extensión de exactamente tres caracteres
Datos.csv foto10.jpg foto1.jpg foto2.jpg foto3.jpg informe.pdf informe.txt lista.txt notas.txt
$ echo ?????.*                      # nombre de cinco caracteres antes del punto
Datos.csv foto1.jpg foto2.jpg foto3.jpg lista.txt notas.txt

La comparación de los dos primeros con foto*.jpg, que los abarca a los cuatro, muestra la diferencia. La interrogación se usa menos que el asterisco, y es valiosa cuando los nombres siguen un formato fijo, como las fechas: registro-2026-??-01.log coincide con el primer día de cada mes.

5. Los corchetes

Los corchetes representan también un solo carácter, pero no cualquiera: uno de los que se enumeran dentro.

$ echo foto[12].jpg                 # un 1 o un 2
foto1.jpg foto2.jpg
$ echo foto[2-9].jpg                # un carácter entre el 2 y el 9
foto2.jpg foto3.jpg
$ echo [iln]*                       # empieza con i, con l o con n
informe.pdf informe.txt lista.txt notas.txt
$ echo [!f]*                        # NO empieza con f
Datos.csv informe.pdf informe.txt lista.txt notas.txt
$ echo [[:upper:]]*                 # empieza con mayúscula
Datos.csv

Las clases con nombre son la forma segura de decir «una letra» o «una mayúscula», porque tienen en cuenta el idioma del sistema, incluidas la ñ y las vocales con tilde:

Los tres comodines se combinan en un mismo patrón. foto[0-9]*.jpg se lee «foto, un dígito, cualquier cosa, .jpg», y coincide con las cuatro fotos.

6. Las reglas de los comodines

El comportamiento de los comodines tiene cinco reglas que conviene conocer, porque cada una explica una sorpresa frecuente.

Primera: los archivos ocultos no coinciden. En todos los ejemplos faltó .oculto, incluso con el asterisco solo. Un comodín al comienzo del patrón nunca coincide con el punto inicial; hay que escribirlo:

$ echo .*
.oculto

Es una protección: evita que un * alcance a los archivos de configuración sin que lo hayas pedido.

Segunda: un comodín no atraviesa la barra. El asterisco coincide con nombres dentro de un directorio, no con rutas. Para abarcar varios niveles se pone un comodín en cada uno:

$ echo /etc/*.conf                  # los .conf que están directamente en /etc
/etc/adduser.conf /etc/ca-certificates.conf /etc/debconf.conf …
$ echo /etc/*/*.conf                # los que están un nivel más abajo
/etc/apparmor/parser.conf /etc/fonts/fonts.conf …
$ echo /home/*/practica             # el directorio «practica» de cada usuario
/home/ana/practica

Tercera: si nada coincide, el patrón queda como está. La shell no da error ni lo elimina: lo entrega al comando sin cambios, con el asterisco incluido.

$ echo *.png
*.png
$ ls *.png
ls: cannot access '*.png': No such file or directory

El mensaje de ls es revelador: buscó un archivo que se llamara literalmente *.png, porque eso fue lo que recibió.

Cuarta: los comodines miran nombres, no contenidos. *informe* encuentra los archivos cuyo nombre contiene esa palabra, no los que la tienen escrita dentro. Buscar en el contenido es tarea de grep, en el tema 27.

Quinta: no son expresiones regulares. Más adelante veremos otro lenguaje de patrones, más potente, que usan grep, sed y awk. Comparte símbolos con los comodines y les da otro significado, lo que es una fuente clásica de confusión. Conviene dejar la diferencia anotada desde ahora:

7. El comando nunca ve el comodín

Quien expande el patrón es la shell. Lo dijimos al comienzo, y tiene consecuencias prácticas que se entienden mejor ahora.

Funciona con todos los comandos, y siempre igual. ls, cp, cat o un programa que escribas tú no necesitan saber nada de comodines. Reciben una lista de nombres. Es una de las decisiones de diseño más acertadas de Unix: el mecanismo se programó una vez, en la shell, y sirve para todo.

Explica un comportamiento de ls que desconcierta. En un directorio que contiene subdirectorios, ls * no muestra lo mismo que ls:

$ cd ~/practica
$ ls
fotos  informe.txt  notas.txt
$ ls *                              # equivale a: ls fotos informe.txt notas.txt
informe.txt  notas.txt

fotos:
$ cd /tmp/prueba

Con el asterisco, ls recibe tres argumentos, y uno es un directorio. Según vimos en el tema 7, cuando el argumento es un directorio muestra su contenido: por eso aparece el bloque fotos:, vacío. La opción -d lo evita.

Explica un error que parece absurdo. En un directorio con decenas de miles de archivos, un patrón puede expandirse a una línea más larga de lo que el sistema admite, y el resultado es Argument list too long. La solución está en el tema 10, con find.

Y explica un riesgo. Si en el directorio hay un archivo cuyo nombre empieza con guion, el asterisco lo incluye en la lista, y el comando lo toma por una opción. La defensa es la del tema 3: el doble guion, o un patrón que empiece con una ruta, como ./*.

8. Las llaves: generar texto

Las llaves parecen un comodín más, y no lo son. No buscan archivos: fabrican palabras, combinando un texto fijo con cada una de las alternativas indicadas.

$ echo foto{1,2,3}.jpg              # una lista
foto1.jpg foto2.jpg foto3.jpg
$ echo capitulo{1..5}.txt           # una secuencia numérica
capitulo1.txt capitulo2.txt capitulo3.txt capitulo4.txt capitulo5.txt
$ echo {01..10}                     # con ceros a la izquierda
01 02 03 04 05 06 07 08 09 10
$ echo {a..e}                       # una secuencia de letras
a b c d e
$ echo {enero,febrero}-{2025,2026}  # todas las combinaciones
enero-2025 enero-2026 febrero-2025 febrero-2026

Ninguno de esos capitulo existe: la shell genera los nombres sin mirar el disco. Esa es la diferencia con los comodines, y determina para qué sirve cada uno:

Por eso las llaves son la herramienta para crear. Una estructura de directorios completa se arma en una línea:

$ mkdir -p proyecto/{src,docs,tests}
$ ls proyecto
docs  src  tests

La shell convirtió la línea en mkdir -p proyecto/src proyecto/docs proyecto/tests. Hay dos reglas de escritura: las alternativas se separan con comas sin espacios, y las secuencias llevan exactamente dos puntos.

Una alternativa puede estar vacía, y de ahí sale un modismo que verás a menudo para hacer una copia de respaldo de un archivo:

$ echo cp informe.txt{,.bak}
cp informe.txt informe.txt.bak

Las llaves y los comodines se combinan: ls *.{jpg,pdf} se convierte primero en ls *.jpg *.pdf, y luego cada patrón se expande por separado.

9. Las demás expansiones

Los comodines y las llaves son dos de las expansiones de Bash. Hay otras, algunas ya vistas y otras que desarrollaremos más adelante. Esta es la lista completa, en el orden en que la shell las aplica:

$ echo $HOME
/home/ana
$ echo $(whoami)
ana
$ echo $((7 * 6))
42

Las tres del medio tienen algo en común: empiezan con el signo $. Es el carácter con el que se le pide a la shell «pon aquí el valor de esto».

El orden tiene importancia. Los comodines se resuelven al final, sobre el resultado de todo lo anterior. Por eso funciona ~/practica/*.txt: primero la virgulilla se convierte en una ruta, y después el asterisco se busca en ella.

10. Los caracteres especiales

La otra cara de la expansión es que una cantidad de caracteres dejaron de ser solo caracteres. Para la shell significan algo:

El problema aparece cuando se necesita uno de ellos tal cual: un precio con el signo $, un nombre de archivo con espacios, un asterisco que debe llegar a un programa. Mira lo que pasa con un mensaje inocente:

$ echo Precio: $5 * 2    (oferta)
bash: syntax error near unexpected token `('
$ echo Precio: $5 * 2
Precio: Datos.csv foto10.jpg foto1.jpg foto2.jpg foto3.jpg informe.pdf informe.txt lista.txt notas.txt proyecto 2

La primera línea ni siquiera se ejecutó: los paréntesis tienen un significado y están mal usados. En la segunda, $5 se tomó como una variable, que está vacía; el asterisco se expandió a todos los archivos, y los espacios repetidos desaparecieron.

Para evitarlo hay que proteger esos caracteres: decirle a la shell que los trate como texto. Hay tres mecanismos, de alcance creciente.

11. La barra invertida

La barra invertida protege un solo carácter: el que tiene inmediatamente después. Ese carácter pierde su significado especial y la barra desaparece.

$ echo Precio: \$5 \* 2 \(oferta\)
Precio: $5 * 2 (oferta)
$ echo \~ no es mi casa
~ no es mi casa
$ echo Una barra: \\
Una barra: \

La operación se llama escapar un carácter. Para escribir una barra invertida literal, se la escapa con otra. Ya vimos dos usos de este mecanismo en el tema 5 sin darle nombre: el mis\ notas.txt que escribía Tab, donde la barra protege un espacio, y la barra al final de la línea, que protege al Enter y permite continuar en el renglón siguiente.

La barra invertida es cómoda para un carácter aislado. Cuando hay varios, la línea se vuelve ilegible, y conviene pasar a las comillas.

12. Las comillas simples

Las comillas simples protegen todo lo que encierran. Entre ellas no hay ningún carácter especial: lo que se escribe es lo que llega.

$ echo 'Precio: $5 * 2    (oferta)'
Precio: $5 * 2    (oferta)
$ echo 'Mi directorio es $HOME y ~ no cambia'
Mi directorio es $HOME y ~ no cambia

Hasta los espacios repetidos se conservan, porque dentro de las comillas el espacio tampoco separa: todo el texto es un solo argumento. Las comillas en sí no llegan al comando; la shell las quita después de usarlas.

La regla no tiene excepciones, y esa es su virtud. La única limitación es consecuencia directa: entre comillas simples no puede escribirse una comilla simple, ni siquiera escapada, porque la barra invertida allí tampoco es especial. Para un texto con apóstrofo se usan las dobles.

13. Las comillas dobles

Las comillas dobles protegen casi todo, con una excepción deliberada: el signo $ sigue funcionando. Dentro de ellas se pueden usar variables y sustituciones, y todo lo demás queda literal.

$ echo "Mi directorio es $HOME"
Mi directorio es /home/ana
$ echo "Soy $(whoami) y los * no se expanden"
Soy ana y los * no se expanden
$ echo "El precio es \$5"           # dentro de las dobles, la barra aún puede escapar al $
El precio es $5

Son las comillas de uso general, porque permiten armar un texto mezclando partes fijas y valores. Esta tabla resume los tres mecanismos, con una misma línea de prueba:

La segunda columna de esta tabla encierra una trampa frecuente: la virgulilla no se expande entre comillas. cd "~/practica" falla, porque busca un directorio llamado literalmente ~. Las soluciones son dejar la virgulilla fuera, cd ~/"practica", o usar la variable, que sí se expande: cd "$HOME/practica".

14. Nombres con espacios

El uso más frecuente de todo esto es el más simple: los nombres de archivo con espacios, que abundan en cualquier sistema donde alguien haya guardado un documento desde un programa gráfico.

$ touch "mis notas.txt"
$ ls -l mis notas.txt               # sin protección: dos argumentos
ls: cannot access 'mis': No such file or directory
-rw-rw-r-- 1 ana ana 0 oct 12 11:40 notas.txt
$ ls -l "mis notas.txt"             # un argumento
-rw-rw-r-- 1 ana ana 0 oct 12 11:52 'mis notas.txt'

El primer ls es instructivo, porque no falló del todo: no encontró mis, y sí encontró notas.txt, que es otro archivo. Con un comando que borra, ese es el accidente. En el segundo, ls muestra el nombre entre comillas para avisar que contiene un espacio; las comillas no forman parte del nombre.

Las tres formas de protegerlo son equivalentes:

En la práctica rara vez se escribe ninguna: se teclean las primeras letras y Tab completa el nombre con las barras necesarias. Las comillas pueden además abarcar solo una parte de la palabra, lo que permite combinarlas con un comodín: ls "mis notas"* protege el espacio y deja libre el asterisco.

Todo esto es la razón del consejo del tema 6: en los archivos que crees tú, guiones en lugar de espacios.

15. Cuando el comodín es para el comando

Hay comandos que entienden patrones por su cuenta, y esperan recibirlos intactos. El caso más importante es find, del tema siguiente, que busca archivos por nombre en todo un árbol de directorios:

$ find /tmp/prueba -name "*.pdf"    # bien: el patrón llega a find
/tmp/prueba/informe.pdf
$ echo find /tmp/prueba -name *.txt # sin comillas: la shell lo expande antes
find /tmp/prueba -name informe.txt lista.txt mis notas.txt notas.txt

La segunda línea, vista a través de echo, muestra el problema. Sin comillas, la shell reemplaza *.txt por los archivos del directorio actual, y find recibe cuatro nombres donde esperaba un patrón: falla, o busca otra cosa. Y si en el directorio actual no hubiera ningún .txt, el patrón pasaría intacto y funcionaría bien: el mismo comando da resultados distintos según dónde se ejecute.

16. Probar antes de actuar

Un patrón es una forma de actuar sobre muchos archivos con pocas teclas. Eso es exactamente lo que lo hace peligroso con los comandos que borran o sobrescriben, que empiezan en el tema 11. Un espacio de más alcanza:

$ echo rm *.pdf                     # lo que se quería
rm informe.pdf
$ echo rm * .pdf                    # con un espacio accidental
rm Datos.csv foto10.jpg foto1.jpg foto2.jpg foto3.jpg informe.pdf informe.txt lista.txt mis notas.txt notas.txt proyecto .pdf

En la segunda línea hay dos patrones: un asterisco solo, que es todo el directorio, y .pdf, un archivo que no existe. rm borraría todo y luego se quejaría de no encontrar .pdf.

La defensa es una costumbre de dos pasos, que no cuesta nada:

1. Mirar primero a qué se expande el patrón, con echo o con ls. ver
2. Leer la lista. ¿Es lo que esperabas? ¿Sobra algo? ¿Falta algo? leer
3. Recuperar la línea con la flecha arriba y cambiar solo el comando, sin volver a escribir el patrón. actuar

El tercer paso es importante: reutilizar el mismo patrón que acabas de comprobar, en lugar de teclearlo otra vez, garantiza que se actúa sobre lo que se vio.

Para terminar, la referencia del tema:

El directorio /tmp/prueba no hace falta borrarlo: desaparecerá con el próximo reinicio. Vuelve a tu directorio personal con cd.

Los comodines encuentran archivos dentro de un directorio conocido. Cuando no se sabe en qué parte del árbol está lo que se busca, hace falta otra herramienta: find, en el tema 10.

17. Resumen

• Antes de ejecutar un comando, la shell reemplaza ciertas construcciones de la línea por otro texto: es la expansión. El comando recibe el resultado.
• echo delante de una línea muestra en qué la convierte la shell, sin ejecutarla.
• * coincide con cualquier cantidad de caracteres; ?, con exactamente uno; [ ], con uno de un conjunto o un rango.
• Los comodines no coinciden con los archivos ocultos ni atraviesan la barra, y si nada coincide el patrón queda sin cambios.
• Los comodines comparan nombres, no contenidos, y no son expresiones regulares.
• Como la expansión la hace la shell, los comodines funcionan igual con todos los comandos.
• Las llaves generan texto sin consultar el disco: sirven para crear varios archivos o directorios en una línea.
• Las demás expansiones empiezan con $: variables, sustitución de comandos y aritmética.
• La barra invertida quita el significado especial al carácter siguiente.
• Las comillas simples dejan todo literal. Las dobles también, salvo el signo $.
• Un nombre con espacios debe protegerse, o la shell lo parte en varios argumentos.
• Un patrón destinado a un comando, como en find -name, se escribe entre comillas.
• Antes de usar un patrón con un comando que borra o sobrescribe, se comprueba a qué se expande.

18. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. En /tmp/prueba, escribe un patrón que coincida solo con foto1.jpg y foto3.jpg, y otro que coincida con todo lo que no termina en .jpg ni en .txt.
2. Con un solo ls, lista los archivos de /etc que terminan en .conf y empiezan con una letra entre la a y la d.
3. Ejecuta ls /usr/bin/*zip* y ls -d /etc/*.d. ¿Para qué hizo falta -d en el segundo?
4. Averigua con echo cuántos comandos de /usr/bin tienen un nombre de exactamente dos caracteres.
5. Usa las llaves para crear en /tmp/prueba, con un solo touch, los archivos informe-01.txt a informe-12.txt.
6. Predice la salida y luego comprueba: echo {a,b}{1,2,3}, echo {10..1}, echo {a..z} y echo {1..10..3}.
7. Muestra con echo, exactamente, el texto: El archivo "$HOME/*.txt" cuesta $10 & más. Hazlo de dos maneras.
8. Crea un archivo llamado mi lista (final).txt y lístalo con ls -l de tres formas distintas. Luego escribe solo ls mi y pulsa Tab.
9. Compara echo *, echo "*", echo '*' y echo \*.
10. Antepone echo a esta línea, sin ejecutarla de otro modo, y explica cada reemplazo: cp ~/practica/*.txt /tmp/copia-$(whoami)/