Alias, Variable, Function, or Script?

First of all, note that this question cannot be asked in Windows. The standard Windows command line shell has neither aliases nor functions, so it’s a script or nothing. They are implemented in the UNIX/Linux/OS/X shells, though. Aliases, variables, functions, and scripts are different ways of executing code that you don’t want to type out time time, but each has a slightly different purpose:

Aliases

An alias is simply a word-processing-style substitution of one text string for another in command position. If you define
```
>alias foo="blah blah blah"
```
then
```
>foo John
```
will be executed as if you had typed blah blah blah John. Note that for this to happen, the alias must be the first thing on the command line. If you type
```
>John foo Dierdorf
```
then what you see is what you get — no substitution will take place. Among other things, this means that any arguments on the command line will always be at the end after the alias is expanded, which severely limits what can be accomplished. For example, suppose you want to write a shortcut that will copy a file to a backup directory. It is not possible to create an alias to do this; you need to have mybackup myfile expand to cp myfile backupdir, but your argument (myfile) cannot go in the middle of an alias expansion.
Here’s another example. Suppose that any time you start acroread from the command line, you want it to start in the background. That is, you want the line ac myfile.pdf to expand into acroread myfile.pdf &. This cannot be done, because there’s no way (using an alias) to slip the argument in before the ampersand.
It is possible to have an alias expand to more than one command, though. Simply separate the commands with semicolons. For example,
```
>alias agud="sudo apt-get update; sudo apt-get dist-upgrade"
```
will work just fine. This can be fairly complicated; for example I have an alias for synchronizing my Calibre library between my desktop and laptop:
```
>alias unical='if [[ -d /dell/CalibreLibrary ]] then unison-gtk -times
/dell/CalibreLibrary ~/CalibreLibrary; else echo "Dell not mounted";fi'
```
If an alias definition ends with a trailing blank, then the shell also tries to expand the next word on the command line as an alias. Consider the following:
```
>alias ee=’echo ’
>alias jj=’John ’
>alias dd=’Dierdorf ’
>alias is=’are ’
>ee jj dd is the speaker.
John Dierdorf are the speaker.
>ee jj dd "is the speaker."
John Dierdorf is the speaker.
>
```
Note that the non-alias argument(s) still have to go at the end. (In the last example, is is not expanded because the next argument is the complete string is the speaker. and that’s not an alias.)
Normally, aliases are defined in .bashrc or .zshrc so they are always available. Note that if an alias’s expansion contains blanks or other special characters, it must be enclosed in quotes when defined.
Zsh can also associate file types with a program to handle that file, so for example if I have associated .pdf with /user/bin/acroread, then I can run the appropriate program by simply typing the file name at the command line:
```
>myebook.pdf
```
To pull this off, use a special alias syntax as follows, putting the lines with the rest of your aliases:
```
alias -s jpg=gv
alias -s gif=gv
alias -s png=gv
alias -s pdf=acroread
alias -s html=kq
alias -s htm=kq
alias -s txt=vi
alias -s odt=oowriter
alias -s doc=oowriter
```
This is the same sort of thing which happens when you click the icon of a file in a graphical file manager.

Shell Variables

For a more general substitution mechanism, you can use a shell variable at the expense of typing one extra character. The expansion of a shell variable can occur anywhere on the command line. For instance, if we define the variables
```
me=’John R. Dierdorf’
mymail=’dierdorf@prismnet.com’
```
then the line
```
>tell $me everything at $mymail
```
expands into tell John R. Dierdorf everything at dierdorf@prismnet.com. Again, these definitions should be in .bashrc or wherever.
Zsh has a cute feature that if you define a variable to hold a path name, then you don't have to use the $. This will work:
```
>mydir=’/home/dierdorf/words/extra’
>cd mydir
```
In fact, in zsh you don’t even need to type the cd:
```
>mydir
```
will work just as well. It doesn’t have to be the full path, as long as the part to be substituted is at the beginning:
```
>mydir/js
```
will expand to cd /home/dierdorf/words/extra/js. This trick will not work as a part of a file name, though. If you want to edit a file in a directory named by a variable, you do have to use the dollar sign:
```
>vi $mydir/myfile.html
```

