Shell Scripting

1. What is the purpose of the shebang line (#!/bin/bash) at the top of a shell script?

• It is a comment that documents the script author
• It tells the OS which interpreter to use when executing the file
• It enables error handling and stops the script on failures
• It sets the default working directory for the script

2. What does set -e do in a shell script?

• Enables strict variable quoting rules
• Sets the script’s encoding to UTF-8
• Stops the script immediately when any command returns a non-zero exit code
• Enables extended glob patterns

3. Which statements about $(...) command substitution are true? (Select all that apply) (select all that apply)

• The shell runs the command inside $(...) and replaces it with the command’s output
• It can be nested — you can put $(...) inside another $(...)
• It requires the eval keyword to work correctly
• It is used in $(date +%A) to embed the day of the week in a string

1. You run mkdir projects/backend/api but the projects/ directory doesn’t exist yet. What happens?

• Bash creates all three directories automatically
• Bash creates only projects/ and stops
• The command fails because the parent directories don’t exist — you need mkdir -p
• Bash prompts you to confirm before creating multiple directories

2. You run cp mydir /tmp/backup where mydir is a directory containing several files. What happens?

• The entire directory and its contents are copied
• Only the directory itself is created, without its contents
• The command fails — cp requires -r to copy directories
• The files inside are copied but the directory structure is flattened

3. What is the difference between cp file.txt dir/ and mv file.txt dir/?

• There is no difference — both move the file
• cp creates a duplicate (original stays); mv relocates the file (original is gone)
• cp works on files only; mv works on directories only
• cp preserves permissions; mv resets them to default

4. [Interleaved: Revisit Hello, Shell!] After running chmod +x morning.sh && ./morning.sh, you move the script: mv morning.sh scripts/morning.sh. Can you still run it with ./morning.sh?

• Yes — chmod +x is permanent and follows the file
• No — the file is no longer at ./morning.sh; you’d need ./scripts/morning.sh
• Yes — the shell caches the file location after the first run
• No — mv strips the execute permission

1. [Interleaved: Revisit Hello, Shell!] A script starts with #!/bin/bash and set -e. The first command is cd /nonexistent. What happens?

• Bash prints a warning but continues running the rest of the script
• Bash silently ignores the failed cd and stays in the current directory
• set -e catches the non-zero exit code from cd and the script exits immediately
• The shebang line prevents cd errors from being fatal

2. In the pipeline grep 'ERROR' server_log.txt | wc -l, what does the | operator do?

• Runs the two commands simultaneously in parallel and sums their output
• Passes the output of grep as a filename argument to wc
• Connects the stdout of grep to the stdin of wc
• Writes the grep output to a temporary file, then passes the filename to wc

3. What is the difference between > and >> for output redirection?

• > appends to a file; >> creates a new file or overwrites
• > creates or overwrites a file; >> appends to an existing file (or creates it)
• Both do the same thing — the number of > characters doesn’t matter
• > redirects stdout; >> redirects both stdout and stderr

4. What does grep 'WARN' server_log.txt | head -n 3 | sort -r do?

• It finds all the ‘WARN’ lines in the file, sorts all of them in reverse alphabetical order, and then shows you the top 3 from that sorted list.
• It goes to the bottom of the file, finds the last 3 ‘WARN’ logs, and displays them.
• It extracts the first 3 lines containing ‘WARN’, sorts them backward, and saves the sorted lines back into server_log.txt
• It grabs the very first 3 lines in server_log.txt that contain ‘WARN’, and prints those 3 specific lines in reverse alphabetical order (Z to A)

5. You run ./script.sh > output.txt but error messages still appear on your terminal. Why?

• The > operator is broken and does not capture all output
• > only redirects stdout; error messages go to stderr, a separate stream that still goes to the terminal
• Error messages always bypass file redirection for security reasons
• You need to use >> instead of > to capture error output

6. The pipeline cut -d' ' -f2 server_log.txt | sort | uniq -c | sort -rn chains four small tools. Which principle does this best illustrate?

• The DRY (Don’t Repeat Yourself) principle — avoid duplicating code
• The Unix Philosophy — write programs that do one thing well, work together, and use text streams as a universal interface
• The Principle of Least Privilege — each tool runs with minimal permissions
• The Single Responsibility Principle — each class should have only one reason to change

1. [Interleaved: Revisit Pipes] You want to count only lines containing ERROR in server.log and save that number to a variable. Which is correct?

• count=grep -c ERROR server.log
• count=$(grep -c ERROR server.log)
• count=| grep -c ERROR server.log
• count="${grep ERROR server.log}"

2. Which variable assignment is syntactically correct in Bash?

• name = "Alice"
• name= "Alice"
• name="Alice"
• $name = Alice

3. A variable dir contains the value my documents. What happens when you run ls $dir (unquoted)?

• Bash lists the directory named my documents correctly
• Bash word-splits on the space, running ls my documents — two separate arguments
• Bash produces a syntax error and stops
• Bash automatically quotes the variable to handle the space

4. [Interleaved: Revisit Hello, Shell!] What does the #!/bin/bash line at the very top of a script tell the Operating System?

• It is a comment for documentation
• It specifies the interpreter that should execute the file
• It enables strict error checking
• It sets the script’s permissions to executable

1. Inside a Bash if statement, you want to check whether server.log has more than 100 lines. Which is syntactically correct?

• if [ $(cat server.log) -gt 100 ]
• if [ $(wc -l < server.log) -gt 100 ]
• if [ grep -c "" server.log -gt 100 ]
• if | wc -l server.log > 100

2. Why are spaces required inside [ ] test brackets, like [ -f "$file" ]?

• Bash style convention only — omitting spaces still works
• [ is an actual command, and its arguments must be separated by spaces like any command
• Without spaces, the shell treats the entire bracket expression as a string
• Spaces are only required when using string comparisons, not file tests

3. You want to compare two integer variables $count and $max in a Bash conditional. Which test is correct?

• [ "$count" = "$max" ]
• [ $count == $max ]
• [ $count -eq $max ]
• [ $count === $max ]

4. [Interleaved: Revisit Pipes] Which operator is used to append output to an existing file without overwriting it?

• >
• >>
• |
• <

1. You write for f in *.log; do wc -l $f; done. One of the log files is named error log.txt (with a space). What happens when the loop processes it?

• wc correctly counts the lines in error log.txt
• The shell word-splits $f on the space, passing error and log.txt as two separate arguments
• Bash automatically handles spaces in filenames when iterating with for
• The loop silently skips any filenames that contain spaces

2. In a for f in *.sh loop, when does the shell substitute *.sh?

• Inside the loop body, each time $f is referenced
• Before the loop runs — the shell expands *.sh to a list of matching filenames first
• After the loop completes, to validate the filenames used
• Only when running with bash -e safety flag enabled

3. What does $((counter + 1)) do in Bash?

• Runs the command counter + 1 and substitutes its output
• Evaluates the integer arithmetic expression and substitutes the result
• Concatenates the string counter with + 1
• Increments counter in place and returns the new value

4. [Interleaved: Revisit Variables & Quoting] Inside a loop, you use wc -l $f. If a file is named data 2024.txt, how does Bash interpret the unquoted $f?

• It correctly processes the single file data 2024.txt
• It word-splits the name into two separate arguments: data and 2024.txt
• It produces a syntax error because of the space
• It automatically adds quotes to handle the space

5. [Interleaved: Revisit Navigating the Filesystem] Your loop creates a directory for each .sh file: mkdir results/$f. But results/ doesn’t exist yet. What happens?

• Bash creates results/ automatically when a subdirectory is needed
• mkdir fails because the parent directory results/ doesn’t exist — you need mkdir -p
• mkdir creates results/ first, then the subdirectory
• The loop skips the file and continues to the next iteration

1. [Interleaved: Revisit Conditionals] Your script receives a filename as $1. You want to check if the file exists before processing it. Which conditional is correct?

• if $1 -f; then
• if [ -f "$1" ]; then
• if exists "$1"; then
• if file "$1"; then

2. What does $# contain when a script is called as ./deploy.sh app v1.2?

• The string app v1.2
• The number 2 (the count of arguments)
• The number 3 (including the script name)
• The exit code of the last command

3. Why use "$@" (quoted) instead of $@ (unquoted) when looping over arguments?

• Quoting $@ makes the loop run faster
• Unquoted $@ word-splits arguments containing spaces, potentially breaking them into separate words
• Quoted $@ includes the script name as the first element
• There is no practical difference between "$@" and $@

1. [Interleaved: Revisit Loops] A function process_all is called as process_all file1.txt "my report.txt". Inside, it runs for f in $@; do. How many iterations does the loop perform?

• 2 — the two properly-separated arguments
• 3 — word-splitting on the space inside my report.txt creates a third element
• 1 — the entire argument list is treated as one string
• 0 — $@ is empty inside functions; use $* instead

2. What problem does the local keyword solve inside a Bash function?

• It makes the function run faster by caching its variables
• It prevents a function’s internal variables from leaking into and overwriting global script variables
• It allows the function to accept more than 9 arguments
• It makes the function available to child processes (subshells)

3. A function count_words should return a number to the caller. Which is the correct Bash pattern?

• Use return 42 and capture it with result=$(count_words)
• Use echo 42 inside the function and capture with result=$(count_words)
• Use return 42 and read it from $? with result=$?
• Assign directly to a global variable inside the function

1. What does cd /project || exit 1 do?

• Runs cd and exit 1 simultaneously in parallel
• Runs exit 1 only if cd /project fails (non-zero exit code)
• Runs exit 1 only if cd /project succeeds (exit code 0)
• The || operator is invalid syntax in Bash

2. In a Bash case statement, what does the * pattern in the last branch do?

• It matches only numeric input
• It acts as a wildcard catch-all, matching any input not matched by earlier branches
• It is a syntax error — case does not support wildcards
• It matches the empty string only

3. What is the universal meaning of exit code 0 in Unix/Linux?

• The script ran but produced no output
• The command or script succeeded without errors
• The script exited before finishing all commands
• Zero is falsy — it means the condition was false

4. [Interleaved: Revisit Arguments] Which special variable contains the number of arguments passed to the script?

• $@
• $#
• $0
• $*

1. [Interleaved: Revisit Hello, Shell!] Scenario: A developer wrote the following deployment script but forgot to include set -e at the top:

#!/bin/bash
cd /var/www/production_app
git pull origin main
rm -rf temp_cache/*
systemctl restart app

• The script immediately terminates with a non-zero exit code because the target directory does not exist
• Bash pauses execution and prompts the user in standard input to manually resolve the missing directory
• The script continues executing in the current directory, potentially pulling code and deleting cache files in the wrong location
• Bash’s implicit error handling skips the next command (git pull) but resumes execution at rm -rf

2. [Interleaved: Revisit Pipes] Scenario: You are given a massive log file, server.log. You need to find out how many times the user “admin” triggered a “WARN” event. Which pipeline correctly filters and counts these logs?

• grep "WARN" server.log | grep "admin" | wc -l
• cat server.log | grep "WARN" && grep "admin" > wc -l

  && runs the next command only if the previous one succeeded — it does not connect their output. | connects stdout of one command to stdin of the next. Also, > wc -l tries to write output into a file literally named wc, not run wc -l.

• grep "WARN" server.log > grep "admin" | wc -l

  > redirects stdout to a file; here it would create a file named grep instead of piping output to the grep command. Replace > with | to connect the two commands.

• wc -l $(grep "WARN" server.log | grep "admin")

  $(grep ...) captures the matching lines as a string and passes them as a command-line argument to wc -l. But wc -l counts lines from its stdin or a filename argument — not from inline text. Use a pipe instead: grep ... | grep ... | wc -l.

3. Scenario: A junior developer writes the following script:

#!/bin/bash
DIR = "/tmp/build"

• Bash requires the let or set keyword to assign string variables
• Bash evaluates the spaces around the = sign and attempts to execute a program named DIR with = and "/tmp/build" as its arguments
• /tmp/build is a directory, not an executable, so Bash cannot assign it to a command substitution
• Variables in Bash must be entirely lowercase to avoid clashing with reserved environment commands

4. Scenario: A deployment script runs the following logic to check for a required environment file:

if [ -d ".env" ]; then
    echo "Environment file loaded."
else
    echo "Fatal: Missing .env file!"
    exit 1
fi

• The .env file is hidden (starts with a dot), so Bash cannot detect it without the -a flag
• The -d flag specifically tests if the path is a directory, not a regular file
• The quotes around “.env” prevent Bash from evaluating the file path correctly
• The if statement is missing the test keyword inside the brackets

5. Scenario: Consider the following loop running in a directory that contains exactly one file named 01 Financial Report.csv:

for f in *.csv; do 
  wc -l $f
done

• 01 Financial Report.csv
• 01\ Financial\ Report.csv
• *.csv
• 01, Financial, and Report.csv

6. Scenario: A script deploy.sh requires exactly three arguments: environment, version, and region. A developer wrote this validation check:

if [ "$@" -ne 3 ]; then
    echo "Error: Expected 3 arguments."
    exit 1
fi

• $@ expands to the actual string values of the arguments, not the total count of arguments
• -ne is used exclusively for string comparison, so it cannot compare against the integer 3
• Bash arrays are zero-indexed, so the developer must check against 2 instead of 3
• The variable should be unquoted ($@) to allow Bash to evaluate it as an integer

7. Scenario: Trace the execution of the following script. What will the final echo statement print to the terminal?

target_dir="/var/www/html"

setup_temp() {
  target_dir="/tmp/workspace"
}

setup_temp
echo "Deploying to $target_dir"

• Deploying to /var/www/html
• Deploying to /tmp/workspace
• Deploying to (empty string)
• The script will throw a syntax error because target_dir is declared twice

8. Scenario: You are writing a script health_check.sh that checks database connectivity. If the database is unreachable, you need the CI/CD pipeline running the script to immediately halt. What is the standard Unix mechanism to communicate this failure back to the CI/CD environment?

• Print “FAILURE” to stdout so the pipeline can parse the string
• Output the error message to stderr using >&2
• Use the command exit 1 (or any non-zero integer) at the end of the failure block
• Return a boolean false using the return keyword

9. Scenario: Read the following script named start_server.sh:

#!/bin/bash
LOG_LEVEL="${1:-INFO}"
PORT="${2:-8080}"
echo "Starting on port $PORT with level $LOG_LEVEL"

• Starting on port DEBUG with level INFO
• Starting on port 8080 with level DEBUG
• Starting on port 8080 with level INFO
• The script will crash because $2 was not provided, causing an unbound variable error

10. [Interleaved: Revisit Case Statements & Exit Codes] Scenario: A deployment script contains this line:

cd /var/www/app && git pull && systemctl restart app

• All three commands run; cd failure does not affect git pull or systemctl
• cd fails, so && short-circuits — git pull and systemctl restart never run
• cd fails, but && only checks the last command, so systemctl restart still runs
• Bash retries cd three times (once per &&) before giving up