La Shell de Linux - Parte I: Fundamentos del intérprete de comandos

📅 Actualizado en febrero 2026 ✍️ Ángel López 📊 Nivel: Principiante ⏱️ 25 min de lectura

La shell es la puerta de entrada al verdadero poder de Linux. Mientras que la interfaz gráfica te permite realizar tareas básicas, es en la línea de comandos donde un administrador de sistemas o un desarrollador desbloquea el control total del sistema operativo. En esta primera parte aprenderás qué es la shell, qué tipos existen, cómo funciona su configuración y dominarás las herramientas fundamentales: variables, redirecciones, tuberías y comodines.

🐚 Qué es la shell y para qué sirve

En el contexto de los sistemas operativos tipo Unix, la shell (literalmente «caparazón» o «concha») es un programa que actúa como intérprete de comandos: recibe instrucciones del usuario en forma de texto, las interpreta y las comunica al kernel del sistema operativo para su ejecución. Es, en esencia, la capa que envuelve al núcleo del sistema y permite que los humanos interactúen con él.

La shell cumple dos funciones fundamentales que la convierten en una herramienta indispensable:

1. Intérprete interactivo: cuando abres una terminal y escribes comandos uno a uno, la shell los lee, los analiza sintácticamente, resuelve variables y comodines, y finalmente los ejecuta. Cada vez que pulsas Enter, la shell realiza todo este proceso en milisegundos.

2. Lenguaje de programación: la shell no solo ejecuta comandos individuales, sino que dispone de un lenguaje completo con variables, condicionales (if/else), bucles (for, while), funciones y manejo de errores. Un script de shell es un archivo de texto con extensión .sh que contiene una secuencia de comandos que la shell ejecuta de forma automática.

💡 ¿Sabías que...?
El nombre «shell» fue acuñado por Louis Pouzin en los años 60 para el sistema Multics, antecesor de Unix. La metáfora es precisa: la shell es la capa exterior que envuelve al kernel (núcleo), igual que la concha envuelve al molusco.
Flujo de un comando en la shell
Usuario escribe: ls -la /home │ ▼ Shell (Bash) ├── Analiza sintaxis ├── Expande comodines y variables ├── Busca el ejecutable en $PATH └── Llama al kernel (syscall execve) │ ▼ Kernel Linux → ejecuta /usr/bin/ls │ ▼ Resultado → se muestra en la terminal
Pantalla de terminal con código, representando el entorno de trabajo de la shell de Linux
📸 Terminal mostrando código — Pexels (Licencia libre)

🔄 Tipos de shell: Bash, Zsh, Fish y más

A lo largo de la historia de Unix y Linux se han desarrollado numerosas shells, cada una con sus propias características y filosofía. La elección de shell es una decisión personal que depende de tus necesidades y preferencias, aunque Bash sigue siendo el estándar de facto en la mayoría de distribuciones Linux.

📜 La familia Bourne

La primera shell ampliamente utilizada fue el Bourne Shell (sh), creada por Stephen Bourne en Bell Labs y distribuida con la Versión 7 de Unix en 1979. Su sintaxis sentó las bases que aún hoy se siguen en la mayoría de shells modernas. Todas las shells «tipo Bourne» son compatibles con la sintaxis original de sh.

ShellAutor / AñoCaracterísticas principalesUso típico
sh (Bourne)Stephen Bourne, 1979La original. Sintaxis base de todas las shells tipo BourneScripts POSIX portables
bash (Bourne Again)Brian Fox / GNU, 1989Compatibilidad sh + historial, autocompletado, arrays, aritméticaShell por defecto en la mayoría de distros Linux
dashHerbert Xu, 1997Mínima y rápida. Compatible POSIX. Sin funciones interactivasScripts del sistema (Debian, Ubuntu /bin/sh)
ksh (Korn)David Korn, 1983Arrays asociativos, aritmética de punto flotante, coprocessesEntornos Solaris/AIX, scripting avanzado
zsh (Z Shell)Paul Falstad, 1990Superset de sh/bash. Temas (Oh My Zsh), corrección ortográfica, globbing avanzadoShell por defecto en macOS desde Catalina

🐠 Shells no Bourne

Existen shells que no siguen la sintaxis Bourne y ofrecen enfoques alternativos:

