Guía completa de alias en Linux: haz tu shell 10 veces más rápido

alias ll='ls -alh' — esa es la idea básica. Dale un nombre corto a un comando largo. Escríbelo en .bashrc o .zshrc para hacerlo permanente, y usa funciones de shell cuando necesites argumentos.

Si trabajas en la terminal regularmente, seguro has escrito los mismos comandos docenas de veces. git status. docker-compose up -d. cd /home/user/projects/myapp/frontend/src.

Todo eso puede convertirse en un alias. Esta guía cubre todo lo que necesitas saber sobre el comando alias — desde lo básico hasta patrones avanzados, colecciones de atajos del mundo real e integración con oh-my-zsh.

¿Qué es un alias?

Un alias es un atajo: le das un nombre más corto a un comando largo o complejo, y usas ese nombre en su lugar. macOS y la mayoría de distribuciones Linux vienen con varios alias ya definidos. Consulta el Manual de GNU Bash — Aliases para la especificación completa. Ejecuta alias sin argumentos para verlos:

alias

Salida típica en Ubuntu:

alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'

Así que ll es un atajo para ls -alF. Dos caracteres en lugar de ocho, y obtienes un listado detallado con colores e indicadores.

Sintaxis básica

alias nombre='cadena de comando'

Algunas cosas a tener en cuenta:

• Sin espacios alrededor de = — eso es un error de sintaxis
• Envuelve el comando entre comillas simples o dobles si contiene espacios u opciones
• Las comillas simples evitan la expansión de variables; las dobles la permiten

Ejemplos rápidos para empezar:

alias ll='ls -alh --color=auto'
alias la='ls -A'
alias ..='cd ..'
alias ...='cd ../..'
alias gs='git status'

Ejecuta estos en tu terminal y funcionan inmediatamente — pero solo para la sesión actual. Cierra la terminal y desaparecen.

Hacer alias permanentes: .bashrc y .zshrc

Para mantener tus alias entre sesiones, escríbelos en el archivo de configuración de tu shell.

Primero, verifica qué shell estás usando:

echo $SHELL

• bash → ~/.bashrc (shell interactivo) o ~/.bash_profile (shell de login)
• zsh → ~/.zshrc

Abre el archivo en tu editor preferido:

# vim
vim ~/.bashrc

# nano (más fácil para principiantes)
nano ~/.bashrc

# VS Code
code ~/.bashrc

Añade tus alias al final. Personalmente me resulta útil agruparlos con un comentario:

# ===========================
# Mis Alias
# ===========================

# Navegación
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias home='cd ~'
alias proj='cd ~/projects'

# Atajos de ls
alias ll='ls -alh --color=auto'
alias la='ls -A --color=auto'
alias lt='ls -lt --color=auto'    # ordenar por tiempo
alias lz='ls -lS --color=auto'    # ordenar por tamaño

# Atajos comunes
alias c='clear'
alias h='history'
alias q='exit'
alias reload='source ~/.bashrc'   # o source ~/.zshrc para zsh

Después de guardar, aplica los cambios a la sesión actual:

source ~/.bashrc
# o
. ~/.bashrc

Colecciones útiles de alias

Git

Si usas Git a diario, estos te ahorrarán una cantidad significativa de escritura:

# Git básico
alias gs='git status'
alias ga='git add'
alias gaa='git add .'
alias gc='git commit -m'
alias gca='git commit -am'
alias gp='git push'
alias gpl='git pull'
alias gd='git diff'
alias gl='git log --oneline --graph --decorate'
alias gb='git branch'
alias gco='git checkout'
alias gcb='git checkout -b'
alias gst='git stash'
alias gstp='git stash pop'

# Operaciones compuestas
alias gpush='git push origin $(git branch --show-current)'
alias gundo='git reset --soft HEAD~1'    # deshacer último commit, conservar cambios
alias gclean='git restore .'             # descartar todos los cambios del árbol de trabajo (sintaxis moderna, Git 2.23+)

Docker y Docker Compose

alias d='docker'
alias dc='docker compose'
alias dcu='docker compose up -d'
alias dcd='docker compose down'
alias dcr='docker compose restart'
alias dcl='docker compose logs -f'
alias dps='docker ps'
alias dpsa='docker ps -a'
alias dclean='docker system prune -f'

# Entrar a un contenedor en ejecución
dexec() {
  docker exec -it "$1" bash
}

Administración del sistema

# Red
alias myip='curl -s ifconfig.me'
alias localip='ip addr show | grep "inet " | grep -v 127.0.0.1'

# Disco y memoria
alias df='df -h'
alias du='du -sh'
alias free='free -h'

# Búsqueda de procesos
alias psg='ps aux | grep'     # uso: psg nginx

# Verificar qué proceso usa un puerto
portcheck() {
  lsof -i :"$1"
}

