Advanced Bash Scripting

Go beyond the basics. In this lesson you'll write real-world bash: functions that return data and status, arrays, modern [[ ]] tests and case branching, "strict mode" safety with set -euo pipefail , cleanup with trap , debugging traces, and powerful parameter-expansion tricks.

Learn Advanced Bash Scripting in our free Command Line course — an interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Cli course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

1. Functions: Arguments, Scope & Return

Define a function with name() { ... } and call it like any command. Inside, the arguments are $1 , $2 , and $@ for all of them — exactly like a script. Use local so a function's variables don't leak out. A function doesn't return data with return ; instead it echoes its result (you capture it with result=$(myfunc arg) ), and uses return N only to set an exit status ( 0 – 255 ).

2. Arrays

An array holds many values under one name: arr=(apple banana cherry) . Read one element by index with ${ arr[0] } (arrays are 0-based), all elements with ${ arr[@] } , and the count with ${ #arr[@] } . Append with arr+=(date) , and loop safely with for x in " ${ arr[@] } "; do ... done (the quotes keep elements with spaces intact).

3. Modern Tests with [[ ]]

[[ ]] is bash's modern conditional — safer than [ ] with strings, and it understands == (with glob pattern matching), =~ (regex), and && / || inside the brackets. Handy string tests: -z (empty), -n (non-empty); file tests: -f (regular file), -d (directory). The older [ ] still works and is more portable, but in bash scripts prefer [[ ]] .

4. The case Statement

When you'd write a long if/elif/elif chain comparing one value against many options, a case statement is cleaner: case "$x" in pattern) ... ;; *) ... ;; esac . Each clause ends with ;; , patterns can use globs (and | to list several), and *) is the catch-all default . Close the whole thing with esac (that's "case" backwards).

5. Safety: set -euo pipefail

Add this near the top of any serious script — it's often called "bash strict mode." set -e exits the moment any command fails (so the script can't blunder on with bad state). set -u turns the use of an unset variable into an error (catching typos in names). set -o pipefail makes a pipeline fail if any stage fails, not just the last one — so a broken command in the middle can't hide.

6. Cleanup with trap

trap registers a handler to run when a signal or special event fires. The classic use is guaranteed cleanup: trap 'rm -f "$tmpfile"' EXIT deletes a temp file whenever the script ends — success, error, or Ctrl-C. You can also catch interrupts explicitly with trap ... INT TERM . This is far more reliable than a delete line at the bottom, which is skipped if the script exits early.

7. Exit Codes & Debugging

Every script ends with an exit code : exit 0 means success, any non-zero means failure. $? holds the exit code of the last command, and functions report status with return . To debug , turn on a trace with set -x — bash prints each command (with its values expanded) as it runs — and set +x turns it back off. You can also trace a whole file with bash -x script.sh .

8. Parameter Expansion Tricks

Parameter expansion edits a value as you read it , with no external tools. The big ones: ${ VAR:-default } uses a default if VAR is unset/empty; ${ VAR:=default } also assigns it; ${ #VAR } is the string length; ${ VAR%.txt } strips a suffix; ${ VAR#prefix } strips a prefix; and ${ VAR/old/new } replaces text. These replace whole pipelines of sed / cut calls.

🎯 Your Turn: finish the function

The function is almost done — fill in the blanks marked ___ using the # 👉 hints, then run it and check the Output panel matches.

🎯 Your Turn: work with an array

Two blanks: get the element count, then expand every element in the loop. Then run it.

Pro Tips

• 💡 Always quote " ${ arr[@] } " in loops. Unquoted, elements containing spaces get split into extra words — quoting keeps each element whole.
• 💡 Capture output, not status: a function's result comes from $(myfunc) ; return only sets $? . Don't try to read data from return .
• 💡 Adopt set -euo pipefail early in real scripts. It turns silent, late-night bugs into loud, immediate failures you can actually find.
• 💡 Trace with set -x when a script misbehaves — seeing each command with its expanded values is usually faster than scattering echo statements.

Common Errors (and the fix)

• Function "returns the wrong number" — you used return 100 expecting to read 100. return only sets an exit status (0–255). Echo the value and capture it with $(...) instead.
• Loop only sees one giant item — you wrote ${ arr[*] } or forgot the quotes. Loop over " ${ arr[@] } " to get each element separately.
• "unbound variable" after adding set -u — you referenced a variable that may be unset. Give it a default: " ${ VAR:- } " , or set it before use.
• case "syntax error: unexpected end of file" — a clause is missing its ;; , or you forgot to close with esac . Every clause ends with ;; .
• Temp file left behind on Ctrl-C — your cleanup was a plain line at the end, which got skipped. Move it into trap 'rm -f "$tmpfile"' EXIT so it always runs.

📋 Quick Reference

Concept

Syntax

Notes

Function

f() { … }

$1 = first arg

Local var

local v=…

Stays inside the function

Capture output

r=$(f arg)

Reads what f echoes

Array all

${ arr[@] }

Quote it in loops

Array count

${ #arr[@] }

Number of elements

Append

arr+=(x)

Adds to the end

Modern test

[[ -f f && -n s ]]

==, =~, -z/-n, -f/-d

Case

case x in p) … ;; esac

;; per clause, *) default

Strict mode

set -euo pipefail

-e exit, -u unset, pipefail

Cleanup

trap '…' EXIT

Runs on any exit

Debug trace

set -x / set +x

Prints each command

Default value

${ VAR:-def }

Use def if unset/empty

Frequently Asked Questions

Mini-Challenge: safe backup-namer

No blanks this time — just a brief and an outline. Combine everything from this lesson: strict mode, an argument guard, a trap cleanup, parameter expansion to build the backup name, and a case for a friendly message. Check your output against the example in the comments.

🎉 Lesson Complete!

• ✅ Functions take args ( $1 …), keep vars private with local , echo results (capture with $(...) ), and set status via return
• ✅ Arrays: ${ arr[0] } one, ${ arr[@] } all, ${ #arr[@] } count, arr+=(x) append
• ✅ Prefer [[ ]] (==, =~, -z/-n, -f/-d) and branch many ways with case … esac
• ✅ Harden scripts with set -euo pipefail and guarantee cleanup with trap '…' EXIT
• ✅ exit 0 / $? track success; debug with set -x ; reshape values with parameter expansion
• 🏆 You've finished the Command Line course! You can now read files, navigate, pipe, and write robust bash scripts — go automate something.

Practice quiz

Continue this course

• Previous: Networking Commands

Related lessons

• Lesson 7: Shell Scripting Basics