Traveling down the Unix $PATH
Why is it that some commands can simply be executed, while others must be
./executed? In other words, why do some commands need a dot-slash in front of them to run? Rather than giving you a short answer, I am going to explore a couple of things and hope you find them enlightening.
If you create a new shell script, will you be able to run it with the first command below, or will you need to resort to the second?
$ newscript $ ./newscript $
Commands in Unix are either builtins or executables. Builtins are part of the shell you are currently running. Examples include
Any command that is not built in must be an executable. There are two types of executables: shell script languages, such as
perl, or compiled executables, such as a program written in C and compiled down to a binary.
Commands created by using an alias in
ksh also break down into these two main categories, because the command is translated and then issued as either a builtin or an executable. The following examples create aliases for the builtin
echo and the executable
The shell can always locate builtins, because they are built in to the currently executing shell.
$ alias sayit='echo ' $ alias g='grep '
In each case, after alias substitution is completed, the command becomes a builtin or an executable.
You can use the
type command to verify the nature of
$ type echo echo is a shell builtin $
Now use the
type command to check on
type will give you the directory that contains the executable
$ type grep grep is /bin/grep $
Whether you enter
grep as a command or ask for its location using
type, the operating system finds
grep by using the
$PATH environment variable. If
type can find
grep, then echoing out the
$PATH variable will verify that the path to the directory containing
grep is part of the
$ type grep grep is /bin/grep $ echo $PATH /bin:/usr/bin:/usr/local/bin:/home/mjb/bin $
The directories listed in
$PATH are separated by colons. The above example includes
/home/mjb/bin. As an aside, the
type command is probably a builtin.
$ type type type is a shell builtin $
Another useful command similar to
whereis, which will usually locate a command and its manual entry.
$ whereis grep grep: /bin/grep /usr/man/man1/grep.1 $
The shell reads and interprets strings of characters and words typed at the keyboard. Unix shells operate in a simple loop:
- Accept a command
- Interpret the command
- Execute the command
- Wait for another command
In step 3, the shell searches for the command to be executed first in the shell itself and then in each of the directories listed in the
$PATH. If it can't be found in one of these path directories, an error results.
$ zowie zowie: command not found $
It's important to note that the shell does not search the current directory unless that directory happens to be in the
$PATH variable. This is important to understand, especially if you came to Unix from an MS-DOS background. MS-DOS uses a
PATH variable as well, but it searches the user's the current directory before it searches in any directories in the user's
Some users have had the foresight to include the current directory in their
$PATH variable. This will appear as a single dot, the Unix shorthand for current directory. Note the dot at the end of the
$PATH variable below.
$ echo $PATH /bin:/usr/bin:/usr/local/bin:/home/mjb/bin:.
If you have the dot in your
$PATH variable, create a new directory under your home directory, such as
$HOME/temp, and change to it.
$ cd $HOME $ mkdir temp $cd temp $
vi editor to create a simple script.
# sayhello echo "Hello"
Save it and change the mode to executable.
$ chmod a+x sayhello $
If you have the dot in your
$PATH variable, you'll be able to execute the command directly.
$ sayhello Hello $
If you don't have a dot in your
$PATH variable, the computer will search through your
$PATH (anywhere but the current directory) and report failure.
$ sayhello sayhello: command not found $
If you type an unadorned command such as
sayhello, the computer searches for it. However, if you apply any additional path information to the command, the shell assumes that you are giving an absolute path and only looks where you tell it to. Consequently,
./sayhello locates the command in the current directory.
$ ./sayhello Hello $
Obviously, the dot-slash version works whether or not you have a dot in your
$PATH variable, because the dot-slash precludes the shell's search for the command.
To get a dot into your
$PATH if you don't have one, you need to edit your personal startup profile, usually called
.profile and located in your
$HOME directory. Look for a line that exports the
PATH variable, such as line 5 below. (Line numbers are included here for easy reference, but are not part of the file.) This file already has a line 4 that includes some local additions to the default
1. # .profile 2. # User specified environment 3. USERNAME="mjb" 4. PATH=$PATH:$HOME/bin 5. export USERNAME PATH
If line 4 did not exist, you'd want to create a line that read:
In this case, edit line 4 to read:
Now, whenever you log in, the dot is added to your search
$PATH for commands.
So, the simple rule is: if you want to execute any command in any directory not on your
$PATH, including the current directory, you must specify a path to locate the command. This includes a
./ for the current directory.