How aliases are executed

When executing a command line, the Korn shell checks each word in turn against its table of known aliases. If the word is an alias name, and is not quoted in any way, and the shell is not already processing an alias of that name, then the alias name is replaced by the value of the alias. The process stops after the shell detects and substitutes one alias, unless the alias is followed immediately by a space. A similar process occurs under the C shell, except that aliases can explicitly refer to the history list (to recall a previously issued command).

It is possible to embed aliases so that an alias definition includes a command that is itself an alias. For example:

   $ alias dir='ls -al'
   $ alias count='dir | wc -l'
   $ count
   34
   $

The shells provide a quoting mechanism that can be used to prevent commands being evaluated under some circumstances.

The shells keep track of alias expansion; an alias which contains its own name will only be expanded once, and aliases are not expanded if they are quoted. This prevents the shell from getting trapped in an infinite loop if it expands an alias that refers to itself.

Note that there are some drawbacks to using aliases. It is easy to accidentally redefine standard commands so that they act in nonstandard or unexpected ways. When you define an alias, it is important to make sure that no program with the same name as the alias already exists; otherwise the alias will be substituted for it. For an example of a dangerous alias (that you should not use) alias -x kill='rm' could have unexpected results if you were to subsequently try to kill a runaway process.

Aliases can include references to variables, but note that you should enclose the alias definition in single quotes to prevent the variable from being expanded as the alias is defined. For example:

alias random='echo $RANDOM'

This command evaluates the variable RANDOM.

alias random="echo $RANDOM"

In this example, the alias would have been defined with whatever the literal value of RANDOM was at the time. This is because the shell expands variable references found in double quotes, but not in single quotes. Whenever the variable RANDOM is referenced, it returns a different (random) number. So we would see something like the following:

   $ alias random='echo $RANDOM'
   $ random
   56302
   $ random
   17094
   $ alias random="echo $RANDOM"
   $ random
   12916
   $ random
   12916
   $

If you use a positional parameter in an alias, the alias will expand the positional parameter of the currently running shell. Aliases are not separate programs and do not have parameters; they are simply replaced with the appropriate string on the command line. For example (in the Korn shell):

   $ set -- bill ted mary
   $ alias args='echo $3 $2 $1'
   $ args foo bar quux
   mary ted bill foo bar quux
   $

   echo $3 $2 $1 foo bar quux

If you need to modify the Korn shell positional parameters, use the set -- command. The arguments to set -- are used to replace the shell positional parameters $1, $2 ... $n.

If you want to define a command within the shell that accepts a parameter, you must define a function. A function is a block of commands that are referred to by a name, and that take positional parameters. For example:

   del()
   {
     rm -i "$@"
   }