ShellEnfoqueNota clave
csh (C Shell)Sintaxis inspirada en el lenguaje C. Creada por Bill Joy en Berkeley (1978)Histórica. No recomendada para scripting moderno
tcshVersión mejorada de csh con autocompletado y edición de líneaAún popular en algunos entornos BSD
fish«Friendly Interactive Shell». Autosugerencias, colores, sin necesidad de configuraciónNo compatible con POSIX. Ideal para uso interactivo
Descubrir tu shell y las disponibles
# ¿Qué shell estoy usando ahora? echo $SHELL # Shell de login: /bin/bash echo $0 # Shell actual: -bash o bash ps -p $$ # Proceso de la shell activa # Listar todas las shells instaladas en el sistema cat /etc/shells # Cambiar temporalmente a otra shell zsh # Abre una subshell zsh exit # Vuelve a la shell anterior # Cambiar shell de login permanentemente chsh -s /usr/bin/zsh
⚠️ Importante
Si escribes scripts de shell, usa Bash o sh (POSIX) para garantizar la portabilidad. Fish tiene una sintaxis incompatible con POSIX, lo que significa que un script escrito para Fish no funcionará en Bash y viceversa.
Evolución de las shells de Unix/Linux 1979 sh Bourne 1978 csh C Shell 1983 ksh Korn 1989 bash ★ Estándar Linux 1990 zsh Z Shell 2005 fish Friendly 🔗 Familia Bourne (POSIX) sh → bash → dash → ksh → zsh 🐠 No POSIX csh → tcsh · fish (sintaxis propia) Recomendación: Bash para scripts portables, Zsh o Fish para uso interactivo El archivo /etc/shells lista todas las shells disponibles en tu sistema

🖥️ Terminal vs shell vs consola

Estos tres términos se usan a menudo como sinónimos, pero técnicamente son conceptos distintos que conviene diferenciar:

La consola (o consola física) era originalmente un dispositivo de hardware: el teclado y la pantalla conectados directamente al ordenador central. Hoy en día, Linux conserva las consolas virtuales (accesibles con Ctrl+Alt+F1 a F6), que son terminales de texto a pantalla completa sin interfaz gráfica.

El emulador de terminal (o simplemente «terminal») es una aplicación gráfica que simula el comportamiento de una consola hardware. Ejemplos populares son GNOME Terminal, Konsole (KDE), Alacritty, Kitty y Tilix. Todos ellos proporcionan una ventana donde se ejecuta una shell.

La shell es el programa que se ejecuta dentro de la terminal. Es el intérprete que procesa los comandos. Puedes abrir varias terminales usando la misma shell, o una terminal que ejecute una shell diferente.

✅ Analogía útil
Piensa en la terminal como el televisor, la shell como el canal que estás viendo, y la consola como el mando a distancia. Son tres cosas relacionadas pero distintas: el televisor muestra la imagen, el canal genera el contenido, y el mando permite la interacción.

⌨️ El prompt y la anatomía de un comando

Cuando la shell está lista para recibir un comando, muestra un texto llamado prompt (indicador). En Bash, el prompt por defecto tiene este formato:

Anatomía del prompt de Bash
# Prompt estándar de un usuario normal: usuario@hostname:~/documentos$ # Desglose: # usuario → nombre del usuario actual ($USER) # @ → separador # hostname → nombre del equipo ($HOSTNAME) # ~/docs → directorio actual ($PWD, ~ = home) # $ → usuario normal (# si es root) # Prompt de root (superusuario): root@servidor:/etc#

Todo comando en Linux sigue una estructura básica: comando [opciones] [argumentos]. Las opciones (también llamadas flags o banderas) modifican el comportamiento del comando, y los argumentos indican sobre qué objeto actúa.

Estructura de un comando
# Estructura: comando [opciones] [argumentos] ls -la /home/usuario # ls → comando (listar archivos) # -la → opciones (-l largo + -a ocultos) # /home/u → argumento (directorio a listar) # Las opciones se pueden combinar o separar: ls -l -a /home # Separadas ls -la /home # Combinadas (equivalente) # Opciones largas (GNU) usan doble guión: ls --all --human-readable /home # Obtener ayuda sobre cualquier comando: man ls # Manual completo ls --help # Resumen de opciones whatis ls # Descripción de una línea

⚙️ Archivos de configuración de la shell

Bash lee diferentes archivos de configuración según cómo se inicie la sesión. Comprender esta distinción es fundamental para personalizar correctamente tu entorno:

Shell de login (cuando inicias sesión por SSH o en una consola virtual): Bash lee en orden /etc/profile (global), y luego el primero que encuentre de ~/.bash_profile, ~/.bash_login o ~/.profile. Al cerrar la sesión, ejecuta ~/.bash_logout.