# Búsqueda de archivos
alias ff='find . -name'       # uso: ff "*.log"

Desarrollo

# Node.js / npm
alias ni='npm install'
alias nid='npm install --save-dev'
alias nr='npm run'
alias ns='npm start'
alias nt='npm test'
alias nb='npm run build'

# Python
alias py='python3'
alias pip='pip3'
alias venv='python3 -m venv venv && source venv/bin/activate'
alias activate='source venv/bin/activate'

# Servidor HTTP local rápido
alias serve='python3 -m http.server 8080'

Funciones de shell: cuando los alias no son suficientes

Los alias no manejan bien los argumentos. Cuando necesitas pasar argumentos, usa una función de shell en su lugar. Van en el mismo archivo .bashrc / .zshrc:

# Crear un directorio y entrar en él inmediatamente
mkcd() {
  mkdir -p "$1" && cd "$1"
}

# Buscar contenido de archivos recursivamente
# (nombrado rgfind para no sobreescribir el comando del sistema fgrep)
rgfind() {
  grep -r "$1" . --include="$2"
}
# uso: rgfind "TODO" "*.js"

# Crear un respaldo con fecha de un archivo
bak() {
  cp "$1" "$1.bak_$(date +%Y%m%d_%H%M%S)"
}
# uso: bak config.json → crea config.json.bak_20260227_143022

# Terminar lo que esté corriendo en un puerto
killport() {
  lsof -t -i:"$1" | xargs kill -9
}
# uso: killport 3000

oh-my-zsh: obtén cientos de alias al instante

Si usas zsh con oh-my-zsh, puedes activar plugins que añaden una gran cantidad de alias bien diseñados sin tener que escribirlos tú mismo.

Edita la línea plugins=(...) en ~/.zshrc:

plugins=(
  git
  docker
  docker-compose
  npm
  python
  z
)

El plugin git solo añade más de 150 alias — gst para git status, gco para git checkout, y así sucesivamente. Puedes consultar la lista completa de alias del plugin git o ejecutar alias | grep ^g para ver cuáles están activos.

El plugin z te permite saltar a cualquier directorio previamente visitado escribiendo parte de su nombre. Una alternativa más potente es zoxide, que también está disponible como plugin de oh-my-zsh:

z proj   # salta a ~/projects si has estado ahí antes

Gestionar tus alias

Verificar qué hace un alias específico

alias gs
# salida: alias gs='git status'

Evitar temporalmente un alias

Si un comando está reemplazado por un alias y quieres ejecutar el original, precédelo con \:

# Aunque ls tenga alias, esto ejecuta el ls real sin color
\ls

Eliminar un alias

unalias gs        # eliminar el alias gs
unalias -a        # eliminar TODOS los alias (usar con precaución)

Flujo seguro para editar .bashrc

# Hacer respaldo primero
cp ~/.bashrc ~/.bashrc.backup

# Editar
vim ~/.bashrc

# Verificar errores de sintaxis (solo bash)
bash -n ~/.bashrc

# Aplicar si no hay errores
source ~/.bashrc

Técnicas avanzadas

Depurar alias con type y command -v

Cuando un comando no se comporta como esperas, verifica si es un alias, una función o un binario con type:

type ls
# ls is aliased to 'ls --color=auto'

type mkcd
# mkcd is a function

type grep
# grep is aliased to 'grep --color=auto'

type curl
# curl is /usr/bin/curl

En scripts, command -v es más portable para verificar si un comando existe:

if command -v docker &>/dev/null; then
  alias dc='docker compose'
fi

Alias condicionales por sistema operativo

Cuando compartes el mismo .bashrc entre macOS y Linux, algunos comandos difieren entre plataformas. Usa $OSTYPE para ramificar:

case "$OSTYPE" in
  linux*)
    alias open='xdg-open'
    alias pbcopy='xclip -selection clipboard'
    alias pbpaste='xclip -selection clipboard -o'
    ;;
  darwin*)
    alias ls='ls -G'
    alias readlink='greadlink'  # brew install coreutils
    ;;
esac

Un solo conjunto de dotfiles, funciona en ambas plataformas.

Archivo separado de alias

A medida que tu colección de alias crece, mantén .bashrc limpio moviendo los alias a un archivo dedicado:

# Añadir al final de ~/.bashrc
if [ -f ~/.aliases ]; then
  source ~/.aliases
fi

Pon todos los alias en ~/.aliases. Esto también facilita la gestión cuando compartes dotfiles en un equipo.

Solo zsh: alias globales (alias -g)

En zsh, alias -g define alias que se expanden en cualquier parte del comando — no solo al principio. Útil para acortar cadenas de pipes:

