File test operators (-f, -d, -e, -r, -w, -x) in Bash Scripting - Mini Project: Build & Apply

Check File Properties Using File Test Operators in Bash

📖 Scenario: You are managing files on your computer. Sometimes you need to check if a file exists, if it is a regular file or a directory, and if you have permission to read, write, or execute it.In this project, you will write a bash script that uses file test operators to check these properties for a given file path.

🎯 Goal: Build a bash script that checks if a file exists, if it is a regular file or directory, and if it has read, write, and execute permissions. Then print the results clearly.

📋 What You'll Learn

Create a variable with a file path

Create a variable to hold a message prefix

Use file test operators: -e, -f, -d, -r, -w, -x

Print messages showing the file's properties

💡 Why This Matters

🌍 Real World

System administrators and developers often need to check file properties before running scripts or commands to avoid errors.

💼 Career

Knowing how to use file test operators in bash is essential for writing safe and effective shell scripts in IT and DevOps roles.

1

Create a variable with the file path

Create a variable called file_path and set it to "/tmp/testfile.txt".

Bash Scripting

# Create a variable called file_path with the value "/tmp/testfile.txt"
# Your code here

Hint

Use the syntax variable_name="value" to create a variable in bash.

2

Create a message prefix variable

Create a variable called msg and set it to "Checking file: $file_path" using double quotes and the variable file_path.

Bash Scripting

file_path="/tmp/testfile.txt"
# Create a variable called msg with the value "Checking file: $file_path"
# Your code here

Hint

Use double quotes to include variables inside strings in bash.

3

Use file test operators to check file properties

Write if statements using the file test operators -e, -f, -d, -r, -w, and -x to check if file_path exists, is a regular file, is a directory, is readable, writable, and executable. For each check, set a variable named exists, is_file, is_dir, can_read, can_write, and can_exec to true or false accordingly.

Bash Scripting

file_path="/tmp/testfile.txt"
msg="Checking file: $file_path"
# Use if statements with -e, -f, -d, -r, -w, -x to set variables exists, is_file, is_dir, can_read, can_write, can_exec
# Your code here

Hint

Use if [ -e "$file_path" ] to check if a file exists. Use similar syntax for other tests.

4

Print the results

Print the message stored in msg. Then print each property with a clear message, for example: echo "Exists: $exists", echo "Is regular file: $is_file", and so on for all variables exists, is_file, is_dir, can_read, can_write, and can_exec.

Bash Scripting

file_path="/tmp/testfile.txt"
msg="Checking file: $file_path"

if [ -e "$file_path" ]; then
    exists=true
else
    exists=false
fi

if [ -f "$file_path" ]; then
    is_file=true
else
    is_file=false
fi

if [ -d "$file_path" ]; then
    is_dir=true
else
    is_dir=false
fi

if [ -r "$file_path" ]; then
    can_read=true
else
    can_read=false
fi

if [ -w "$file_path" ]; then
    can_write=true
else
    can_write=false
fi

if [ -x "$file_path" ]; then
    can_exec=true
else
    can_exec=false
fi

# Print the message and all property variables
# Your code here

Hint

Use echo to print messages. Print the msg variable first, then each property variable with a label.

Practice

1. Which file test operator checks if a path is a regular file in a bash script?

easy

A. -e

B. -f

C. -d

D. -x

Solution

1. Step 1: Understand the meaning of each operator

   -f checks if the path is a regular file, -d checks for directory, -e checks if the path exists, and -x checks if the file is executable.

2. Step 2: Match the operator to the question

   The question asks for the operator that checks if a path is a regular file, which is -f.

3. Final Answer:

   -f -> Option B

4. Quick Check:

   Regular file check = -f [OK]

Hint: Remember: -f means file, -d means directory [OK]

Common Mistakes:

• Confusing -f with -d
• Using -e which only checks existence
• Mixing -x (executable) with file type

2. Which of the following is the correct syntax to check if a directory exists in bash?

easy

A. if [ -f /path/to/dir ]; then echo "Exists"; fi

B. if [ -x /path/to/dir ]; then echo "Exists"; fi

C. if [ -e /path/to/dir ]; then echo "Exists"; fi

D. if [ -d /path/to/dir ]; then echo "Exists"; fi