Shell interactiva sin login (cuando abres una terminal en el escritorio gráfico): Bash lee /etc/bash.bashrc (global) y ~/.bashrc (del usuario). Este es el archivo que más frecuentemente editarás.

ArchivoTipoCuándo se leeUso típico
/etc/profileGlobalLogin shellsVariables de entorno del sistema, PATH global
~/.bash_profileUsuarioLogin shellsVariables personales, cargar .bashrc
~/.bashrcUsuarioShells interactivas no-loginAliases, funciones, prompt, colores
~/.bash_logoutUsuarioAl cerrar login shellLimpiar pantalla, logs de auditoría
/etc/bash.bashrcGlobalShells interactivasConfiguración para todos los usuarios
~/.bashrc — Ejemplo de configuración personal
# ~/.bashrc — Configuración de Bash # ─── Aliases útiles ─── alias ll='ls -lah --color=auto' alias la='ls -A' alias grep='grep --color=auto' alias ..='cd ..' alias update='sudo apt update && sudo apt upgrade -y' # ─── Prompt personalizado con colores ─── PS1='\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ ' # ─── Historial mejorado ─── HISTSIZE=10000 HISTFILESIZE=20000 HISTCONTROL=ignoreboth shopt -s histappend # ─── Opciones útiles de Bash ─── shopt -s checkwinsize shopt -s cdspell shopt -s autocd # ─── PATH personal ─── export PATH="\$HOME/.local/bin:\$PATH"
✅ Buena práctica
Incluye siempre source ~/.bashrc (o . ~/.bashrc) dentro de tu ~/.bash_profile. Así tanto las shells de login como las interactivas compartirán la misma configuración.

📦 Variables de entorno y del shell

Las variables son nombres que almacenan valores. En la shell, existen dos tipos principales:

Variables de shell (locales): solo existen en la shell actual. No se heredan por los procesos hijos. Se crean con una asignación simple (nombre=valor, sin espacios alrededor del =).

Variables de entorno (exportadas): se heredan por todos los procesos hijos. Se crean con export. Son fundamentales para la configuración del sistema.

Trabajar con variables
# ─── Variables de shell (locales) ─── nombre="Ana" curso="Linux" echo "Hola, $nombre. Bienvenida a $curso" # ─── Variables de entorno (heredadas) ─── export MI_EDITOR="nano" export PROYECTO="/home/ana/web" # ─── Variables predefinidas del sistema ─── echo $HOME # /home/ana (directorio personal) echo $USER # ana (usuario actual) echo $PATH # Directorios donde buscar ejecutables echo $PWD # Directorio actual echo $SHELL # /bin/bash (shell de login) echo $LANG # es_ES.UTF-8 (idioma) echo $? # Código de salida del último comando (0=ok) echo $$ # PID de la shell actual # ─── Ver todas las variables ─── env # Solo variables de entorno set # Todas (shell + entorno + funciones) printenv PATH # Valor de una variable específica # ─── Eliminar una variable ─── unset MI_EDITOR
⚠️ Error frecuente
No dejes espacios alrededor del signo = al asignar variables. nombre = "valor" (con espacios) no funciona en Bash: la shell interpretará nombre como un comando y = y "valor" como argumentos.
Persona escribiendo en un teclado con código en pantalla, representando el trabajo con la shell de Linux
📸 Trabajo en terminal y scripting — Pexels (Licencia libre)

🔀 Redirecciones: stdin, stdout y stderr

Uno de los conceptos más poderosos de la shell de Linux es el sistema de redirecciones. Todo proceso en Unix maneja tres flujos estándar de datos:

FlujoDescriptorNombrePor defecto
stdin0Entrada estándarTeclado
stdout1Salida estándarPantalla
stderr2Salida de erroresPantalla
Operadores de redirección
# ─── Redirigir stdout a un archivo ─── ls -la > listado.txt # Crea o SOBRESCRIBE ls -la >> listado.txt # AÑADE al final # ─── Redirigir stderr (errores) ─── find / -name "*.conf" 2> errores.txt find / -name "*.conf" 2>/dev/null # Descartar errores # ─── Redirigir stdout Y stderr ─── comando &> todo.txt comando > salida.txt 2>&1 # Forma clásica # ─── Separar stdout y stderr ─── comando > salida.txt 2> errores.txt # ─── Redirigir stdin (leer desde archivo) ─── wc -l < /etc/passwd sort < datos.txt > ordenados.txt # ─── Here document (texto multilínea) ─── cat << EOF Esto es un bloque de texto que se pasa como entrada estándar. EOF

