Shell Script Check If File Exists

5 min read

Checking if a file exists is one of the most fundamental tasks in shell scripting. Also, whether you are writing a simple backup utility, a complex deployment pipeline, or a system health monitor, your script will inevitably need to make decisions based on the presence—or absence—of specific files or directories. Mastering the test command and its modern alternatives allows you to write strong, portable, and readable automation logic.

Understanding the Test Command Mechanics

At the heart of file existence checks lies the test command. Practically speaking, it returns an exit status of 0 (true) if the expression evaluates successfully and 1 (false) otherwise. In almost every POSIX-compliant shell (Bash, Zsh, Sh, Ksh), test evaluates conditional expressions. This exit status is what drives if statements, while loops, and logical operators like && and || It's one of those things that adds up..

You will typically encounter three syntax variations:

  1. test expression: The original, portable POSIX syntax.
  2. [ expression ]: A synonym for test, built into the shell. Crucially, the spaces inside the brackets are mandatory. [ -f file ] works; [-f file] throws a syntax error.
  3. [[ expression ]]: A Bash/Ksh/Zsh extension (keyword, not a builtin). It offers enhanced features like pattern matching (==), regex matching (=~), and safer variable handling without requiring quotes.

For maximum portability across Unix-like systems, stick to [ ]. If you are writing strictly for Bash (the most common interactive shell), [[ ]] is generally preferred for its safety and readability And that's really what it comes down to. Nothing fancy..

Primary File Test Operators

The test command uses single-letter flags (operators) prefixed with a hyphen to inspect file attributes. Here are the most critical operators for existence checks:

Operator Description True If... Here's the thing —
-e Exists File exists (any type: regular file, directory, symlink, socket, etc. ). In practice,
-f Regular File File exists and is a regular file (not a directory or device node).
-d Directory File exists and is a directory. In real terms,
-L or -h Symbolic Link File exists and is a symbolic link. Think about it:
-b Block Special File exists and is a block device (e. So g. , /dev/sda).
-c Character Special File exists and is a character device (e.Here's the thing — g. In practice, , /dev/tty). In real terms,
-S Socket File exists and is a socket.
-p Named Pipe (FIFO) File exists and is a named pipe.

The Critical Distinction: -e vs -f vs -d

Beginners often confuse -e (exists) with -f (regular file).

  • Use -e when you simply care that something occupies that path (e.g.That said, , "Does this config path exist so I don't overwrite it? In real terms, "). * Use -f when your script needs to read data from a file (e.So g. , cat, grep, source). So naturally, a directory passes -e but fails -f. * Use -d when you need to cd into a path or list its contents.

Basic Syntax Patterns

The Standard if Block

This is the most readable structure for complex logic Worth keeping that in mind..

#!/bin/bash

CONFIG_FILE="/etc/myapp/config.conf"

if [ -f "$CONFIG_FILE" ]; then
    echo "Configuration file found. Loading settings..."
    source "$CONFIG_FILE"
else
    echo "Error: Config file missing at $CONFIG_FILE" >&2
    exit 1
fi

Key Best Practices in the snippet above:

  1. Quote your variables ("$CONFIG_FILE"). If the path contains spaces or globbing characters (*, ?), unquoted variables will cause syntax errors or unexpected behavior.
  2. Redirect errors to stderr (>&2). Error messages belong in the error stream, not standard output.
  3. Exit with non-zero (exit 1). This signals failure to the calling process (CI/CD, parent script, systemd).

One-Liners with Logical Operators

For simple guard clauses, the && (AND) and || (OR) operators create concise flow control.

Execute only if file exists (Guard Clause):

[ -f "/tmp/lockfile" ] && echo "Lock exists. Exiting." && exit 1

Execute only if file is MISSING (Setup/Init):

[ -d "/var/log/myapp" ] || mkdir -p "/var/log/myapp"

Reading logic: "Test if directory exists OR make it." This is idiomatic for "ensure directory exists."

The [[ ]] Extended Test (Bash/Zsh/Ksh)

If your shebang is #!/bin/bash, apply [[ ]] for cleaner syntax.

FILE_PATH="/home/user/data.csv"

# No quoting needed for variables inside [[ ]] (word splitting/globbing disabled)
if [[ -f $FILE_PATH && -r $FILE_PATH ]]; then
    echo "File exists and is readable."
    # Process file
fi

Note: Inside [[ ]], you can use && and || logically. Inside [ ], you must use -a and -o (which are deprecated in POSIX) or separate [ ] commands.

Advanced Existence Checks

Checking Permissions Alongside Existence

Existence does not imply accessibility. A file might exist (-e) but be unreadable (-r), unwritable (-w), or unexecutable (-x).

SCRIPT="/opt/scripts/deploy.sh"

if [[ -f $SCRIPT && -x $SCRIPT ]]; then
    echo "Executing deployment script..."
    "$SCRIPT"
else
    echo "Deployment script missing or not executable." >&2
    exit 1
fi

Common Permission Flags:

  • -r: Read permission granted.
  • -w: Write permission granted.
  • -x: Execute permission granted.
  • -s: File exists and has size greater than zero (not empty).

Handling Symbolic Links Correctly

This is a frequent source of bugs. By default, -e, -f, -d, -r, -w, -x follow symbolic links (dereference them). They test the target of the link, not the link itself No workaround needed..

  • [ -f symlink ] returns true if symlink points to a regular file.
  • [ -L symlink ] returns true if symlink is a link (regardless of target validity).
  • [ -e symlink ] returns false if the link is broken (dangling).

Scenario: You want to know if the link itself exists, even if broken.

LINK="/usr/bin/python"

if [[ -L $LINK ]]; then
    echo "It is a symlink."
    # Check if target exists
    if [[ -e $LINK ]]; then
        echo "Target exists: $(readlink -f "$LINK")"
    else
        echo "Warning: Broken symlink detected!"
    fi
fi

Checking Multiple Files (Globbing)

You cannot pass a glob pattern directly to -f (e.g., [ -f *.log ] fails with "too many arguments" if multiple

Just Added

Hot New Posts

Dig Deeper Here

More to Discover

Thank you for reading about Shell Script Check If File Exists. We hope the information has been useful. Feel free to contact us if you have any questions. See you next time — don't forget to bookmark!
⌂ Back to Home