Solution

1. Step 1: Identify the operator for directory check

   -d is used to check if a path is a directory.

2. Step 2: Verify the syntax correctness

   The syntax if [ -d /path/to/dir ]; then ... fi is correct for checking directory existence.

3. Final Answer:

   if [ -d /path/to/dir ]; then echo "Exists"; fi -> Option D

4. Quick Check:

   Directory check uses -d [OK]

Hint: Use -d to check directories, not -f or -x [OK]

Common Mistakes:

• Using -f to check directories
• Confusing -e (exists) with directory check
• Missing spaces inside [ ] causing syntax errors

3. What will be the output of this script if myfile.txt exists and is readable but not writable?

if [ -r myfile.txt ]; then echo "Readable"; else echo "Not readable"; fi
if [ -w myfile.txt ]; then echo "Writable"; else echo "Not writable"; fi

medium

A. Readable\nWritable

B. Not readable\nWritable

C. Readable\nNot writable

D. Not readable\nNot writable

Solution

1. Step 1: Check readability condition

   The file exists and is readable, so [ -r myfile.txt ] is true, printing "Readable".

2. Step 2: Check writability condition

   The file is not writable, so [ -w myfile.txt ] is false, printing "Not writable".

3. Final Answer:

   Readable\nNot writable -> Option C

4. Quick Check:

   Readable true, writable false = A [OK]

Hint: Check each permission separately with -r and -w [OK]

Common Mistakes:

• Assuming writable if readable
• Mixing up -r and -w operators
• Ignoring else branch output

4. Identify the error in this bash snippet that checks if a file exists and is executable:

if [ -e myscript.sh -a -x ]; then echo "Executable file"; fi

medium

A. Missing filename after -x operator

B. Wrong operator -e should be -f

C. Missing spaces around -a operator

D. Should use double brackets [[ ]] instead of single [ ]

Solution

1. Step 1: Analyze the -x operator usage

   The -x operator requires a filename argument, but none is provided after it.

2. Step 2: Check other parts of the condition

   -e myscript.sh is valid to check existence; spaces around -a are correct; using single brackets is valid.

3. Final Answer:

   Missing filename after -x operator -> Option A

4. Quick Check:

   -x needs a file name [OK]

Hint: Always provide filename after each test operator [OK]

Common Mistakes:

• Forgetting filename after -x
• Confusing -e and -f operators
• Missing spaces around operators causing syntax errors

5. You want to write a bash script that prints "Ready" only if config.cfg exists, is a regular file, and is readable and writable. Which condition correctly checks all these?

hard

A. if [ -f config.cfg ] && [ -r config.cfg ] && [ -w config.cfg ]; then echo "Ready"; fi

B. if [ -e config.cfg -a -r config.cfg -a -w config.cfg ]; then echo "Ready"; fi

C. if [ -d config.cfg ] && [ -r config.cfg ] && [ -w config.cfg ]; then echo "Ready"; fi

D. if [ -e config.cfg ] && [ -r config.cfg ] && [ -w config.cfg ]; then echo "Ready"; fi

Solution

1. Step 1: Identify the operator for regular file check

   -f checks if the path is a regular file, which is required.

2. Step 2: Combine all conditions correctly

   Using && between separate [ ] tests is correct and clear. The script checks existence as a file, readability, and writability.

3. Step 3: Eliminate incorrect options

   if [ -e config.cfg ] && [ -r config.cfg ] && [ -w config.cfg ]; then echo "Ready"; fi uses -e which allows directories; if [ -e config.cfg -a -r config.cfg -a -w config.cfg ]; then echo "Ready"; fi uses -e which allows directories; if [ -d config.cfg ] && [ -r config.cfg ] && [ -w config.cfg ]; then echo "Ready"; fi checks for directory which is wrong.

4. Final Answer:

   if [ -f config.cfg ] && [ -r config.cfg ] && [ -w config.cfg ]; then echo "Ready"; fi -> Option A

5. Quick Check:

   Regular file with read/write uses -f, -r, -w combined [OK]

Hint: Use -f for file, combine tests with && for clarity [OK]

Common Mistakes:

• Using -e instead of -f to check file type
• Using -a inside single [ ] causing confusion
• Checking directory instead of file