🔗 Tuberías (pipes) y encadenamiento

Las tuberías (pipes) son posiblemente la característica más emblemática de Unix. El operador | conecta la salida estándar de un comando con la entrada estándar del siguiente, formando una cadena de procesamiento.

Esta filosofía, conocida como la filosofía Unix («haz una sola cosa y hazla bien»), permite combinar herramientas simples para resolver problemas complejos:

Tuberías en acción
# ─── Tuberías básicas ─── ls -la | grep ".txt" cat /etc/passwd | wc -l # Contar usuarios ps aux | grep "apache" # ─── Cadenas más largas ─── cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -10 # Lee log → extrae IPs → ordena → cuenta únicas → las 10 más frecuentes du -sh /home/* | sort -rh | head -5 # Los 5 directorios más grandes en /home # ─── Operadores de encadenamiento ─── mkdir proyecto && cd proyecto # && ejecuta 2.º solo si 1.º tuvo éxito cat archivo.txt || echo "No existe" # || ejecuta 2.º solo si 1.º falló make build ; make test # ; ejecuta ambos siempre
💡 Dato histórico
El concepto de pipe fue inventado por Douglas McIlroy en 1973 para la tercera versión de Unix. Ken Thompson implementó la primera versión del operador | en una sola noche. McIlroy lo describió como «la idea más importante en Unix».
Flujo de datos en la shell stdin (0) Teclado / < Comando (proceso) stdout (1) → > >> Pantalla / Archivo stderr (2) → 2> Pantalla / Archivo > crear >> añadir 2> errores &> ambos < leer desde

🃏 Expansión de nombres y comodines

Antes de ejecutar un comando, la shell realiza varias expansiones sobre el texto que has escrito. La más visible es la expansión de nombres de archivo (globbing), que permite usar comodines para referirse a múltiples archivos a la vez:

Comodines (globbing)
# ─── Comodín * (cualquier cadena, incluida vacía) ─── ls *.txt # Todos los archivos .txt ls informe_*.pdf # informe_enero.pdf, informe_2024.pdf... rm /tmp/*.log # Eliminar todos los .log en /tmp # ─── Comodín ? (exactamente un carácter) ─── ls archivo?.txt # archivo1.txt, archivoA.txt ls foto_???.jpg # foto_001.jpg, foto_abc.jpg # ─── Corchetes [ ] (conjunto o rango) ─── ls [abc]*.txt # Empiezan por a, b o c ls [0-9]*.log # Empiezan por un dígito ls [!0-9]* # NO empiezan por dígito # ─── Llaves { } (expansión de Bash) ─── echo {1..10} # 1 2 3 4 5 6 7 8 9 10 echo {a..z} # a b c d ... z mkdir proyecto/{src,docs,tests} cp foto.{jpg,bak} # cp foto.jpg foto.bak
⚠️ Cuidado con los comodines
Los comodines se expanden antes de ejecutar el comando. rm * en el directorio equivocado puede ser catastrófico. Usa siempre ls * primero para verificar qué archivos coinciden con tu patrón.

📋 Historial de comandos y atajos

Bash mantiene un registro de todos los comandos que ejecutas en el archivo ~/.bash_history. Este historial es una herramienta de productividad fundamental:

Historial de comandos
# ─── Navegar por el historial ─── # ↑ / ↓ → Comando anterior / siguiente # Ctrl+R → Búsqueda inversa (escribir para filtrar) # ─── Comandos de historial ─── history # Mostrar todo el historial numerado history 20 # Últimos 20 comandos history | grep "ssh" # Buscar en el historial # ─── Reutilizar comandos ─── !! # Repetir el último comando sudo !! # Ejecutar el último con sudo !grep # Último que empieza por grep !42 # Comando número 42 del historial !$ # Último argumento del comando anterior

Bash también ofrece numerosos atajos de teclado que aceleran el trabajo:

