🥇 Metacaracteres en Linux: caracteres especiales

Si alguna vez has escrito ls *.txt en la terminal, ya has usado un metacarácter. Los metacaracteres son símbolos con significado especial para el shell de Linux: no representan un carácter literal sino una instrucción. Dominarlos es lo que separa a un usuario que escribe comandos de uno que realmente habla el idioma de la terminal. En esta guía aprenderás todos los metacaracteres esenciales de Linux, con ejemplos que puedes probar ahora mismo.

🔤 Qué son los metacaracteres

Un metacarácter es cualquier carácter que el shell (normalmente bash) interpreta con un significado especial en lugar de tratarlo como texto literal. Cuando escribes un comando en la terminal, el shell lo procesa antes de ejecutarlo: busca metacaracteres, los interpreta y los sustituye por lo que representan. Este procesamiento previo se llama expansión.

Los metacaracteres de bash se agrupan en varias categorías según su función: comodines (wildcards) para seleccionar archivos por patrones, operadores de redirección para controlar dónde va la salida de un comando, tuberías (pipes) para conectar la salida de un comando con la entrada de otro, operadores de expansión para generar texto dinámicamente, y caracteres de escape y comillas para controlar qué se interpreta y qué se trata como texto literal.

Es importante entender que la interpretación de metacaracteres la hace el shell, no el comando que ejecutas. Cuando escribes ls *.txt, el shell primero expande *.txt en una lista de archivos (por ejemplo, notas.txt informe.txt datos.txt) y luego ejecuta ls notas.txt informe.txt datos.txt. El comando ls nunca ve el asterisco — recibe directamente los nombres de archivo. Comprender este mecanismo es fundamental para usar la terminal con fluidez.

💡 ¿Shell y terminal son lo mismo?

No exactamente. La terminal (o emulador de terminal) es la ventana donde escribes — un programa gráfico como GNOME Terminal, Konsole o Alacritty. El shell es el intérprete de comandos que se ejecuta dentro de esa ventana — normalmente bash, pero puede ser zsh, fish u otro. Los metacaracteres son una función del shell, no de la terminal.

🃏 Comodines (wildcards): *, ? y []

Los comodines (wildcards) son metacaracteres que representan patrones de nombres de archivo. El shell los expande a todos los archivos del directorio actual que coincidan con el patrón. Este proceso se llama globbing.

El asterisco (*): cualquier cosa

El asterisco sustituye cualquier cantidad de caracteres (incluyendo cero caracteres). Es el comodín más usado y más potente.

terminal — comodín *
# Listar todos los archivos .txt
ls *.txt
# Resultado: datos.txt  informe.txt  notas.txt

# Listar archivos que empiecen por "img_"
ls img_*
# Resultado: img_001.jpg  img_002.png  img_portada.webp

# Copiar todos los archivos .log a una carpeta
cp *.log /backup/logs/

# Eliminar todos los archivos temporales
rm *~    # Archivos de backup de editores (terminan en ~)

# El asterisco también funciona en medio
ls foto*2026*.jpg
# Encuentra: foto_enero_2026.jpg  foto_vacaciones_2026_v2.jpg

La interrogación (?): exactamente un carácter

La interrogación sustituye exactamente un carácter, ni más ni menos. Es útil cuando conoces la estructura del nombre pero no un carácter concreto.

terminal — comodín ?
# Archivos con exactamente un carácter antes de .txt
ls ?.txt
# Encuentra: a.txt  1.txt  x.txt  (pero NO notas.txt)

# Archivos con exactamente 3 caracteres de extensión
ls imagen.???
# Encuentra: imagen.jpg  imagen.png  (pero NO imagen.webp)

# Combinar ? con *
ls log_?.*
# Encuentra: log_1.txt  log_A.gz  (exactamente 1 carácter después de log_)

Los corchetes ([]): conjunto de caracteres

Los corchetes definen un conjunto de caracteres posibles para una posición. También pueden definir rangos con el guion.

terminal — comodín []
# Archivos que empiecen por vocal
ls [aeiou]*
# Encuentra: archivo.txt  ejemplo.py  ubuntu.iso

