This is a read-only archive. Find the latest Linux articles, documentation, and answers at the new!

Feature: Shell & CLI

Save time at the command line with shell aliases and functions

By Marco Fioretti on September 16, 2008 (9:00:00 AM)

Share    Print    Comments   

Familiarity with command prompts and shell scripts is still necessary if you want to get the most from your GNU/Linux system, but the less time you spend doing that the better, right? Two powerful ways to minimize your time at the command line are shell aliases and functions.

The examples that follow are for the bash shell, but all the concepts and most of the code are valid for other shells too.

Shell aliases are alternative, easy-to-remember names for long commands that you need to execute frequently. When you type at the command line, the shell first looks for what you wrote in its list of aliases. If it finds a match, it replaces the alias with its corresponding text; after that, it looks again at the whole resulting command line and executes it. Here are some examples of aliases definitions:

alias sqlmanage='mysql -p -u my_MySQL_userid MySQL_database_name' alias ssh2rws='ssh -p port_number my_remote_userid@my.remote.web.server' alias findbig='find . -type f -exec ls -s {} \; | sort -n -r | head -5' alias cof='clear;ls -lrt'

The first two replace the much longer strings one would need to connect to a local MySQL database and to a remote server. The third finds the five biggest files in the current directory tree. The last alias, while simpler and shorter than the others, is more flexible. Due to the way aliases are replaced, you could use "cof" to list any group of files or directories, oldest files first:

cof # clear screen, list content of current directory cof /tmp /usr # clear screen, list contents of /tmp and /usr cof *.jpg # clear screen, list all .jpg files in this folder

You can define aliases at the prompt during a shell session, but they're more useful if you make them permanent by defining them inside your system or personal shell configuration file (/etc/bashrc or $HOME/.bashrc). To know which aliases are already defined in your shell, just type alias at the prompt.

As handy as they are, aliases have some limits and gotchas. To begin with, they are not expanded when the shell is not interactive, unless you set the proper options (see the bash man page). Also, the shell loads at least one complete line of input, then replaces aliases, and only after that executes the whole resulting command. This means that you can use more than one predefined alias in the same line, though this may have unpredictable results, but you cannot define an alias and then use it in the same line. For the same reason, bad things may happen if you try to define aliases inside shell functions. To stay on the safe side, never mix alias definitions with anything else in the same line: don't use or define aliases in compound commands or code blocks executed only when some condition is met.

Beyond aliases: Shell functions

Aliases cannot replace blocks of similar but not identical codes. They cannot handle errors nor return custom exit codes, do flow control, or use variables. If you need to do any of these, it's time to learn how to use shell functions.

Shell functions are code blocks structured as complete sub-scripts, written once and invoked from any script that needs it. There are two equivalent ways to declare a function in bash. The first uses the function keyword, while the second replaces it with parentheses:

function my_function { code } my_function () { code }

Whichever syntax you prefer, remember that the definition must precede the first call to the function. You can also nest a function within another function, or write recursive functions. Inside functions you can use pretty much any construct available in your shell of choice; what requires special care in the code of a function is how it interacts with the script that uses it.

A script can use a function only if it is defined and predeclared in the script itself, or if it was already known in the shell that launched it. You can create and load functions in at least four (conceptually) different ways. One is to just type them at the command line as you would inside a script. A permanent alternative is to save all your functions into one file and then load that file with the '.' command from the command line or any script.

You can declare functions inline in the weirdest places: this shell prompt customization trick defines a function inside the shell prompt itself. You can even simulate different versions of a function that depend on other variables:

if [ "$USER" eq "root" ] then . /etc/ else . /etc/ fi backup_all_files # depends on user

The backup_all_files function that will be executed will be the one written inside /etc/ if the script is run by root, and the one inside /etc/ in all other cases. Beware: when a function is defined multiple times, the final version is the one that is invoked.

The arguments passed to a function are placed inside special variables named $1, $2, and so on. A special array called $@ contains all the input arguments. Limit yourself to using $1, $2, and so on only when your function has a fixed number of arguments. With functions whose number of arguments may change at every call, and with recursive functions, work on one parameter at a time instead, pulling each out from $@:

function partition_maintenance { for partition in $@ do #do something to the current partition done }

Return an exit status from all your functions, because it is useful for diagnostic purposes. To do so, use the return keyword:

function check_treshold { if [ $SOME_VAR -gt 40 ] ; then echo 5; return 5; else echo 4; return 4 ; fi }

Running a function like this will put 4 into the special $? shell variable if SOME_VAR is less than 40. Remember that you can return only numerical values. To return strings or arrays you must either echo the function result and assign it to a variable with backticks:


or pass that variable by reference to the function, which will modify it with an eval statement:

function set_variable { eval "$1=$2" }

In this case, the command "set_variable WEBSITE" (note the absence of dollar signs!) will assign to $WEBSITE.

To become more productive with shell functions, you also need to know when not to use them. This simple shell script shows three different ways to make calculations without a function and one way not to do it:

#! /bin/bash MY_VAR=40 echo 0: $MY_VAR MY_VAR=`expr $MY_VAR - 10` echo 1: $MY_VAR MY_VAR=$(($MY_VAR + (5**2 /2))) echo 2: $MY_VAR let MY_VAR="$MY_VAR + 7" echo 3: $MY_VAR MY_VAR="$MY_VAR + 7" # this is a string assignment, not a calculation echo 4: $MY_VAR

The output shows that functions are great, but necessary for arithmetic only if you have to deal with long, constant series of formulas:

0: 40 1: 30 2: 42 3: 49 4: 49 + 7

Marco Fioretti is the author of The Family Guide to Digital Freedom and contributes regularly to and other IT magazines.

Share    Print    Comments   


on Save time at the command line with shell aliases and functions

Note: Comments are owned by the poster. We are not responsible for their content.

ssh alias

Posted by: Anonymous [ip:] on September 16, 2008 09:15 PM
Good article in overall, but this line has caught my attention:
> alias ssh2rws='ssh -p port_number my_remote_userid@my.remote.web.server'
This, in particular should be solved by ~/.ssh/config which is a ssh client config file. See ssh_config(5) for more details, but this particular case would be served like:
Host rws
HostName my.remote.web.server
User my_remove_userid
Port port_number
And then you just type "ssh rws".


Re: ssh alias

Posted by: Anonymous [ip:] on September 17, 2008 09:38 AM
Good article in overall, but this line... should be solved by ~/.ssh/config

absolutely correct of course. That's one alias I created long, long time ago, before getting more familiar with ssh configuration, and then simply remained in my bashrc file. When I wrote the article, I choose a few aliases as complex and as much different as possible from each other to illustrate the possibilities, and so that one resurfaced.

Thanks for your compliments,
Marco F.


Save time at the command line with shell aliases and functions

Posted by: Anonymous [ip:] on September 18, 2008 11:03 AM
This is my set of aliases

Changing directoryes

make_and_cd_to_directory ()
mkdir -p "$1" && cd "$1"

alias ..='cd ..'
alias ...='cd ../..'
alias mcd='make_and_cd_to_directory '

# show only directories in ./
alias lsd='ls -d */'

# several file listings
alias lA='ls -A'
alias la='ls -a'
alias ll='ls -l'
alias llA='ls -lA'
alias lla='ls -la'
alias lld='ls -l | grep ^d'
alias lls='ll -S'
alias llt='ll -t'
alias ls='ls --color=auto'

# Open multiple files in tabs
alias gvim='gvim -p'


This story has been archived. Comments can no longer be posted.

Tableless layout Validate XHTML 1.0 Strict Validate CSS Powered by Xaraya