Master Bash Scripting: Safety, Functions, and Advanced Tricks

Script Safety

All Bash scripts should begin with the following lines to prevent common pitfalls:

#!/bin/bash
set -o nounset
set -o errexit

These options avoid referencing undefined variables and silently ignoring failed commands. Note that some commands (e.g., mkdir -p, rm -f) can deliberately suppress errors, and errexit does not catch every failure.

Script Functions

Define functions to improve readability and reuse code:

ExtractBashComments() {
    egrep "^#"
}
cat myscript.sh | ExtractBashComments | wc
comments=$(ExtractBashComments < myscript.sh)

Place most logic inside functions, leaving only global variables, constants, and the final call to a main -like entry point at the top level.

Variable Annotations

Use local for function‑scoped variables and readonly for constants to make scripts self‑documenting:

readonly DEFAULT_VAL=${DEFAULT_VAL:-7}
myfunc() {
    local some_var=${DEFAULT_VAL}
    ...
}

Attempting to reassign a readonly variable results in an error.

Prefer $() Over Backticks

Modern command substitution with $() is clearer and nestable, avoiding the visual confusion of backticks:

# Backticks (hard to read)
echo "A-`echo B-\`echo C-\\\`echo D\\\``"
# Preferred $() syntax
echo "A-$(echo B-$(echo C-$(echo D)))"

Use [[ ]] Instead of [ ]

Double brackets provide safer tests, support regex, and avoid many quoting issues:

# Single brackets (limited)
[ "$name" ">" "a" -a "$name" "<" "m" ]
# Double brackets (preferred)
[[ "${name}" > "a" && "${name}" < "m" ]]
[[ "$t" == abc* ]]   # globbing
[[ "$t" =~ [abc]+[123]+ ]]   # regex

From Bash 3.2 onward, regex and glob patterns must not be quoted; store complex patterns in variables if they contain spaces.

String Operations

Various slicing, replacement, and deletion techniques are available:

f="path1/path2/file.ext"
# Length
len=${#f}
# Slice
slice1=${f:6}
slice2=${f:6:5}
slice3=${f: -8}
# Replace
single_subst=${f/path?/x}
global_subst=${f//path?/x}
# Delete prefix/suffix
extension=${f#*.}
filename=${f##*/}
dirname=${f%/*}
root=${f%%/*}

Avoid Temporary Files

Use process substitution to feed command output directly where a filename is required:

# Compare two web pages without creating files
diff <(wget -O - url1) <(wget -O - url2)

Here Documents

Embed multi‑line input directly in a script using a custom delimiter:

command << MARKER
... script content ...
$var
$(cmd)
MARKER

Quote the delimiter (e.g., 'MARKER') when you want no variable expansion.

Built‑in Variables

Debugging

Check syntax without execution: bash -n myscript.sh Trace each command as it runs: bash -v myscript.sh Enable verbose and xtrace permanently with set -o verbose and set -o xtrace, useful for remote debugging.

When Not to Use Bash

Scripts become very long (hundreds of lines)

Complex data structures beyond arrays are needed

Escaping becomes overly complicated

Heavy string manipulation dominates

Little interaction with other programs or pipelines

Performance concerns arise

In such cases, consider a higher‑level language like Python or Ruby.

References

Advanced Bash‑Scripting Guide: http://tldp.org/LDP/abs/html/

Bash Reference Manual