# Archivos con dígito en una posición concreta
ls cap[0-9].pdf
# Encuentra: cap1.pdf  cap5.pdf  cap9.pdf  (NO cap10.pdf)

# Rangos de letras
ls [A-Z]*.txt
# Encuentra archivos .txt que empiecen por mayúscula

# Negación: [!...] o [^...] excluye caracteres
ls [!0-9]*
# Encuentra archivos que NO empiecen por dígito

# Combinar rangos
ls [a-zA-Z0-9]*.conf
# Archivos .conf que empiecen por letra o dígito

⚠️ Cuidado con rm y comodines

El comando rm * elimina todos los archivos del directorio actual sin preguntar. No hay papelera de reciclaje en la terminal Linux. Siempre usa ls con el mismo patrón antes de rm para verificar qué archivos coinciden. Ejemplo: primero ls *.tmp para ver, luego rm *.tmp para borrar.

📤 Redirección de entrada y salida

En Linux, cada comando tiene tres flujos estándar: la entrada estándar (stdin, descriptor 0), la salida estándar (stdout, descriptor 1) y la salida de error (stderr, descriptor 2). Por defecto, stdin lee del teclado, y stdout y stderr muestran en la pantalla. Los operadores de redirección te permiten cambiar estos destinos.

terminal — redirección de salida
# Redirigir stdout a un archivo (sobreescribe)
ls -la > listado.txt
# El resultado de ls se guarda en listado.txt

# Redirigir stdout a un archivo (añadir al final)
echo "Nueva línea" >> registro.log
# Añade "Nueva línea" al final de registro.log

# Redirigir stderr a un archivo
find / -name "*.conf" 2> errores.txt
# Los errores de "Permission denied" van a errores.txt

# Redirigir stdout Y stderr al mismo archivo
make > compilacion.log 2>&1
# Todo (salida normal y errores) va a compilacion.log

# Descartar stderr (enviarlo a la "nada")
find / -name "*.py" 2>/dev/null
# Solo ves los resultados, los errores desaparecen

terminal — redirección de entrada
# Leer entrada desde un archivo en vez del teclado
sort < nombres.txt
# sort ordena el contenido de nombres.txt

# Combinar redirección de entrada y salida
sort < desordenado.txt > ordenado.txt
# Lee de desordenado.txt, guarda resultado en ordenado.txt

# Here document: entrada multilínea inline
cat << EOF
Línea 1 del documento
Línea 2 del documento
Variable: $USER
EOF

Operador	Función	Ejemplo
`>`	Redirige stdout a archivo (sobreescribe)	`ls > lista.txt`
`>>`	Redirige stdout a archivo (añade)	`echo "ok" >> log.txt`
`<`	Redirige stdin desde archivo	`sort < datos.txt`
`2>`	Redirige stderr a archivo	`cmd 2> errores.txt`
`2>&1`	Redirige stderr a donde va stdout	`cmd > todo.log 2>&1`
`&>`	Redirige stdout y stderr juntos (atajo)	`cmd &> todo.log`
`/dev/null`	«Agujero negro»: descarta la salida	`cmd 2>/dev/null`

🔗 Tuberías (pipes): el poder de combinar comandos

La tubería (pipe), representada por el carácter |, es posiblemente el metacarácter más poderoso de Linux. Conecta la salida estándar (stdout) de un comando con la entrada estándar (stdin) del siguiente, permitiéndote crear cadenas de procesamiento donde cada comando transforma los datos antes de pasarlos al siguiente.

Esta filosofía —programas pequeños que hacen una sola cosa bien y que se conectan entre sí— es uno de los principios fundacionales de Unix y Linux. En lugar de tener un programa gigante que lo haga todo, tienes herramientas especializadas que combinadas resuelven problemas complejos con elegancia.

terminal — tuberías en acción
# Buscar líneas con "error" en un log y contarlas
grep "error" /var/log/syslog | wc -l

# Ver los 10 archivos más grandes del directorio
du -sh * | sort -rh | head -10

# Procesos que más CPU consumen
ps aux | sort -nrk 3 | head -5

# Contar archivos .py en todo el proyecto
find . -name "*.py" | wc -l

