When to Use Alias, Script, or Function in Bash

aliasbashfunctionshell-script

It's taken me almost 10 years of Linux usage to ask this question. It was all trial and error and random late-night internet surfing.

But people shouldn't need 10 years for this. If I were just starting out with Linux, I'd want to know: When to alias, when to script, and when to write a function?

Where aliases are concerned, I use aliases for very simple operations that don't take arguments.

alias houston='cd /home/username/.scripts/'

That seems obvious. But some people do this:

alias command="bash bashscriptname"

(and add it to the .bashrc file)

Is there a good reason to do that? I'm trying really hard, but I genuinely can't think of any circumstances in which I'd want to do that. So, if there is an edge case where that would make a difference, please answer below.

Because that's where I would just put something in my PATH and chmod +x it, which is another thing that came after years of Linux trial-and-error.

Which brings me to the next topic. For instance, I added a hidden folder (.scripts/) in the home directory to my PATH by just adding a line to my .bashrc (PATH=$PATH:/home/username/.scripts/), so anything executable in there automagically autocompletes.

If I needed to.

I don't really need that, though, do I? I would only use that for languages that are not the shell, like Python.

If it's the shell, I can just write a function inside the very same .bashrc:

funcname () {
  somecommand -someARGS "$@"
}

As I stated, I found a lot of this out through trial and error. And I only truly saw the beauty of functions when my computer died and I was forced to use the computers of the people around me when they weren't using them.

Instead of moving a whole directory of scripts from computer to computer, I ended up just replacing everyone else's .bashrc with my own, since they had never even made a single modification.

But did I miss anything?

So, what would you tell a beginning Linux user about when to alias, when to script, and when to write a function?

If it's not obvious, I'm assuming the people who answer this will make use of all three options. If you only use aliases, or only use scripts, or only use functions—or if you only use aliases and scripts or aliases and functions or scripts and functions—this question isn't really aimed at you.

Best Answer

An alias should effectively not (in general) do more than change the default options of a command. It is nothing more than simple text replacement on the command name. It can't do anything with arguments but pass them to the command it actually runs. So if you simply need to add an argument at the front of a single command, an alias will work. Common examples are

# Make ls output in color by default.
alias ls="ls --color=auto"
# make mv ask before overwriting a file by default
alias mv="mv -i"

A function should be used when you need to do something more complex than an alias but that wouldn't be of use on its own. For example, take this answer on a question I asked about changing grep's default behavior depending on whether it's in a pipeline:

grep() { 
    if [[ -t 1 ]]; then 
        command grep -n "$@"
    else 
        command grep "$@"
    fi
}

It's a perfect example of a function because it is too complex for an alias (requiring different defaults based on a condition), but it's not something you'll need in a non-interactive script.

If you get too many functions or functions too big, put them into separate files in a hidden directory, and source them in your ~/.bashrc:

if [ -d ~/.bash_functions ]; then
    for file in ~/.bash_functions/*; do
        . "$file"
    done
fi

A script should stand on its own. It should have value as something that can be re-used, or used for more than one purpose.

Related Solutions

Shell – How to get this script file’s functions to load without having to source it every time? “command not found” (Bash/scripting basics)

mikeserv's answer is good for the details of what goes on "behind the scenes", but I feel another answer here is warranted as it doesn't contain a simple usable answer to the exact title question:

How can I get this script file's functions to load without having to source it every time?

The answer is: Source it from your .bashrc or your .bash_profile so it is available in each shell you run.

For example, I have the following in my .bash_profile:

if [ -d ~/.bash_functions ]; then
  for file in ~/.bash_functions/*.sh; do
    . "$file"
  done
fi

Bash – calling Bash Function from alias definition

The problem is that your alias definition (the one of iseRemoveSetup) is in a subshell:

alias analyzer='setupise;'`iseAddToRemoveCall "analyzer"`

For iseAddToRemoveCall "analyzer" a subshell is started and the alias definition affects only this subshell which is gone as soon as this line is done.

This could be solved by changing

alias analyzer='setupise;'`iseAddToRemoveCall "analyzer"`

alias analyzer='setupise;$(iseAddToRemoveCall analyzer)'

and replacing echo "iseRemoveSetup;$1" (in iseAddToRemoveCall) with echo "unalias $1;$1". Thus the unalias would become part of the alias expansion and would be executed in the correct shell.

alternative

All this seems quite strange to me. Wouldn't it make more sense to start a subshell (type bash), run the setup, run the commands, and leave the subshell (^D) when finished?

additional remarks

man 1 bash:

The first word of the replacement text is tested for aliases, but a word that is identical to an alias being expanded is not expanded a second time. This means that one may alias ls to ls -F, for instance, and bash does not try to recursively expand the replacement text.

So you don't need unalias p1 in your alias definition before you call pi from it.

It may be better to use an (associative) array with the commands you want to unalias and just work with the array.

This is important, too, because you do exactly what you ought not to do:

Bash always reads at least one complete line of input before executing any of the commands on that line. Aliases are expanded when a command is read, not when it is executed. Therefore, an alias definition appearing on the same line as another command does not take effect until the next line of input is read. The commands following the alias definition on that line are not affected by the new alias. This behavior is also an issue when functions are executed. Aliases are expanded when a function definition is read, not when the function is executed, because a function definition is itself a compound command. As a consequence, aliases defined in a function are not available until after that function is executed. To be safe, always put alias definitions on a separate line, and do not use alias in compound commands.

Best Answer

Related Solutions

Shell – How to get this script file’s functions to load without having to source it every time? “command not found” (Bash/scripting basics)

Bash – calling Bash Function from alias definition

Related Question