AtajoAcciónCategoría
Ctrl+AIr al inicio de la líneaMovimiento
Ctrl+EIr al final de la líneaMovimiento
Ctrl+UBorrar desde cursor hasta inicioEdición
Ctrl+KBorrar desde cursor hasta finalEdición
Ctrl+WBorrar la palabra anteriorEdición
Ctrl+RBúsqueda inversa en historialHistorial
Ctrl+LLimpiar pantallaTerminal
Ctrl+CCancelar comando en ejecuciónControl
Ctrl+DCerrar la shell (EOF)Control
Ctrl+ZSuspender proceso en segundo planoControl
TabAutocompletar comando, archivo o rutaProductividad
TabTabMostrar todas las opciones posiblesProductividad
✅ Truco de productividad
sudo !! es uno de los atajos más útiles. Cuando ejecutas un comando y falla por falta de permisos, simplemente escribe sudo !! para repetirlo como superusuario sin reescribirlo.
Orden de expansiones en Bash 1. Llaves {a,b} {1..5} 2. Tilde ~ → /home/usr 3. Variables $HOME ${v} 4. Sustitución $(cmd) $((1+2)) 5. Globbing * ? [a-z] echo ~/docs/{*.txt,*.md} → tilde → llaves → globbing → archivos reales

📝 Ejercicios prácticos

📋 Ejercicio 1: Descubrir tu entorno
Ejecuta los siguientes comandos y anota los resultados: ¿Qué shell usas? ¿Cuántas shells hay instaladas? ¿Cuál es tu PATH?
💡 Ver solución
Solución ejercicio 1
echo $SHELL # Tu shell de login echo $0 # Tu shell actual cat /etc/shells # Shells instaladas echo $PATH # Directorios de búsqueda echo $HOME # Directorio personal echo $USER # Nombre de usuario
📋 Ejercicio 2: Redirecciones
Crea un archivo con la lista de todos los archivos de /etc, redirige los errores a un archivo separado y cuenta cuántas líneas tiene cada uno.
💡 Ver solución
Solución ejercicio 2
ls -la /etc/ > listado_etc.txt 2> errores_etc.txt wc -l listado_etc.txt errores_etc.txt cat errores_etc.txt
📋 Ejercicio 3: Tuberías
Usando tuberías, encuentra los 5 archivos más grandes en tu directorio /home.
💡 Ver solución
Solución ejercicio 3
find /home -type f -exec du -h {} + 2>/dev/null | sort -rh | head -5
📋 Ejercicio 4: Comodines
En /etc, lista todos los archivos que empiezan por «s», los que tienen exactamente 4 caracteres, y los que terminan en «.conf».
💡 Ver solución
Solución ejercicio 4
ls /etc/s* # Empiezan por s ls /etc/???? # Exactamente 4 caracteres ls /etc/*.conf # Terminan en .conf
📋 Ejercicio 5: Personalizar tu .bashrc
Añade un alias mis_procesos que muestre solo tus procesos activos ordenados por consumo de CPU, y un alias espacio que muestre el uso de disco de tu /home.
💡 Ver solución
Solución ejercicio 5 — Añadir a ~/.bashrc
alias mis_procesos='ps aux --sort=-%cpu | grep "^$USER"' alias espacio='du -sh ~/* 2>/dev/null | sort -rh' # Recargar configuración: source ~/.bashrc

❓ Preguntas frecuentes sobre La Shell de Linux - Parte I: Fundamentos del intérprete de comandos

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

La terminal (o emulador de terminal) es la ventana gráfica donde escribes. La shell es el programa intérprete que procesa tus comandos dentro de esa ventana. Puedes usar distintas shells (Bash, Zsh, Fish) dentro del mismo emulador de terminal.
No. Bash es la más extendida y viene por defecto en la mayoría de distribuciones, pero existen muchas otras: Zsh (por defecto en macOS desde Catalina), Fish (enfocada en usabilidad), Dash (mínima y rápida para scripts), Ksh (Korn Shell) y Tcsh, entre otras.
Ejecuta echo $SHELL para ver tu shell de login, o echo $0 para ver la shell actual. También puedes usar ps -p $$ para ver el proceso de la shell activa. El archivo /etc/shells lista todas las shells instaladas en el sistema.
Sí. Usa el comando chsh -s /ruta/al/shell (por ejemplo, chsh -s /usr/bin/zsh). La nueva shell debe estar listada en /etc/shells. El cambio se aplica en el próximo inicio de sesión.
Un pipe (símbolo |) conecta la salida estándar de un comando con la entrada estándar de otro, permitiendo encadenar comandos. Por ejemplo, ls -la | grep ".txt" lista archivos y filtra solo los que contienen .txt en su nombre.
Las variables de entorno almacenan configuraciones que los programas necesitan para funcionar: PATH indica dónde buscar ejecutables, HOME el directorio del usuario, LANG el idioma del sistema. Son heredadas por los procesos hijos y son fundamentales para el funcionamiento del sistema.
Valora este artículo

💬 Foro de discusión

¿Tienes dudas sobre La Shell de Linux - Parte I: Fundamentos del intérprete de comandos? 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 →