# Usuarios conectados, ordenados y sin duplicados
who | awk '{print $1}' | sort | uniq

# Cadena compleja: top 5 IPs que más acceden al servidor
cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -5

tee: ver y guardar al mismo tiempo

El comando tee resuelve un problema común: quieres ver la salida en pantalla y guardarla en un archivo al mismo tiempo. Sin tee tendrías que elegir entre una cosa u otra. tee lee la entrada estándar, la escribe en un archivo y además la pasa a la salida estándar, así puedes seguir encadenando pipes.

terminal — tee en acción
# Ver la salida Y guardarla en un archivo
ls -la | tee listado.txt

# tee en medio de una cadena de pipes
cat access.log | grep "404" | tee errores_404.txt | wc -l
# Guarda los errores 404 Y muestra cuántos hay

# Añadir al archivo en vez de sobreescribir
echo "Nuevo registro" | tee -a registro.log

xargs: convertir stdin en argumentos

El comando xargs es el complemento perfecto de las tuberías. Mientras que una tubería conecta la salida de un comando con la entrada estándar del siguiente, xargs convierte esa entrada en argumentos de línea de comandos. Esta distinción es crucial: muchos comandos (como rm, cp, chmod) no leen de stdin sino que esperan los nombres de archivo como argumentos.

terminal — xargs
# Encontrar archivos .tmp y eliminarlos
find /tmp -name "*.tmp" | xargs rm

# Buscar "TODO" en todos los archivos .py del proyecto
find . -name "*.py" | xargs grep "TODO"

# Con -I {} para controlar dónde va cada argumento
find . -name "*.bak" | xargs -I {} mv {} /backup/

# Contar líneas en todos los archivos Python
find . -name "*.py" | xargs wc -l

✅ Truco profesional

Cuando construyas una cadena de pipes, hazlo paso a paso. Ejecuta primero el primer comando solo, verifica la salida, luego añade el siguiente pipe, y así sucesivamente. Esto te permite depurar cada paso y entender exactamente qué transformación aplica cada comando. Es la forma en que trabajan los administradores de sistemas experimentados.

📐 Expansión de llaves, tilde y variables

Además de los comodines, bash realiza otros tipos de expansión antes de ejecutar un comando.

Expansión de llaves {}

Las llaves generan listas de cadenas a partir de un patrón. A diferencia de los comodines, las llaves no dependen de que los archivos existan — generan texto puro.

terminal — expansión de llaves
# Crear varios directorios de una vez
mkdir proyecto/{src,tests,docs,config}
# Crea: proyecto/src  proyecto/tests  proyecto/docs  proyecto/config

# Generar secuencias numéricas
echo {1..10}
# Resultado: 1 2 3 4 5 6 7 8 9 10

# Con paso
echo {0..100..5}
# Resultado: 0 5 10 15 20 25 ... 95 100

# Secuencias de letras
echo {a..z}
# Resultado: a b c d e f ... x y z

# Hacer backup rápido de un archivo
cp config.yml{,.bak}
# Equivale a: cp config.yml config.yml.bak

# Combinar llaves anidadas
mkdir -p app/{frontend/{css,js,img},backend/{api,models}}
# Crea una estructura de directorios completa

Expansión de tilde (~) y variables ($)

terminal — tilde y variables
# La tilde se expande al directorio home
cd ~        # Equivale a: cd /home/usuario
ls ~/Documentos  # Lista archivos en tu carpeta Documentos

# Variables de entorno (se expanden con $)
echo $HOME      # /home/usuario
echo $USER      # tu nombre de usuario
echo $PATH      # rutas de búsqueda de comandos
echo $SHELL     # /bin/bash (tu shell actual)

# Variables propias
nombre="Linux"
echo "Bienvenido a $nombre"
# Resultado: Bienvenido a Linux

# Expansión aritmética
echo $(( 15 * 3 + 7 ))
# Resultado: 52

🛡️ Comillas y escape: controlar la interpretación

A veces necesitas que el shell no interprete un metacarácter — quieres que lo trate como texto literal. Para eso existen tres mecanismos de escape y protección.

