alias: un nome breve per i comandi lunghi

Ogni giorno scrivi ls -lah --color=auto, oppure sudo apt update && sudo apt upgrade, oppure il percorso di un server in ssh. Con alias dai a quel comando un nome corto, per esempio ll o aggiorna, e da quel momento ti basta digitare quello.

Cos'è

alias è un comando interno della shell (come cd e history) che definisce una scorciatoia: un nome che, quando lo scrivi all'inizio di un comando, viene sostituito da un testo più lungo prima dell'esecuzione. Non crea nessun programma e non salva niente da solo: l'alias esiste solo nella sessione del terminale in cui l'hai definito, a meno che tu non lo scriva in un file di configurazione. Gli esempi sono per bash.

Cosa fa

Con alias nome='comando' definisce una scorciatoia; con alias senza argomenti le elenca; con unalias nome la elimina. Prima di eseguire una riga, la shell guarda la prima parola: se coincide con un alias, la sostituisce con il testo corrispondente, e poi esegue il comando risultante, a cui si aggiunge tutto ciò che hai scritto dopo.

Come si usa

$ alias nome='comando [opzioni]'
$ unalias nome

Il testo del comando va tra apici singoli e attorno al segno = non ci sono spazi.

Esempio 1: il primo alias

$ alias ll='ls -lah'
$ ll
totale 48K
drwxr-xr-x 6 enzo enzo 4,0K 25 ott 08.02 .
drwxr-xr-x 3 root root 4,0K  3 set 10.15 ..
-rw-r--r-- 1 enzo enzo  220  3 set 10.15 .bash_logout
-rw-r--r-- 1 enzo enzo 3,7K 20 ott 21.40 .bashrc
$ ll /var/log
$ ll -t

