Most people who use Bash know the basics: you set a variable with FOO=bar and access it with $FOO. But did you know Bash has a whole mini language for transforming variables without external commands?

This feature is called Shell Parameter Expansion, and once you get comfortable with it, you’ll stop reaching for sed, awk, or even basename/dirname for many common tasks. It’s fast, built-in, and surprisingly elegant.

In this article, we’ll explore the most useful expansions, with practical examples you can try right away.

1. Safer Variables: ${parameter}

The simplest form is ${parameter}. The braces aren’t always required, but they prevent surprises:

FILE=report
echo "$FILE1"     # expands $FILE1 (probably unset)
echo "${FILE}1"   # expands $FILE, then adds 1 → report1

Rule of thumb: always use braces unless it’s just $x.

2. Smart Defaults and Assignments

Bash can handle unset or empty variables inline — no if needed.

# Use default if unset or empty
echo ${USER_NAME:-"Anonymous"}

# Assign default if unset or empty
: ${USER_NAME:="Anonymous"}
echo "$USER_NAME"

# Error out if unset or empty
: ${CONFIG:?Missing CONFIG variable!}

# Expand only if set
PORT=8080
echo ${PORT:+"Running on port $PORT"}

These are essential for robust scripts that handle missing values gracefully.

3. Substring Extraction

Grab slices of a string:

text="0123456789abcdef"
echo ${text:4}      # 456789abcdef
echo ${text:4:3}    # 456
echo ${text: -4}    # cdef (negative offset counts from the end)

This works for positional parameters too:

set -- a b c d e f g
echo ${@:2:3}    # b c d

4. String Length

Quickly measure string or array size:

word="hello"
echo ${#word}      # 5

arr=(a b c)
echo ${#arr[@]}    # 3

5. Pattern Removal

Trim prefixes or suffixes without basename/dirname:

path="/home/user/file.txt"

echo ${path#*/}    # home/user/file.txt (shortest prefix)
echo ${path##*/}   # file.txt          (longest prefix)

echo ${path%/*}    # /home/user        (shortest suffix)
echo ${path%%/*}   #                  (longest suffix)

6. Search and Replace

Inline string replacement — no sed needed:

fruit="banana"
echo ${fruit/a/o}     # bonana (first match)
echo ${fruit//a/o}    # bonono (all matches)
echo ${fruit/#ba/BA}  # BAnana (only at start)
echo ${fruit/%na/NA}  # banaNA (only at end)

7. Case Conversion

Change case directly in Bash:

word="bash"
echo ${word^}     # Bash (capitalize first)
echo ${word^^}    # BASH (uppercase all)
echo ${word,}     # bash (lowercase first)
echo ${word,,}    # bash (lowercase all)

You can even pass a pattern to only target specific characters.

8. Indirection: Expanding Variable Names

Sometimes, the name of the variable you want to expand is itself stored in a variable:

name="USER"
echo ${!name}   # expands to value of $USER

This trick powers advanced Bash code like dynamic variable names.

You can also list all variable names with a prefix:

echo ${!HO*}   # all variables starting with "HO"

9. Advanced Transformations: ${parameter@operator}

Bash 4.4+ introduced handy transformations:

var="hello"
echo ${var@U}   # HELLO
echo ${var@L}   # hello
echo ${var@Q}   # 'hello' (quoted safely)
echo ${var@A}   # var='hello' (assignment form)

These are especially useful for debugging scripts and safe quoting.

10. Arrays and Indices

Parameter expansion also plays nicely with arrays:

arr=(red green blue)

echo ${!arr[@]}   # 0 1 2   (indices)
echo ${#arr[@]}   # 3       (size)

Combine with substring expansion for powerful inline array slicing.

Why This Matters

Once you internalize these expansions, you’ll find that many tasks you previously solved with external commands can be done entirely in Bash:

• Trim extensions without basename: ${file%.*}
• Replace spaces with underscores: ${str// /_}
• Check variables are set at script startup: ${VAR:?Missing VAR}

The result? Cleaner, faster, and more portable scripts.

Final Thoughts

Shell parameter expansion is one of those features that’s been hiding in plain sight. It feels like discovering a secret Bash superpower: concise string manipulation, safe defaults, and robust error handling — all built-in.

Next time you’re about to reach for awk, sed, or cut, pause and ask: can I do this with ${...} instead? Chances are, you can.