terminal — comillas y escape
# COMILLAS DOBLES "..." — permiten expansión de $ y $()
echo "Hola, $USER. Hoy es $(date +%A)."
# Resultado: Hola, ana. Hoy es jueves.

# COMILLAS SIMPLES '...' — todo es literal, nada se expande
echo 'Hola, $USER. Hoy es $(date +%A).'
# Resultado: Hola, $USER. Hoy es $(date +%A).

# BARRA INVERTIDA \ — escapa un solo carácter
echo El archivo cuesta \$100
# Resultado: El archivo cuesta $100

# Usar archivos con espacios en el nombre
cat "mi documento.txt"    # Con comillas dobles
cat mi\ documento.txt     # Con escape en cada espacio

# Mostrar un asterisco literal
echo "El comodín es: \*"
# Resultado: El comodín es: *

Mecanismo	Expande $	Expande *	Expande $()	Uso típico
Comillas dobles ""	Sí	No	Sí	Texto con variables
Comillas simples ''	No	No	No	Texto 100% literal
Barra invertida \	Escapa siguiente	Escapa siguiente	Escapa siguiente	Carácter individual

Globbing extendido (extglob)

Bash ofrece patrones de globbing avanzados activando la opción extglob. Estos patrones permiten lógica más compleja que los comodines básicos: negación, alternancia y cuantificadores.

terminal — globbing extendido
# Activar extglob
shopt -s extglob

# !(patrón) — todo EXCEPTO lo que coincide
ls !(*.log)           # Todo excepto archivos .log
rm !(importante.txt)  # Borra todo MENOS importante.txt

# +(patrón) — una o más coincidencias
ls +(ab).txt          # ab.txt, abab.txt, ababab.txt...

# @(patrón1|patrón2) — exactamente uno de los patrones
ls *.@(jpg|png|gif)   # Solo imágenes jpg, png o gif

# ?(patrón) — cero o una coincidencia
ls archivo?(s).txt    # archivo.txt o archivos.txt

El globbing extendido es especialmente útil para seleccionar archivos por exclusión — algo que los comodines básicos no pueden hacer. El patrón !(*.bak|*.tmp|*.log) selecciona todos los archivos que no sean backups, temporales ni logs.

🔄 Sustitución de comandos

La sustitución de comandos te permite usar la salida de un comando como parte de otro. Se escribe con $(comando) (sintaxis moderna) o con comillas invertidas `comando` (sintaxis antigua, menos legible).

terminal — sustitución de comandos
# Guardar la fecha actual en una variable
hoy=$(date +%Y-%m-%d)
echo "Hoy es $hoy"

# Crear un backup con fecha en el nombre
tar czf backup_$(date +%Y%m%d).tar.gz /datos

# Contar líneas de código en un proyecto
echo "Total: $(find . -name '*.py' | xargs wc -l | tail -1) líneas"

# Instalar paquetes listados en un archivo
sudo apt install $(cat paquetes.txt)

# Usar en condicionales
if [ $(whoami) = "root" ]; then
    echo "Eres root"
fi

⌨️ Caracteres de control en la terminal

Los caracteres de control se generan con combinaciones de teclas Ctrl + y envían señales al proceso en ejecución o al shell. Son esenciales para trabajar con la terminal de forma eficiente.

Combinación	Señal/Acción	Descripción
`Ctrl + C`	SIGINT	Interrumpe (cancela) el proceso en ejecución
`Ctrl + D`	EOF	Envía fin de archivo. Cierra la sesión del shell si la línea está vacía
`Ctrl + Z`	SIGTSTP	Suspende el proceso actual (lo pone en background). Reanudar con `fg`
`Ctrl + L`	clear	Limpia la pantalla del terminal
`Ctrl + A`	—	Mueve el cursor al inicio de la línea
`Ctrl + E`	—	Mueve el cursor al final de la línea
`Ctrl + W`	—	Borra la palabra anterior al cursor
`Ctrl + U`	—	Borra toda la línea antes del cursor
`Ctrl + R`	—	Búsqueda inversa en el historial de comandos

✅ Truco esencial

