Bash Functions & Scripting – Build Modular, Maintainable Shell Scripts

Introduction – Master the Art of Bash Automation

Bash scripting isn’t just about running commands—it’s about structuring logic, modularizing tasks, handling inputs, and responding to events. This guide walks you through defining functions, passing parameters, handling script arguments, performing redirection, and even using traps for signal cleanup.

In this guide, you’ll learn:

• How to define and call functions with parameters
• How to write well-structured scripts using shebang and arguments
• How to redirect output and debug scripts
• How to build interactive select menus
• How to trap signals and control exit behavior

Topics Covered

Bash: Defining Functions (function, (), return)

Syntax:

greet() {
  echo "Hello, $1"
}
greet "World"

Or:

function greet {
  echo "Hello, $1"
}

Use return <code> to set an exit code (0 = success).

Bash: Function Parameters & Return Values

add() {
  result=$(( $1 + $2 ))
  echo "Sum: $result"
  return 0
}

add 3 5
echo "Function exited with code $?"

Use $1, $2, etc., inside functions like scripts.

Bash: Script Header & Structure (#!/bin/bash)

Every Bash script should start with:

#!/bin/bash

Example Layout:

#!/bin/bash

# Define function
say_hello() {
  echo "Hello, $1"
}

# Call function
say_hello "User"

Save as script.sh, then run using bash script.sh or chmod +x script.sh.

Bash: Script Arguments ($1, $2, $@, $#)

echo "Script name: $0"
echo "First arg: $1"
echo "All args: $@"
echo "Total args: $#"

Always validate arguments before use:

if [[ $# -lt 1 ]]; then
  echo "Usage: $0 filename"
  exit 1
fi

Bash: Running Scripts (bash script.sh, ./script.sh)

• Execute directly:

chmod +x script.sh
./script.sh arg1 arg2

• Or use Bash interpreter:

bash script.sh arg1

Use the shebang line (#!/bin/bash) to allow direct execution.

Bash: IO Redirection in Scripts (>, <, >>, 2>)

Example:

echo "Hello" > out.txt
cat < out.txt
ls /fakepath 2> error.log

Bash: Select Menus (select)

select opt in "Start" "Stop" "Exit"; do
  case $opt in
    "Start") echo "Starting...";;
    "Stop") echo "Stopping...";;
    "Exit") break;;
    *) echo "Invalid";;
  esac
done

select is ideal for interactive command-line menus.

Bash: Debugging (set -x, set -n, set -v)

Example:

set -x
echo "Debugging this line"
set +x

Great for troubleshooting long scripts.

Bash: Trap, Signals & Exit Codes (trap, exit)

Use trap to clean up:

cleanup() {
  echo "Cleaning up..."
}
trap cleanup EXIT

Trap SIGINT:

trap "echo Interrupted!" SIGINT

Use exit 0 for success, exit 1 or higher for error conditions.

Summary – Bash Functions & Scripting

Bash scripting allows you to write modular, maintainable, and reusable code using functions, parameters, and redirection. With traps, menus, and debugging tools, your scripts become production-grade automation tools.

Key Takeaways:

• Define functions using () or function for reusability
• Use $1, $2, $@ for arguments in scripts and functions
• Add shebang (#!/bin/bash) to make scripts executable
• Redirect input/output and handle errors with redirection operators
• Use select for user choices, and trap for signal handling
• Enable debugging using set -x or syntax check with set -n

Real-World Applications:

• Scheduled cron job scripts
• Backup and log rotation automation
• User-driven shell tools and server maintenance scripts

Frequently Asked Questions: Bash Functions & Scripting

Can a Bash function return a string?
Not directly. Use echo inside the function and capture with var=$(func).

How do I make a Bash script executable?
Use:

chmod +x script.sh

What is the use of trap in Bash?
It allows you to run cleanup code on signals like SIGINT, EXIT, etc.

How do I debug a Bash script?
Add set -x at the top or run as:

bash -x script.sh