Functions

A function is a pre-defined chunk of shell code. As such, it can have multiple arguments, and what it can perform is only limited by bash or zsh’s language. The syntax is:
```
myfunction() {
  code goes here
}
```

Here are a couple of simple examples getting around the limitation of an alias as described above. Both use the syntax that

$1, $2,
...

are the arguments to the function, while $@ means all arguments.

### start acroread in background; ignore error messages
ac() {
  acroread $1 2>/dev/null &
}

### back up arguments to backup directory
mybackup() {
  cp $@ /home/dierdorf/backupdir
}

### copy files to my web server at prismnet.com/publicweb
pf() {
if [[ -e $1 ]]
then
  scp $@ dierdorf@prismnet.com:public-web/
else
  echo "usage is pf localfilename [...]"
fi
}

These would be executed as:

>ac mydoc.pdf
>mybackup file1 [file2 …]
>pf file1 [file2 …]

Note that gv, kq, etc. mentioned in the alias -s definitions above, are functions in the same form as ac, invoking gwenview and konqueror, respectively.

As is the case for aliases, functions are normally defined once and for all in .bashrc or .zshrc.

Scripts

A script is a chunk of code residing in a separate file on disk rather than being defined in a startup file. As such, anything that can be written as a function (or an alias) could have been written as a script. Functions and aliases have several advantages, though, all due to the fact that they act as a “built-in” part of the shell:
1. A function (or alias) can be executed more quickly, since there is no need to look up a file name and load it before the code can be executed,
2. They don’t clutter up your file system with lots of itty-bitty files,
3. You don’t have to remember to make them executable when you write them,
4. They run as part of the shell. An external program (whether a shell script or an executable binary) causes the shell to clone itself, with the external program running in a separate instance of the shell. This takes both time and memory.
5. Similarly, a function is logically part of the calling program, so it “knows” everything the parent does, and any value set by the function is known to the parent after the function ends.
On the other hand, scripts have some advantages, too:
1. Since all functions are incorporated into the shell, they make the shell somewhat larger and slower to load.
2. Using the #! “shebang” notation, scripts can be written in perl, python, ruby, or whatever, whereas functions are limited to the shell’s native language. (Likewise, a script can be written using zsh or csh syntax even though your running shell is bash.) The external languages provide more capability than the shell (otherwise there would be need for them at all!) and (particularly for larger programs) are easier to write, read, and debug. Examples of stuff you can easily use in these languages include regular expressions, floating point and complex arithmetic, mathematical functions (sin, log, …), data base manipulation, complicated I/O, multi-dimensional arrays, object-oriented programming, etc.
3. A script can easily be exported to another machine, kept on your thumb drive for emergencies, etc., just like any other file. Re-customizing some other computer’s shell can be irksome, not least to the owner of the other computer!
4. A script is easier to debug, using a standard edit-->save-->execute-->edit… sequence. If you edit a function or alias, you have to reload the shell before it becomes “visible” for testing. This can be alleviated, however, by putting your aliases and functions in a separate file (say .mycode) and then adding only one line to the startup file to include it.
```
source ./.mycode
```
  If you change .mycode, you can simply execute that line or its even shorter version,
```
>. ./.mycode
```
  from the command line to make the shell re-load the definitions.
5. A script can be “detached” to run in the background using the & notation, but a function must run to completion before the shell regains control.
As you can see, there is no hard and fast rule for which facility you use to solve a given problem, except that aliases cannot handle arguments. As a rule of thumb, if I can write it in half a dozen lines or less and it doesn’t do anything fancy, I use a function. Otherwise I use a script.

Last modified: Tue May 31 17:07:09 CDT 2011