File test operators (-f, -d, -e, -r, -w, -x) in Bash Scripting - Step-by-Step Execution

Concept Flow - File test operators (-f, -d, -e, -r, -w, -x)

Start

↓

Check file existence (-e)

↓

Check if regular file (-f)

↓

Output: It's a file

↓

Check if directory (-d)

↓

Output: It's a directory

↓

Output: Exists but not file/dir

↓

Output: Does not exist

↓

Check permissions (-r, -w, -x)

↓

Output permission results

↓

End

The script checks if a file exists, then tests if it is a regular file or directory, and finally checks read, write, and execute permissions.

Execution Sample

Bash Scripting

#!/bin/bash
file="test.txt"

# Check existence
if [ -e "$file" ]; then
  echo "$file exists"
  
  # Check type
  if [ -f "$file" ]; then
    echo "$file is a regular file"
  elif [ -d "$file" ]; then
    echo "$file is a directory"
  else
    echo "$file exists but is neither a file nor directory"
  fi
  
  # Check permissions
  [ -r "$file" ] && echo "$file is readable" || echo "$file is not readable"
  [ -w "$file" ] && echo "$file is writable" || echo "$file is not writable"
  [ -x "$file" ] && echo "$file is executable" || echo "$file is not executable"
else
  echo "$file does not exist"
fi

Complete script that checks existence (-e), type (-f, -d), and permissions (-r, -w, -x) for 'test.txt', printing appropriate messages.

Execution Table

Step	Test	Condition	Result	Action/Output
1	Check -e test.txt	Does test.txt exist?	Yes	Output: 'test.txt exists' & Proceed
2	Check -f test.txt	Is test.txt a regular file?	Yes	Output: 'test.txt is a regular file'
3	Check -d test.txt	Is test.txt a directory?	No (skipped due to elif)	No directory output
4	Check -r test.txt	Is test.txt readable?	Yes	Output: 'test.txt is readable'
5	Check -w test.txt	Is test.txt writable?	No	Output: 'test.txt is not writable'
6	Check -x test.txt	Is test.txt executable?	No	Output: 'test.txt is not executable'
7	End	All tests completed	-	Script ends

💡 Script handles all cases: existence, type, and permissions. Outputs vary based on actual file state.

Variable Tracker

Variable/Test	Start	After Step 1 (-e)	After Step 2 (-f)	After Step 3 (-d)	After Step 4 (-r)	After Step 5 (-w)	Final (-x)
file	"test.txt"	"test.txt"	"test.txt"	"test.txt"	"test.txt"	"test.txt"	"test.txt"
-e result	unset	true	true	true	true	true	true
-f result	unset	unset	true	true	true	true	true
-d result	unset	unset	unset	false	false	false	false
-r result	unset	unset	unset	unset	true	true	true
-w result	unset	unset	unset	unset	unset	false	false
-x result	unset	unset	unset	unset	unset	unset	false

Key Moments - 4 Insights

Why check -e first before -f or -d?

The -f and -d tests require the file to exist; without -e, they may behave unexpectedly or cause issues if the path doesn't exist (see step 1).

What if the item exists but is neither -f nor -d (e.g., symlink, pipe)?

The updated script handles it with an else clause after -f/-d, outputting 'exists but neither file nor dir'.

How are permissions tested independently?

Each [-r], [-w], [-x] is tested separately with &&/|| for output, allowing mixed results as in steps 4-6.

Why use quotes around "$file"?

Prevents errors if file path has spaces or is unset/empty.

Visual Quiz - 4 Questions

In the execution_table, what is the -d result at step 3?

A Yes

B Error

C No (skipped due to elif)

D Not performed

💡 Hint

Step 3 'Result' column shows why no directory output.

Which step confirms it's a regular file?

A 1

B 2

C 3

D 4

💡 Hint

'Action/Output' in step 2 identifies the file type.

If -w was true, what would step 5 output?

A Skip to end

B 'test.txt is not writable'

C No change

D 'test.txt is writable'

💡 Hint

Permission tests use conditional output based on result.

In variable_tracker, when does -x get evaluated?

A Final column

B After step 2

C Never

D Step 1

💡 Hint

Track the last column for execute permission.

Concept Snapshot

Bash file test operators:
• -e: exists
• -f: regular file
• -d: directory
• -r: readable (by user)
• -w: writable
• -x: executable
Always quote paths: [ -e "$file" ]. Chain with if/elif for types; test perms independently.

Full Transcript

This VMC_v5 trace demonstrates bash file test operators in action. The script first verifies existence (-e) to safely proceed to type checks (-f, -d) and permissions (-r/-w/-x). Execution table simulates a 'test.txt' regular file that's readable but not writable/executable. Variable tracker shows test results evolving step-by-step. Key moments explain best practices like early existence check and handling special files. Updated execution_sample is complete with shebang and all tests. Quizzes reference tables for retention. Estimated 10 mins to review.

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