Linux ‘which’ Command | Installation and Usage Guide

Terminal interface illustrating the installation of which used for locating commands

Are you trying to locate a command in Linux? Just like a searchlight, the 'which' command in Linux can help you find the path of a command. This might seem daunting, but 'which' is a powerful tool that is worth learning to install and use. The 'which' command enhances your command-line experience, making it easier to manage tasks on your Linux system. It’s accessible on most package management systems, simplifying the installation once you understand the process.

In this guide, we will navigate the process of installing the ‘which’ command on your Linux system. We will provide you with installation instructions for Debian, Ubuntu, CentOS, and AlmaLinux, delve into how to compile ‘which’ from the source, and install a specific version. Finally, we will show you how to use the ‘which’ command and ascertain that the correctly installed version is in use.

Let’s get started with the step-by-step 'which' installation on your Linux system!

TL;DR: How Do I Install and Use the ‘which’ Command in Linux?

In most Linux distributions, the ‘which’ command comes pre-installed. You can verify this with, which which. However, if it isn’t installed to your system, you can add it with the commands: sudo yum install which or sudo apt install which. To use it, simply type which followed by the command you want to locate.

For example:

which ls

# Output:
# /bin/ls

This command will return the path of the ‘ls’ command. This is a basic way to use the ‘which’ command in Linux, but there’s much more to learn about ‘which’ and its various applications. Continue reading for more detailed information and advanced usage scenarios.

Understanding the ‘which’ Command in Linux

The ‘which’ command in Linux is a utility for identifying the location of executables. It searches through the directories listed in your PATH environment variable to find the first match of a given command. This is particularly useful when you have multiple versions of the same program installed or when you’re dealing with complex scripts that call upon different tools.

Installing ‘which’ with apt

For Debian-based distributions like Ubuntu, you can use the apt package manager to install ‘which’. Here’s how:

sudo apt update
sudo apt install which

This will update your package lists and install the ‘which’ command. You can verify the installation by typing:

which which

# Output:
# /usr/bin/which

Installing ‘which’ with yum

For Red Hat-based distributions like CentOS or Fedora, you can use the yum package manager. Here’s the command:

sudo yum install which

And again, verify the installation with:

which which

# Output:
# /usr/bin/which

With the ‘which’ command installed, you can now easily locate other commands in your Linux system. For example, to find the location of the ‘ls’ command, you would type which ls.

which ls

# Output:
# /bin/ls

This tells you that the ‘ls’ command is located in the /bin directory.

Installing the ‘which’ Command from Source

For those who prefer to install the ‘which’ command from the source, you can do so by following these steps:

tar -xvzf which-2.21.tar.gz
cd which-2.21
sudo make install

This will download the source code, extract it, configure the build options, compile the code, and install it on your system. You can verify the installation by typing which which.

Installing Different Versions of ‘which’

From Source

To install a specific version of ‘which’ from the source, you simply need to replace the version number in the download URL. For example, to install version 2.20, you would use the following command:

tar -xvzf which-2.20.tar.gz
cd which-2.20
sudo make install

Using Package Managers


For Debian-based distributions, you can specify a version number with the apt package manager like this:

sudo apt install which=2.20-0.1


For Red Hat-based distributions, you can use the yum package manager to install a specific version like this:

sudo yum install which-2.20-7.el7

Version Comparison

Different versions of ‘which’ may have different features or bug fixes. For example, version 2.21 added support for the -a flag, which shows all locations containing an executable named after the argument in the directories listed in the PATH environment variable. Here’s a summary of the key features in each version:

VersionKey Features
2.20Basic functionality
2.21Added -a flag

Using ‘which’ and Verifying Its Installation

Basic Usage

The ‘which’ command is straightforward to use. Simply type which followed by the command you want to locate. For example, to find the location of the ‘python’ command, you would type which python.

which python

# Output:
# /usr/bin/python

Verifying Installation