Da ora ll equivale a ls -lah. Tutto ciò che scrivi dopo l'alias viene accodato: ll /var/log diventa ls -lah /var/log, e ll -t diventa ls -lah -t. Se chiudi il terminale, l'alias sparisce (vedi l'esempio 4 per renderlo permanente).

Esempio 2: vedere gli alias esistenti

$ alias
alias egrep='egrep --color=auto'
alias grep='grep --color=auto'
alias ll='ls -alF'
alias ls='ls --color=auto'
$ alias ll
alias ll='ls -alF'
$ type -t ll
alias
$ type -t cd
builtin

Senza argomenti, alias elenca quelli attivi. Molte distribuzioni ne definiscono alcuni di serie (ls con i colori, grep con l'evidenziazione, ll): per questo, un "ls" che mostra i colori è già un alias. Con alias nome si vede la definizione di uno solo. type -t dice di che tipo è un nome: alias, builtin (interno alla shell), file (programma) o function.

Esempio 3: alias utili per tutti i giorni

alias ll='ls -lah'
alias la='ls -A'
alias ..='cd ..'
alias ...='cd ../..'
alias grep='grep --color=auto'
alias dfh='df -h'
alias ports='sudo ss -tulpn'
alias aggiorna='sudo apt update && sudo apt upgrade'
alias mioip='curl -s https://ifconfig.me; echo'
alias meteo='curl -s "wttr.in/Salerno?format=3"'
alias cp='cp -i'
alias mv='mv -i'

Qualche idea, ciascuna già vista negli articoli precedenti: ll e la per ls; .. per salire di una cartella; dfh per df -h; ports per le porte in ascolto con ss; aggiorna per apt; mioip per scoprire il proprio indirizzo pubblico con curl. Gli ultimi due, cp -i e mv -i, chiedono conferma prima di sovrascrivere un file (vedi più avanti i limiti di questa abitudine). Un alias può contenere più comandi con &&, ; e pipe, purché tutto stia dentro gli apici.

Esempio 4: rendere gli alias permanenti

$ nano ~/.bash_aliases
alias ll='ls -lah'
alias aggiorna='sudo apt update && sudo apt upgrade'
$ source ~/.bash_aliases
$ grep -n bash_aliases ~/.bashrc
99:if [ -f ~/.bash_aliases ]; then
100:    . ~/.bash_aliases

Per non ridefinire gli alias a ogni accesso si scrivono in un file che la shell legge all'avvio. Su Debian e Ubuntu il file ~/.bashrc carica già, se esiste, ~/.bash_aliases (come si vede dal secondo comando): è il posto ideale, e si modifica con nano. Altrimenti le righe si possono scrivere direttamente in fondo a ~/.bashrc. Le modifiche valgono per i nuovi terminali; per quello aperto si usa source ~/.bash_aliases (o source ~/.bashrc), che rilegge il file.

Esempio 5: eliminare un alias

$ unalias ll
$ unalias -a
$ alias ll
bash: alias: ll: non trovato

unalias nome elimina un alias per la sessione corrente. unalias -a li elimina tutti. Se l'alias è definito in un file, ricomparirà al prossimo avvio: va tolta anche la riga dal file.

Esempio 6: usare il comando vero e non l'alias

$ alias rm='rm -i'
$ \rm vecchio.txt
$ command rm vecchio.txt
$ /bin/rm vecchio.txt
$ type -a ls
ls è un alias per «ls --color=auto»
ls è /usr/bin/ls

Quando serve il comando originale, senza l'alias, ci sono tre modi: una barra inversa davanti (\rm), la parola command (command rm) o il percorso completo (/bin/rm). Con type -a nome si vedono tutti i significati di un nome, in ordine di priorità: alias, funzioni e programmi. (L'esatto testo dell'output dipende dalla lingua del sistema.)

Esempio 7: alias con virgolette e variabili

$ alias oggi='echo Oggi è $(date +%A)'
$ oggi
Oggi è domenica
$ alias errato="echo Sono in $PWD"
$ cd /tmp
$ errato
Sono in /home/enzo
$ alias giusto='echo Sono in $PWD'
$ giusto
Sono in /tmp

Tra apici singoli il testo viene preso così com'è, e le variabili e le sostituzioni ($PWD, $(date)) si valutano ogni volta che l'alias viene usato. Tra apici doppi la shell le sostituisce subito, al momento della definizione, e l'alias conserva un valore fisso (come nel caso di errato, che resta bloccato alla cartella in cui era stato definito). Per scrivere un apice dentro un alias tra apici singoli conviene usare gli apici doppi all'esterno, oppure una funzione.

Esempio 8: gli alias non accettano argomenti: usa le funzioni

$ alias mkcd='mkdir -p "$1" && cd "$1"'
$ mkcd progetti/nuovo
mkdir: impossibile creare la directory "": File o directory non esistente
$ mkcd() { mkdir -p "$1" && cd "$1"; }
$ mkcd progetti/nuovo
$ pwd
/home/enzo/progetti/nuovo

Un alias è solo una sostituzione di testo: gli argomenti vengono accodati alla fine, non inseriti in un punto qualsiasi, e $1 non funziona (nell'esempio il primo tentativo fallisce). Quando serve un argomento in mezzo al comando, si scrive una funzione, che si definisce nello stesso file degli alias (~/.bash_aliases) e si usa nello stesso modo. Con unset -f mkcd si elimina.

Esempio 9: alias e sudo

$ alias ll='ls -lah'
$ sudo ll /root
sudo: ll: comando non trovato
$ alias sudo='sudo '
$ sudo ll /root

sudo non conosce i tuoi alias: dopo di lui la shell non controlla più se una parola è un alias, e sudo ll fallisce. Un trucco classico è definire alias sudo='sudo ', con uno spazio finale dentro gli apici: questo dice alla shell di controllare anche la parola successiva. Funziona per l'alias che segue sudo, ma non è necessario scrivere sudo davanti ad alias come aggiorna, che lo contiene già.

Esempio 10: dove gli alias non funzionano

$ alias ll='ls -lah'
$ bash -c 'll'
bash: riga 1: ll: comando non trovato
$ echo "ll" > prova.sh && bash prova.sh
prova.sh: riga 1: ll: comando non trovato

Gli alias esistono solo nella shell interattiva in cui sono definiti: non li vedono gli script, cron, i servizi di systemd, i comandi lanciati da find -exec o xargs, né la shell di un altro utente o di una connessione ssh verso un altro computer. Per usarli in uno script, la strada corretta è scrivere il comando completo, o definire una funzione dentro lo script stesso.

Esempio 11: aggiungere alias da uno script

#!/bin/bash
FILE="$HOME/.bash_aliases"

aggiungi() {
    grep -qxF "$1" "$FILE" 2>/dev/null || echo "$1" >> "$FILE"
}

aggiungi "alias ll='ls -lah'"
aggiungi "alias ..='cd ..'"
aggiungi "alias dfh='df -h'"

echo "Alias configurati in $FILE"
echo "Per attivarli: source $FILE"

Un piccolo script per configurare gli alias su un computer nuovo, o su un server. La funzione aggiungi controlla con grep -qxF se la riga esiste già (-q senza output, -x riga intera, -F testo letterale), e la aggiunge solo se manca: eseguendo lo script più volte non si creano duplicati. L'attivazione nella shell corrente va fatta a mano con source, perché uno script non può modificare la shell che l'ha lanciato.

Opzioni utili

• alias / alias -p: elenca tutti gli alias definiti.
• alias nome: mostra la definizione di un alias.
• alias nome='comando': definisce (o ridefinisce) un alias.
• unalias nome: elimina un alias; unalias -a: li elimina tutti.
• type nome, type -a nome, type -t nome: dicono se un nome è un alias, una funzione, un comando interno o un programma.
• command nome e \nome: eseguono il comando ignorando l'alias.
• ~/.bash_aliases / ~/.bashrc: i file dove rendere gli alias permanenti; source file: li ricarica.
• nome() { ...; }: la funzione, per i casi in cui servono argomenti.

Attenzione a

• Niente spazi attorno al segno uguale: alias ll = 'ls -lah' dà errore, perché la shell vede tre parole separate. Si scrive alias ll='ls -lah'.
• Gli alias non sono permanenti da soli: se li definisci nel terminale spariscono alla chiusura. Per tenerli, scrivili in ~/.bash_aliases o ~/.bashrc e ricarica con source.
• Non sostituire comandi con versioni pericolose: un alias come alias rm='rm -rf' o alias cp='cp -f' toglie le protezioni. Al contrario, rm -i e cp -i sembrano prudenti, ma creano un'abitudine rischiosa: sul server, o su un altro computer dove l'alias non esiste, rm cancella senza chiedere. Meglio un nome nuovo (come rmi) che cambiare il significato di quello vecchio.
• Controlla che il nome sia libero: un alias con lo stesso nome di un comando esistente lo "nasconde". Prima di sceglierlo usa type nome o command -v nome: se non risponde nulla, il nome è libero. Se lo sai, è però un modo legittimo di aggiungere opzioni (come per ls e grep con i colori).
• Ricorda cosa hai nascosto: se un comando "si comporta in modo strano" (opzioni che non hai scritto, output diverso), controlla con type -a e alias. Un alias dimenticato è una causa frequente di risultati inattesi, soprattutto quando si copia un comando da una guida.
• Gli alias incidono anche sulle pipe: con alias ls='ls -l', un comando come ls | wc -l o ls | grep ... in un terminale interattivo conta o filtra le righe dell'elenco esteso, non i nomi. Negli script non succede, perché lì gli alias non sono attivi, e questo può dare comportamenti diversi tra la riga di comando e lo script.
• L'alias viene letto con la riga: un alias definito e usato nella stessa riga (alias x='ls'; x) non funziona, perché la shell sostituisce gli alias prima di eseguire la riga. Va definito in un comando precedente.
• Prima parola soltanto: l'alias viene sostituito solo se è la prima parola del comando (o la prima dopo ;, |, &&). Come argomento di un altro comando (per esempio dopo sudo o watch) non viene sostituito.
• Non è sicurezza: un alias non protegge nulla e chiunque può scavalcarlo con \comando o command. Per limitare cosa può fare un utente servono permessi e sudoers.
• Altre shell, altri file: in zsh gli alias si scrivono in ~/.zshrc (con la stessa sintassi); in fish si usano alias e abbr con regole diverse. Un alias sul tuo computer non esiste sui server a cui ti colleghi con ssh: su ogni macchina vanno ricreati (con uno script come quello dell'esempio 11).
• Troppi alias non aiutano: una decina di scorciatoie usate ogni giorno valgono più di cento dimenticate. E se un comando lungo ti serve di rado, la sua ricerca con Ctrl+R (vedi history) può bastare.

Riepilogo