How to Find the Directory Where a Shell Script Resides

When working with Unix shell scripts, there are many scenarios where you need to determine the directory in which the script itself is located. For example, you might want to reference other files relative to the script’s location, regardless of where the script is being executed from. This task isn’t as straightforward as it might seem because scripts can be called from different directories or via symbolic links.

In this blog post, we’ll explore several methods to find the directory of a shell script, with examples in Bash and other Unix shells.

Why Do You Need the Script Directory?

Sometimes, scripts depend on other resources like configuration files or other scripts that are located in the same directory as the script itself. If you try to reference those files using relative paths, things can break if you run the script from a different directory. The solution is to dynamically determine the directory where the script resides and base all paths on that.

Method 1: Using dirname in Bash

The simplest and most commonly used method to find the script’s directory in Bash is by utilizing the dirname command with $0, which refers to the script’s name.

#!/usr/bin/env bash

BASEDIR=$(dirname "$0")
echo "Script is located in: $BASEDIR"

How it works:

• dirname "$0" extracts the directory part of the script’s location.
• This works in most cases, but it doesn’t handle cases where the script is called through a symbolic link.

Method 2: Handling Symbolic Links with readlink

To account for scripts being invoked through symbolic links, we can use the readlink command. This ensures we get the actual path of the script, not the symbolic link.

#!/bin/bash

# Get the absolute path of the script
SCRIPT=$(readlink -f "$0")
# Extract the directory from the script path
SCRIPTPATH=$(dirname "$SCRIPT")
echo "Script is located in: $SCRIPTPATH"

Explanation:

• readlink -f "$0" follows symbolic links and returns the canonical path of the script.
• dirname "$SCRIPT" then extracts the directory part from this canonical path.

This method is robust for scripts called through both absolute and relative paths.

Method 3: Bash-Specific Solution Using $BASH_SOURCE

In some cases, especially when a script is sourced from another script, $0 might not hold the script’s path. In Bash, $BASH_SOURCE is a better alternative as it always points to the script file being executed.

#!/bin/bash

SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
echo "Script is located in: $SCRIPT_DIR"

Why use $BASH_SOURCE?

• $0 doesn’t always contain the path of the script, especially when sourcing or when the script is part of a pipeline.
• $BASH_SOURCE is Bash-specific but ensures you get the correct script path in all cases.

Method 4: A Universal POSIX Shell Approach

If you’re looking for a solution that works across different Unix shells (like sh, dash, ksh, etc.), you can rely on the pwd and pushd/popd commands. This method uses shell built-ins, which makes it more portable.

#!/bin/sh

# Change to the script's directory
cd "$(dirname "$0")"
# Store the absolute path of the current directory
SCRIPT_DIR=$(pwd)
echo "Script is located in: $SCRIPT_DIR"

Why use this?

• It’s POSIX-compliant, meaning it will work in any Unix shell.
• It avoids relying on external commands like readlink, which might not be available in all environments (e.g., macOS’s version of readlink behaves differently).

Method 5: Following Symlinks and Handling Edge Cases

For more complex scenarios, such as handling multiple levels of symbolic links, you can use a more advanced script that recursively resolves symbolic links.

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do
  DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
done
DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
echo "Script is located in: $DIR"

How it works:

• This script resolves symbolic links recursively until it reaches the actual file.
• It ensures that the script’s location is determined correctly, even if multiple symlinks are involved.

Conclusion

Determining the directory where a Unix shell script resides is essential when working with relative file paths. The method you choose depends on your requirements and the shell you’re using. For simple cases, using dirname "$0" works well, but if your script is invoked via symbolic links or sourced from other scripts, methods like readlink or $BASH_SOURCE provide more reliable results.

Now that you know several ways to find the directory of your script, you can confidently work with scripts that depend on other files or directories, regardless of where they are executed from.

Additional Resources

• Bash Reference Manual
• POSIX Shell Command Reference

This should help you manage your scripts more effectively, no matter where they’re located!