Variables, PATH, and Aliases

Shell variables and environment variables

You create a variable by writing a name, =, and a value, with no spaces around the = ^{1 2}:

me@linuxbox:~$ project=garden-plan
me@linuxbox:~$ echo "$project"
garden-plan
me@linuxbox:~$ project = garden-plan
project: command not found

With spaces, bash reads project as a command name. Use quotes when the value has spaces: title="Spring garden".

There are two kinds of variables ¹:

• A shell variable exists only in the current shell.
• An environment variable is also copied to every program the shell starts.

export turns one into the other ¹:

me@linuxbox:~$ color=blue
me@linuxbox:~$ bash -c 'echo "color is $color"'
color is
me@linuxbox:~$ export color
me@linuxbox:~$ bash -c 'echo "color is $color"'
color is blue

Programs get their settings this way: the editor to open, your language, where your home is. To set a variable for one command only, put it in front: LANG=C sort names.txt.

printenv lists the environment; set lists everything, shell variables and functions included ¹. unset name removes a variable.

Variables you’ll see everywhere

These are from the list in Shotts’ book ¹. Not every system sets all of them.

How the shell finds a command

When you type a command name, bash checks, in order ^{1 2}:

1. Is it an alias?
2. Is it a shell function?
3. Is it a builtin, like cd or echo?
4. Otherwise, search the directories in PATH, left to right, and run the first matching file that’s executable ³.

me@linuxbox:~$ echo "$PATH"
/home/me/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
me@linuxbox:~$ echo "$PATH" | tr ':' '\n'      # one per line, easier to read

The first match wins. If two folders both contain a python3, the earlier one in PATH is the one you get. type -a name shows every match in the order they’d be tried, and which name shows the first program file ¹.

Your own commands on PATH

A name with a slash in it skips the search: ./hello.sh means “the file hello.sh in this folder,” and /usr/bin/ls means that exact file ³. That’s why a script in your current folder must be run as ./hello.sh. The current folder is deliberately not on PATH, so a file named ls lying in some folder can’t hijack your ls.

To make your own scripts runnable from anywhere, keep them in a folder that is on PATH. Ubuntu already puts ~/.local/bin and ~/bin on it, if they exist when you log in ¹:

me@linuxbox:~$ mkdir -p ~/.local/bin
me@linuxbox:~$ mv ~/hello.sh ~/.local/bin/hello
me@linuxbox:~$ hello                      # works from anywhere (after a new login)

On other systems, or for another folder, add it yourself in your startup file (next lesson) ¹:

export PATH="$HOME/.local/bin:$PATH"     # first, so your versions win

Put new folders before $PATH to take priority, or after ("$PATH:$HOME/tools") to be a fallback. Never replace it outright: PATH=~/tools on its own would hide every system command until you open a new shell.

Aliases

An alias is a shortcut for the start of a command ¹:

me@linuxbox:~$ alias ll='ls -alF'
me@linuxbox:~$ alias update='sudo apt update && sudo apt upgrade'
me@linuxbox:~$ alias rm='rm -I'
me@linuxbox:~$ alias                  # list them
me@linuxbox:~$ unalias update

Ubuntu’s default .bashrc already defines ll, la, and l, and makes ls and grep colorize. To run the real command and skip an alias, put a backslash in front: \ls.

Aliases typed at the prompt vanish when the shell closes; next lesson puts them in ~/.bashrc so they last.

Functions

An alias can only paste text at the front of a command. When you need arguments in the middle, or several steps, write a function ^{1 2}:

mkcd() {
    mkdir -p "$1" && cd "$1"
}

me@linuxbox:~$ mkcd projects/shed-plans
me@linuxbox:~/projects/shed-plans$

$1 is the function’s first argument, $2 the second, and "$@" all of them. A function runs inside your current shell, which is why cd in a function moves you, while cd in a script would only move the script. You’ll write many more in the scripting module.

Your turn

So

Variables are name=value with no spaces; export makes them environment variables that programs inherit. The shell looks up a command as an alias, then a function, then a builtin, then in PATH, left to right, first match wins; a name with a slash skips the search. Keep your own scripts in ~/.local/bin, use aliases for shortcuts, and use functions when you need arguments.