You can verify that ‘which’ is correctly installed and find its location by using the command which which.

which which

# Output:
# /usr/bin/which

This tells you that the ‘which’ command is correctly installed and located in the /usr/bin directory.

Exploring Alternatives to ‘which’ Command

While ‘which’ is a powerful tool for locating commands in Linux, there are alternative methods that you can use. In this section, we’ll discuss two such alternatives: the ‘type’ command and the ‘whereis’ command.

The ‘type’ Command

The ‘type’ command is a shell builtin that displays the kind of command you’re dealing with. It can tell you whether a command is a shell builtin, an alias, a file, or a function.

type ls

# Output:
# ls is aliased to `ls --color=auto'

In this example, ‘type’ tells us that ‘ls’ is an alias for ‘ls –color=auto’. This is useful when you’re dealing with aliases or functions.

The ‘whereis’ Command

The ‘whereis’ command locates the binary, source, and manual page files for a command. It’s more thorough than ‘which’, as it searches for other related files, not just the executable.

whereis ls

# Output:
# ls: /bin/ls /usr/share/man/man1/ls.1.gz

In this example, ‘whereis’ tells us that the ‘ls’ executable is located in /bin, and its manual page is in /usr/share/man/man1.

Comparing ‘which’, ‘type’, and ‘whereis’

Each of these commands has its strengths and weaknesses. Here’s a summary:

whichSimple, easy to useOnly finds executables
typeIdentifies aliases, functions, etc.Output can be verbose
whereisFinds related files (source, man pages)Can be slow on large systems

In conclusion, while ‘which’ is a handy tool for locating commands in Linux, ‘type’ and ‘whereis’ offer more comprehensive information. Depending on your needs, you might find one more useful than the others.

Troubleshooting Common ‘which’ Command Issues

Even with the most straightforward commands, you may encounter issues or unexpected results. Let’s discuss some common problems you might face when using the ‘which’ command and how to solve them.

Command Not Found

One of the most common issues is the ‘Command not found’ error. This happens when the command you’re looking for isn’t installed or isn’t in the PATH.

which non-existent-command

# Output:
# non-existent-command not found

In this case, check if the command is installed and whether its location is included in the PATH. If it’s not installed, you’ll need to install it using your package manager. If it’s not in the PATH, you can add it by modifying the PATH variable in your shell’s configuration file.

Multiple Matches

The ‘which’ command only returns the first match it finds. If there are multiple versions of the same command installed in different directories, ‘which’ might not return the one you expected.

To see all matches, you can use the ‘-a’ option.

which -a python

# Output:
# /usr/bin/python
# /usr/local/bin/python

In this example, there are two versions of Python installed: one in /usr/bin and another in /usr/local/bin. The ‘-a’ option shows both matches.

‘which’ Command Not Found

If the ‘which’ command itself isn’t found, you might need to install it. On some minimal installations or containers, ‘which’ might not be installed by default. In this case, you can use your package manager to install it, as we discussed in the previous sections.


The ‘which’ command is a powerful tool, but like any tool, it has its quirks and potential issues. By understanding these common problems and their solutions, you can use ‘which’ more effectively and troubleshoot any issues that arise.

Understanding Command Path Resolution in Linux

To fully appreciate the utility of the ‘which’ command, it’s crucial to understand the concept of command path resolution in Linux and the role of the PATH environment variable.

What is Command Path Resolution?

Command path resolution is the process the shell uses to locate the executable file associated with a command. When you type a command into the terminal, the shell needs to find the corresponding executable file to run it. It does this by searching through a list of directories defined in the PATH environment variable.

The Role of the PATH Environment Variable

The PATH environment variable is a colon-separated list of directories that the shell searches when trying to execute a command. When you type a command, the shell looks in each directory listed in the PATH, in order, until it finds the executable or runs out of directories.

You can view your current PATH with the command echo $PATH.

echo $PATH

# Output:
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

