Bash and Shell Scripting Questions

Covers proficiency in writing reliable Bash and POSIX shell scripts to automate common Linux system administration and operational tasks. Topics include shell syntax, variables, parameter expansion, arrays, control flow such as conditionals and loops, functions and modular script design, input and output redirection and pipes, and use of core Unix utilities for text processing such as grep, sed, and awk. Emphasizes defensive and maintainable scripting practices including error handling, exit codes, trap usage, logging, input validation, command substitution, process and job management, debugging techniques, performance considerations, and secure handling of file and process permissions. Typical use cases include service management, backups, log parsing and rotation, user provisioning, monitoring checks, and small operational tooling.

MediumTechnical

40 practiced

Explain traps in shell scripting. Provide example usages: a trap on EXIT to clean up temporary resources even when the script exits early under 'set -e', a trap on SIGINT to perform graceful shutdown, and an ERR trap to log the command that failed. Discuss limitations of traps across shells and in subshells.

Sample Answer

**What "trap" is (brief)** A trap registers a handler to run when the shell receives signals or special events (EXIT, ERR, INT, etc.). Useful in DevOps scripts for cleanup, graceful shutdown, and error logging.

**Example: EXIT trap to clean temp resources (works with set -e)**

bash

#!/usr/bin/env bash
set -euo pipefail
tmpdir="$(mktemp -d)"
cleanup() {
  rm -rf "$tmpdir"
  echo "Cleaned $tmpdir"
}
trap cleanup EXIT

# Simulate early exit due to error
cp non_existent_file "$tmpdir/"   # set -e causes exit, EXIT trap still runs

**SIGINT trap for graceful shutdown**

bash

#!/usr/bin/env bash
trap 'echo "Interrupted, shutting down..."; stop_services; exit 130' INT
start_services
# long-running work

**ERR trap to log failing command**

bash

#!/usr/bin/env bash
trap 'rc=$?; echo "ERROR: command \"$BASH_COMMAND\" exited $rc" >&2' ERR
set -e
some_command_that_may_fail

**Notes, limitations & portability**- ERR and BASH_COMMAND are Bash-specific; POSIX sh may not support ERR or $BASH_COMMAND. Use portable patterns for wide compatibility.- Traps run in the current shell; they do NOT fire for signals delivered to commands in a separate process group or for commands running in subshells (e.g., within parentheses). A subshell's EXIT runs its own traps; parent traps won’t catch failures inside `()` unless you propagate status.- In pipelines, earlier shells differ: in Bash `set -o errtrace` and `set -o functrace` help propagate ERR to functions/traps; use `set -o pipefail` to catch pipeline failures.- Test scripts on target shell (dash, bash, ksh) and in container/CI environments to ensure behavior matches production.

EasyTechnical

43 practiced

Explain how exit codes work in shell scripts. How should a function indicate failure or success, and how should the calling code inspect and react to those exit codes? Provide a short function example that returns 42 in a specific error case and show how the caller handles that code.

Sample Answer

**How exit codes work (DevOps perspective)**

- Shell commands and functions return an integer 0–255: 0 means success, non-zero means failure. CI/CD tooling, systemd, and orchestration rely on these codes to make decisions.- Use `return` inside a function (or `exit` in a script) to set the code. Keep codes documented (e.g., 1 = generic error, 42 = specific failure).

**Best practices**- Return 0 for success.- Use distinct non-zero codes for different failure modes.- Calling code inspects `$?` immediately or uses `if`/`case` on command substitution.- Prefer explicit checks over `set -e` for fine-grained handling in pipelines.

**Example: function returning 42 and caller handling**

bash

#!/usr/bin/env bash

my_check() {
  # simulate a specific error condition
  if [[ ! -f "/etc/myconfig" ]]; then
    echo "missing config" >&2
    return 42
  fi
  return 0
}

# caller
my_check
code=$?
if [[ $code -eq 0 ]]; then
  echo "OK"
elif [[ $code -eq 42 ]]; then
  echo "Specific error: config missing" >&2
  # take remediation, e.g., create default config or fail pipeline
  exit 42
else
  echo "Unexpected error: $code" >&2
  exit $code
fi

This pattern is useful in deployment scripts and CI jobs where different exit codes trigger different remediation or notifications.

MediumTechnical

33 practiced

Describe best practices for safely editing files in-place (for example config files) using sed or awk inside scripts. Provide a robust pattern that preserves file permissions and ownership, avoids data loss if the script is interrupted, and handles systems where 'sed -i' syntax differs between GNU and BSD variants.

Sample Answer

**Brief approach**Use a safe edit: write changes to a secure temp file (same dir), preserve mode/ownership, fsync, then atomically rename into place. Avoid sed -i portability; run sed/awk reading original and writing temp. Use traps to cleanup on interrupt.

**Robust pattern (bash)**

bash

#!/usr/bin/env bash
set -euo pipefail

file="/etc/myapp/config.conf"
dir=$(dirname "$file")
tmp=$(mktemp -p "$dir" "$(basename "$file").tmp.XXXXXX")
trap 'rm -f "$tmp"' EXIT

# preserve perms/ownership
perm=$(stat -c %a "$file" 2>/dev/null || stat -f %p "$file")
owner=$(stat -c %u:%g "$file" 2>/dev/null || stat -f %u:%g "$file")

