Bash: Customization Basics

The real power of bash is in its potential for limitless customization. When a bash shell is started, it goes down a list of predefined paths, looking for customization files. Depending on your operating system, it is likely that 99% of what you will need to do can be accomplished in .bash_aliases, which is located in the top-level of your user directory.

.bashrc and .bash_profile will take edits as well, but this is generally not advisable. Some operating systems have things mixed around, but by default most of them will have comments in the headings of these files explaining how they are arranged on your machine.

Depending on how bash is invoked and initialized, there are a handful of other places it will look for customizations.

(ex: SSH, SU)

1. /etc/profile (global configuration)
   1. /etc/profile.d/ (directory for global configuration modules)
2. /etc/bashrc (more global settings)
3. ~/.bash_profile (user configuration)
   1. ~/.bashrc (more user configuration)
   2. ~/.bash_aliases (user aliases file)
4. ~/.bash_logout (performed on user logout)

(ex: within X window manager)

1. ~/.bashrc
2. ~/.bash_aliases

(ex: scripts)

1. Defined by BASH_ENV

As you start to use bash more often, you will find yourself using specific combinations of commands and flags to accomplish basic tasks. You can drastically cut the amount of typing you will do by setting aliases, which are just pseudo-commands that refer to other commands. These are the simplest customizations to make to bash.

For example, lets look at the ls command. The default output of ls is very bare-bones, and you have to type something like ls -lhaF to get a more detailed view. To make it so typing ls by itself gives you an easy-to-read detail view, add the following line to your .bash_aliases file:

ls='ls -lhaF --color=auto'

Aliases do not have to be permanent, either. To set that same alias to only work for the current shell session, you would run:

$ alias ls=\'ls -lhaF --color=auto\'

To unset that alias, you would run:

$ unalias ls

You can also unset all aliases for the current shell session with:

$ unalias -a

To see a list of active aliases, run:

$ alias -p

You can set all sorts of things up in your aliases file. The following are just a few tweaks you can make:

Just as in any programming language, bash uses variables. A variable in bash can contain a number, a character, or a string of characters.

You have no need to declare a variable, as just assigning a value to its reference will create it.

The most important variable you will deal with, is the $PATH variable, which specifies the directories that bash will look for executable files. (So you can type appname instead of /path/to/appname into your shell to run the program.) To figure out where your $PATH is, run:

$ echo $PATH

This will output something like:

/home/user/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

This above line shows that bash will look in your personal ~/.local/bin directory, as well as a list of common locations for globally-accessible binaries. Your system may have other locations appended here as well for things like games, Flatpak or Snap.

To enable bash to run a custom application (such as a freshly downloaded AppImage file) without having to type out the whole directory it is located in, you should place the file into your personal ~/.local/bin directory. Or, you could put a symlink into that directory like so:

$ ln -s /path/to/the.appimage ~/.local/bin/commandname

With commandname being whatever you want to type out to open that AppImage file in your shell or launcher.

You could also put the file or symlink in /usr/local/bin/ or /usr/bin/ to make it accessible to other users on the system.

See list of global variables:

$ env

Same as above, but with less available option flags:

$ printenv

See full list of global and local variables:

$ set

Another long list of environment variables:

$ declare

See value for global variable HOME:

$ printenv HOME

Same as above:

$ echo $HOME

Use global variable HOME as part of another command:

$ ls $HOME

Set value of new local variable \'testvar\':

$ testvar=testvalue

Same as above, but for strings:

$ testvar=\"A String Value\"

Append more data to the end of existing variable:

$ testvar=$testvar:moredata

Assign variable the result of set of commands:

$ testvar=$(other | commands)

Export a local variable to the global environment:

$ export testvar

Removes variable \'testvar\':

$ unset testvar

Define multiple values for variable as array:

$ vararray=(one two three four five)

Echo column three from vararray:

$ echo ${vararray[2]}

Echo entire array from vararray:

$ echo ${vararray[*]}

Change the value of column three in vararray:

$ vararray[2]=whatever

Remove column 2 from vararray. Prior col 3 now new col 2:

$ unset vararry[2]

• Get value of variables with `$`, but don\'t use `$` when assigning them.
• Global environment variables can be accessed from any child shells of the parent from which it was defined.
• Local environment variables can only be accessed from the process in which they were defined.
• Export and unset, when used in a child shell, will not affect the parent shell.
• Variable arrays start with an index value of zero, not one.

• Back to Index