Ctrl + R es uno de los atajos más útiles y menos conocidos. Al pulsarlo, puedes escribir parte de un comando anterior y bash lo buscará en tu historial. Pulsa Ctrl + R repetidamente para ver coincidencias anteriores. Cuando encuentres el que buscas, pulsa Enter para ejecutarlo. Esto ahorra enormes cantidades de tiempo si trabajas regularmente con la terminal.

⛓️ Encadenamiento de comandos: ;, && y ||

Linux ofrece tres formas de ejecutar múltiples comandos en una sola línea, cada una con un comportamiento diferente respecto al éxito o fracaso de los comandos anteriores.

terminal — encadenamiento de comandos
# PUNTO Y COMA (;) — ejecuta siempre, sin importar errores
cd /proyecto ; make ; make install
# Ejecuta los tres comandos, aunque alguno falle

# DOBLE AMPERSAND (&&) — ejecuta SOLO si el anterior fue exitoso
cd /proyecto && make && make install
# Si cd falla, no ejecuta make. Si make falla, no instala.

# DOBLE PIPE (||) — ejecuta SOLO si el anterior falló
ping -c1 google.com || echo "Sin conexión a Internet"
# Solo muestra el mensaje si el ping falla

# Combinar && y || para if/else simple
test -f config.yml && echo "Existe" || echo "No existe"

# Uso profesional: compilar y notificar
make && echo "✅ Compilación exitosa" || echo "❌ Error de compilación"

# Ejecutar en background con &
python3 servidor.py &
# El comando se ejecuta en segundo plano

Process substitution: <(comando)

La sustitución de procesos es una característica avanzada de bash que te permite usar la salida de un comando como si fuera un archivo. La sintaxis <(comando) crea un archivo temporal virtual que contiene la salida del comando. Esto es extremadamente útil con herramientas como diff, paste o comm que necesitan archivos como argumentos.

terminal — sustitución de procesos
# Comparar la salida de dos comandos como si fueran archivos
diff <(ls dir1) <(ls dir2)
# Muestra las diferencias entre los contenidos de dir1 y dir2

# Comparar paquetes instalados en dos servidores
diff <(ssh server1 "dpkg --list") <(ssh server2 "dpkg --list")

# Poner dos listas lado a lado
paste <(seq 5) <(seq 6 10)
# 1    6
# 2    7
# 3    8
# 4    9
# 5    10

El ampersand (&): procesos en segundo plano

El carácter & al final de un comando lo ejecuta en segundo plano (background), devolviendo inmediatamente el control de la terminal. Esto te permite seguir trabajando mientras un proceso largo se ejecuta. La terminal muestra el PID (identificador del proceso) y el número de trabajo (job).

terminal — procesos en background
# Ejecutar un proceso largo en background
find / -name "*.log" > todos_los_logs.txt 2>/dev/null &
# [1] 12345   ← job número 1, PID 12345

# Descargar un archivo grande en background
wget https://ejemplo.com/imagen.iso &

# Ver trabajos en background
jobs
# [1]+  Running    find / -name "*.log" > todos_los_logs.txt &

# Traer un trabajo de vuelta al foreground
fg %1

# Suspender con Ctrl+Z y luego enviar a background
# (presiona Ctrl+Z mientras un proceso está en foreground)
bg    # Continúa en background

La combinación de & con redirección es un patrón muy común en administración de sistemas. Por ejemplo, al lanzar un servidor o un script de procesamiento de datos, normalmente redirigirás la salida a un archivo de log y lo ejecutarás en background: python3 mi_servidor.py > server.log 2>&1 &. Así la terminal queda libre para otros trabajos y la salida queda registrada en el log.

💡 Referencia rápida de metacaracteres

Los metacaracteres de Linux forman un lenguaje completo para el manejo de datos en la terminal. Los más importantes son: *, ? y [] para seleccionar archivos; >, >>, < y 2> para redirección; | para tuberías; ${} y $() para expansión; "", '' y \ para protección; ;, && y || para encadenamiento; y & para ejecución en background. Con estos símbolos puedes resolver la inmensa mayoría de tareas en la línea de comandos.

🧪 Ejercicios prácticos resueltos