In this example, the shell will first look in /usr/local/sbin for the executable, then in /usr/local/bin, and so on.

How ‘which’ Uses the PATH

The ‘which’ command uses the PATH to find the location of a command. It searches through the directories in the PATH in the same way the shell does, returning the path of the first matching executable it finds.

For example, if you have two versions of Python installed — one in /usr/bin and another in /usr/local/bin — ‘which python’ will return the path of the first one it finds. If /usr/bin comes before /usr/local/bin in the PATH, ‘which python’ will return /usr/bin/python, even though there’s another version installed in /usr/local/bin.

which python

# Output:
# /usr/bin/python

Understanding how command path resolution works and the role of the PATH environment variable can help you use the ‘which’ command more effectively. It can also help you troubleshoot issues when a command doesn’t behave as expected, as the problem might be due to the shell finding a different version of the command than you intended.

Delving Deeper: Command Location and System Administration

Understanding the location of commands and how to find them is not just a neat trick for Linux users. It’s a fundamental skill for system administration and scripting. When writing scripts, you need to know exactly which commands you’re calling. If a script calls a command without specifying its full path, the shell will use the PATH to find it. This could lead to unexpected results if there are multiple versions of the same command installed in different locations.

Exploring Symbolic Links and Aliases

In addition to the ‘which’, ‘type’, and ‘whereis’ commands, you can also use symbolic links and aliases to manage command locations in Linux.

A symbolic link is a type of file that points to another file or directory. You can use symbolic links to create ‘shortcuts’ to commands in different locations.

An alias is a way to create a new command that runs as a substitute for a longer command sequence. Aliases are defined in the shell’s configuration file and are only available in the current shell session.

Here’s an example of how to create a symbolic link and an alias for the ‘python3’ command:

ln -s /usr/bin/python3 /usr/local/bin/py
alias py='/usr/bin/python3'

In this example, ‘ln -s /usr/bin/python3 /usr/local/bin/py’ creates a symbolic link named ‘py’ that points to ‘/usr/bin/python3’. ‘alias py=’/usr/bin/python3” creates an alias named ‘py’ that substitutes for ‘/usr/bin/python3’.

Further Resources for Mastering Linux Command Location

  1. GNU Coreutils: Shell Command Language: This is a comprehensive guide to the shell command language, including command location and execution.

  2. Linux Command Library: A great resource for learning about different Linux commands, including ‘which’, ‘type’, and ‘whereis’.

  3. The Linux Documentation Project: This site has a wealth of guides and how-tos for all levels of Linux users.

Wrapping Up: Installing the ‘which’ Command in Linux

In this comprehensive guide, we’ve explored the ‘which’ command in Linux, a powerful tool for locating the path of a command. We’ve learned how to install and use ‘which’, delved into advanced usage scenarios, and discussed common issues and their solutions.

We began with the basics, learning how to install ‘which’ using different package managers and from the source. We then ventured into advanced usage, understanding how to install specific versions of ‘which’ and how to use the ‘-a’ option to find all matches for a command.

Along the way, we tackled common challenges you might face when using ‘which’, such as the ‘Command not found’ error and unexpected results due to multiple matches. We provided solutions and workarounds for these issues, helping you to use ‘which’ more effectively.

We also explored alternative approaches to locating commands in Linux, comparing ‘which’ with the ‘type’ and ‘whereis’ commands. Here’s a quick comparison of these methods:

whichSimple, easy to useOnly finds executables
typeIdentifies aliases, functions, etc.Output can be verbose
whereisFinds related files (source, man pages)Can be slow on large systems

Whether you’re just starting out with Linux or you’re a seasoned system administrator, we hope this guide has given you a deeper understanding of the ‘which’ command and its alternatives.

Understanding how to locate commands is a fundamental skill for using Linux effectively. With the ‘which’ command and its alternatives at your disposal, you’re well-equipped to navigate your Linux system with confidence. Happy coding!