# solo zsh
alias -g L='| less'
alias -g G='| grep'
alias -g H='| head'
alias -g T='| tail'
alias -g C='| wc -l'
alias -g J='| jq .'
alias -g S='| sort'
alias -g U='| sort -u'

Uso:

ps aux G nginx      # → ps aux | grep nginx
cat access.log C    # → cat access.log | wc -l
curl -s api.example.com/data J  # → ... | jq .

Esta función no existe en bash. Los usuarios de bash pueden lograr resultados similares con funciones.

Solo zsh: alias de sufijo (alias -s)

alias -s de zsh asigna un programa predeterminado a extensiones de archivo:

# solo zsh
alias -s json='code'
alias -s md='code'
alias -s log='less'
alias -s py='python3'
alias -s html='open'

# Solo escribe el nombre del archivo para abrirlo con el programa asignado
config.json    # → code config.json
README.md      # → code README.md
error.log      # → less error.log

Problemas comunes

"command not found" después de añadir un alias

Probablemente olvidaste ejecutar source ~/.bashrc. También verifica errores tipográficos — asegúrate de que no haya espacios alrededor del signo =.

alias | grep nombredelias

Rutas con espacios causan errores

Siempre pon entre comillas las rutas que contienen espacios:

# Mal
alias mydir='cd /home/user/My Projects'

# Bien
alias mydir='cd "/home/user/My Projects"'

Usar un alias dentro de otro

Los alias solo se expanden un nivel de profundidad por defecto. Si necesitas referenciar otro alias dentro de un alias, usa una función en su lugar.

Artículos relacionados

• Herramientas CLI modernas en Rust — exa, bat, fd, ripgrep — las herramientas modernas que querrás crear alias
• Guía práctica de tmux — tmux + alias para un flujo de trabajo en terminal aún más eficiente
• Guía práctica de fzf — combina fzf con alias para búsqueda difusa instantánea
• Kit de herramientas CLI — el panorama general de herramientas CLI y cuándo usar cada una

FAQ

¿Cuál es la diferencia entre un alias y una función de shell?

Un alias es una sustitución simple de texto — no puede manejar argumentos de forma flexible ni incluir lógica como condicionales y bucles. Usa alias para atajos simples como alias gs='git status'. Usa funciones cuando necesites argumentos: mkcd() { mkdir -p "$1" && cd "$1"; }.

¿Cómo depuro un alias que no funciona?

Empieza con type nombre_alias para verificar su estado actual. Si dice "not found", probablemente olvidaste ejecutar source ~/.bashrc. Verifica si el alias está definido con alias | grep nombre_alias, y valida la sintaxis de tu archivo de configuración con bash -n ~/.bashrc.

¿Los alias se escriben diferente en bash y zsh?

La sintaxis básica es idéntica: alias nombre='comando' funciona en ambos. La diferencia son las funciones exclusivas de zsh — alias -g (alias globales) y alias -s (alias de sufijo) solo funcionan en zsh.

¿Qué hago cuando tengo demasiados alias para gestionar?

Muévelos a un archivo dedicado como ~/.aliases y cárgalo desde .bashrc con source ~/.aliases. También puedes dividir por categoría: ~/.aliases_git, ~/.aliases_docker, etc. Consulta la guía de gestión de dotfiles para más detalles.

¿Por qué mis alias no funcionan con sudo?

sudo ejecuta comandos en un nuevo contexto de shell, así que los alias de tu shell actual no se heredan. Define alias sudo='sudo ' (nota el espacio al final) — esto le dice a bash que también busque expansión de alias en el comando que sigue a sudo.

¿Qué pasa cuando los alias de plugins de oh-my-zsh entran en conflicto con los míos?

La última definición gana. En .zshrc, tus alias personalizados se definen después de cargar los plugins, así que normalmente los tuyos tienen prioridad. Verifica la definición actual con alias | grep nombre_alias.

Conclusión

Los alias sirven para dos cosas: comandos que escribes constantemente y opciones que nunca recuerdas. Empieza con solo unos pocos, y añade más cada vez que te pilles escribiendo lo mismo repetidamente.

Empieza ahora mismo:

1. Ejecuta alias para ver qué ya está definido
2. Abre ~/.bashrc o ~/.zshrc y añade tu propia sección de alias
3. Ejecuta source ~/.bashrc para aplicar los cambios

Una vez que tengas un buen conjunto de alias, pasa a las funciones de shell para todo lo que necesite argumentos. Con el tiempo, tu configuración de shell se convierte en una herramienta de productividad adaptada exactamente a tu forma de trabajar.

Artículos relacionados:

• Guía completa de fzf: búsqueda difusa que lo cambia todo
• Guía completa de tmux: multiplexación de terminal para desarrolladores
• Herramientas CLI modernas en Rust: eza, bat, fd, zoxide y más
• El kit de herramientas CLI del desarrollador: un mapa completo