La mejor forma de interiorizar los metacaracteres es practicar. Estos ejercicios están diseñados para que los ejecutes en tu terminal. Si no tienes Linux instalado, puedes usar WSL o una máquina virtual.

Ejercicio 1: Organizar archivos con comodines

terminal — ejercicio 1
# Preparación: crear archivos de prueba
mkdir ~/ejercicio_meta && cd ~/ejercicio_meta
touch informe_{enero,febrero,marzo,abril}.{txt,pdf,csv}
touch foto_{01..15}.jpg nota_{A..F}.md

# Reto 1: Listar solo los informes de febrero (cualquier extensión)
ls informe_febrero.*

# Reto 2: Listar fotos del 01 al 09
ls foto_0?.jpg

# Reto 3: Listar notas de la A a la C
ls nota_[A-C].md

# Reto 4: Mover todos los CSV a una carpeta
mkdir datos && mv *.csv datos/

Ejercicio 2: Pipes y redirección combinados

terminal — ejercicio 2
# Crear un archivo de prueba con datos
for i in {1..100}; do echo "$(shuf -i 1-50 -n1) $(shuf -n1 -e Ana Pedro María Carlos Lucía)"; done > ventas.txt

# Reto 1: ¿Cuántas ventas hizo cada persona?
awk '{print $2}' ventas.txt | sort | uniq -c | sort -rn

# Reto 2: Guardar solo las ventas de Ana en un archivo
grep "Ana" ventas.txt > ventas_ana.txt

# Reto 3: Las 5 ventas más altas, con nombre
sort -rn ventas.txt | head -5

Ejercicio 3: Automatización rápida con llaves

terminal — ejercicio 3
# Crear la estructura completa de un proyecto web
mkdir -p miproyecto/{public/{css,js,img},src/{components,utils},tests,docs}

# Verificar la estructura creada
find miproyecto -type d
# miproyecto
# miproyecto/public
# miproyecto/public/css
# miproyecto/public/js
# miproyecto/public/img
# miproyecto/src
# miproyecto/src/components
# miproyecto/src/utils
# miproyecto/tests
# miproyecto/docs

✅ Siguiente paso

Ahora que dominas los metacaracteres, el siguiente paso natural es aprender expresiones regulares, que llevan el concepto de patrones a un nivel mucho más potente. Mientras que los comodines operan sobre nombres de archivos, las expresiones regulares operan sobre el contenido de los archivos y se usan con herramientas como grep, sed y awk. También puedes profundizar en scripting bash, donde todos estos metacaracteres se combinan para crear programas automatizados.

✅ Dominar la terminal es un proceso gradual

No intentes memorizar todos los metacaracteres de golpe. Empieza por los comodines (*, ?) y la redirección (>, >>), que son los que usarás a diario. Después incorpora las tuberías (|) y el encadenamiento (&&). Con el tiempo, las expansiones de llaves, la sustitución de comandos y el globbing extendido se convertirán en herramientas naturales de tu flujo de trabajo. Practica con los ejercicios de esta página, revisa los editores de texto para escribir tus propios scripts, y antes de que te des cuenta estarás construyendo pipelines complejos con la misma naturalidad con la que escribes un correo electrónico.

❓ Preguntas frecuentes sobre Metacaracteres y caracteres especiales en Linux: guía completa

Las dudas más comunes respondidas de forma clara y directa.

El asterisco (*) sustituye cualquier cantidad de caracteres (incluyendo cero), mientras que la interrogación (?) sustituye exactamente un solo carácter. Por ejemplo, *.txt encuentra todos los archivos .txt, mientras que archivo?.txt solo encuentra archivo1.txt, archivoA.txt, etc. (un solo carácter después de "archivo").

El operador > redirige la salida a un archivo, sobreescribiendo su contenido si ya existe. El operador >> añade la salida al final del archivo sin borrar el contenido existente (append). Usar > en un archivo con datos los perderás; usar >> los preserva.

Sí, puedes encadenar tantos comandos como necesites. Por ejemplo: cat archivo.log | grep "ERROR" | sort | uniq -c | sort -rn encadena cinco comandos para buscar errores, ordenarlos y contar las ocurrencias únicas. No hay límite práctico en el número de pipes.