# produce edited output safely (use sed/awk; no -i)
sed 's/OLD/NEW/g' "$file" > "$tmp"

# ensure data hits disk
sync
# set metadata
chmod "$perm" "$tmp"
chown "$owner" "$tmp" || true   # may require root; ignore if not permitted

# atomic replace
mv -f "$tmp" "$file"
trap - EXIT

**Why this is safe**- Writing to a temp file in same directory allows atomic mv (rename).- Preserves permissions and ownership so services keep access.- mktemp avoids predictable names; trap ensures cleanup on interrupt.- Avoids sed -i portability issues by not using in-place flags.- mv is atomic on the same filesystem — prevents partial writes and recovers by leaving original until swap.

**Edge notes**- If editing symlinks, decide whether to replace symlink or target (use mv --backup or follow symlink explicitly).- For critical systems, call fsync on temp file descriptor before chmod/mv.- Run as appropriate user/root to preserve ownership; otherwise chown may fail.

HardTechnical

34 practiced

Write a performant, memory-efficient Bash pipeline or script that scans a 10GB newline-delimited JSON log file, extracts the top-level string field 'user_id' from each JSON object, counts the number of unique user_ids, and tolerates malformed JSON lines by skipping them while printing a warning to stderr. Use only standard Unix utilities commonly available on Linux and explain optimizations you made for performance and low memory usage.

Sample Answer

**Solution (streaming, low-memory, robust)**

Code:

bash

#!/usr/bin/env bash
# Reads NDJSON from stdin or file arg, writes unique count to stdout,
# warnings about malformed lines to stderr.
file="${1:-/dev/stdin}"

# Parse line-by-line in Python (built-in json), emit user_id on stdout,
# warnings to stderr. Then use GNU sort's external merge to count uniques.
python3 -u -c '
import sys, json
fh = open(sys.argv[1]) if len(sys.argv)>1 and sys.argv[1]!="-" else sys.stdin
for i, line in enumerate(fh,1):
    line=line.rstrip("\n")
    if not line: 
        continue
    try:
        obj = json.loads(line)
        uid = obj.get("user_id")
        if isinstance(uid, str):
            print(uid)
    except Exception as e:
        print(f"Warning: malformed JSON at line {i}: {e}", file=sys.stderr)
' "$file" \
| LC_ALL=C sort -S 25% --temporary-directory=/tmp -T /tmp -u \
| wc -l

Why this approach- Streaming: Python reads one line at a time — constant memory regardless of file size.- Robust parsing: Python's json correctly handles escapes and Unicode; exceptions for malformed lines are caught and printed to stderr with line numbers.- Low-memory unique counting: sort -u uses external merge (disk-backed) when data exceeds RAM; using LC_ALL=C speeds comparisons; -S controls memory footprint.- Performance tips: run on multiple cores by splitting file (if needed) and merging, or increase -S if RAM available. Avoids per-line process fork overhead by using a single Python process rather than launching jq for every line.

EasyTechnical

47 practiced

Describe what the shell options 'set -euo pipefail' do in Bash scripts. For each option (-e, -u, and -o pipefail) explain its behavior, typical use in defensive scripting, and common caveats including interactions with pipelines, subshells, command lists, and conditional tests. Suggest safer patterns to use alongside these options.

Sample Answer

**Overview**Using set -euo pipefail is common defensive Bash for DevOps: stop on errors, fail on unset vars, and propagate pipeline failures. Below I explain each, caveats, and safer patterns.

**-e (errexit)**- Behavior: exit script immediately if a simple command returns non‑zero.- Use: prevents silent failures in deployments or provisioning scripts.- Caveats: does not always trigger in conditional tests, lists (cmd1 || cmd2), pipelines (without pipefail), or commands in while/tests. Also subshell failures may not abort parent.- Safer pattern: check return codes explicitly or use `command || exit` for expected non-zero.

**-u (nounset)**- Behavior: exit when referencing undefined variables.- Use: catches typos in env vars, secrets, config.- Caveats: parameter expansions like ${VAR:-} can avoid exit; arrays and indirections need care.- Safer pattern: use default expansions `${VAR?err}` to give clear messages.

**-o pipefail**- Behavior: pipeline exits with the rightmost non‑zero status (first failing command) instead of last command's status.- Use: catches failures in any stage (e.g., grep | awk in CI checks).- Caveats: not POSIX; in some shells pipelines in subshells still mask behavior.- Safer pattern: prefer `set -o pipefail` and avoid constructs that swallow exits; or capture intermediate statuses via `${PIPESTATUS[@]}` (Bash).

**Examples**

bash

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'
output=$(grep pattern file | awk '{print $1}')   # fails if grep fails

**Best practices**- Set IFS, use `trap 'echo "failed at $BASH_COMMAND"; exit 1' ERR` for diagnostics.- Use explicit checks for commands you expect may fail.- Use `${VAR:-default}` or `${VAR?Missing VAR}` to control nounset behavior.- Test scripts in dash/bash versions used in CI to ensure portability.

Unlock Full Question Bank

Get access to hundreds of Bash and Shell Scripting interview questions and detailed answers.

Join thousands of developers preparing for their dream job.