Las comillas simples (') preservan todo literalmente: nada se interpreta ni expande. Las comillas dobles (") permiten la expansión de variables ($variable) y la sustitución de comandos ($(comando)). Usa comillas simples cuando quieras texto literal exacto, y dobles cuando necesites incluir variables.

El operador 2>&1 redirige la salida de error estándar (stderr, descriptor 2) al mismo destino que la salida estándar (stdout, descriptor 1). Es útil cuando quieres capturar tanto la salida normal como los errores en un mismo archivo o tubería. Por ejemplo: comando > log.txt 2>&1 guarda todo en log.txt.

Globbing es el mecanismo por el cual el shell (bash, zsh) expande los comodines (*, ?, []) en nombres de archivos reales antes de ejecutar el comando. Si escribes ls *.txt, el shell primero busca todos los archivos que terminen en .txt y luego pasa esa lista al comando ls. El comando nunca ve el asterisco; recibe los nombres ya expandidos.

💬 Foro de discusión

¿Tienes dudas sobre Metacaracteres y caracteres especiales en Linux: guía completa? Comparte tu pregunta con la comunidad.

¿Tienes cuenta? o comenta como invitado ↓

Todavía no hay mensajes. ¡Sé el primero en participar!

🚀 ¿Quieres dominar Linux profesionalmente?

Cursos bonificados por FUNDAE para empresas — formación 100% subvencionada

Ver cursos de Linux →

Metacaracteres y caracteres especiales en Linux: guía completa

🔤 Qué son los metacaracteres

🃏 Comodines (wildcards): *, ? y []

El asterisco (*): cualquier cosa

La interrogación (?): exactamente un carácter

Los corchetes ([]): conjunto de caracteres

📤 Redirección de entrada y salida

🔗 Tuberías (pipes): el poder de combinar comandos

tee: ver y guardar al mismo tiempo

xargs: convertir stdin en argumentos

📐 Expansión de llaves, tilde y variables

Expansión de llaves {}

Expansión de tilde (~) y variables ($)

🛡️ Comillas y escape: controlar la interpretación

Globbing extendido (extglob)

🔄 Sustitución de comandos

⌨️ Caracteres de control en la terminal

⛓️ Encadenamiento de comandos: ;, && y ||

Process substitution: <(comando)

El ampersand (&): procesos en segundo plano

🧪 Ejercicios prácticos resueltos

Ejercicio 1: Organizar archivos con comodines

Ejercicio 2: Pipes y redirección combinados

Ejercicio 3: Automatización rápida con llaves

❓ Preguntas frecuentes sobre Metacaracteres y caracteres especiales en Linux: guía completa

💬 Foro de discusión

🔑 Recuperar contraseña

Crear cuenta

¿Cómo valorarías tu experiencia aprendiendo en esta sección?

¡Gracias por tu valoración!

🔤 Qué son los metacaracteres

🃏 Comodines (wildcards): *, ? y []

El asterisco (*): cualquier cosa

La interrogación (?): exactamente un carácter

Los corchetes ([]): conjunto de caracteres

📤 Redirección de entrada y salida

🔗 Tuberías (pipes): el poder de combinar comandos

tee: ver y guardar al mismo tiempo

xargs: convertir stdin en argumentos

📐 Expansión de llaves, tilde y variables

Expansión de llaves {}

Expansión de tilde (~) y variables ($)

🛡️ Comillas y escape: controlar la interpretación

Globbing extendido (extglob)

🔄 Sustitución de comandos

⌨️ Caracteres de control en la terminal

⛓️ Encadenamiento de comandos: ;, && y ||

Process substitution: <(comando)

El ampersand (&): procesos en segundo plano

🧪 Ejercicios prácticos resueltos

Ejercicio 1: Organizar archivos con comodines

Ejercicio 2: Pipes y redirección combinados

Ejercicio 3: Automatización rápida con llaves

❓ Preguntas frecuentes sobre Metacaracteres y caracteres especiales en Linux: guía completa

💬 Foro de discusión

Iniciar sesión

🔑 Recuperar contraseña

Crear cuenta