Offensive Security Researcher & Quantum Cryptography Analyst

How to Create Functions in Bash

Abdul Wahab Junaid
How to Create Functions in Bash

How to Create Functions in Bash

Once a script grows past a few dozen lines, or once I find myself copy-pasting the same block of commands more than twice, that’s my cue to wrap it in a function. Functions are what turn a long, flat script into something organized and reusable, and Bash’s function syntax — while a little different from other languages — is easy to pick up once you’ve seen a few real examples. In this article, I’ll cover how to define functions, pass arguments to them, return values, manage scope, and use them in real automation.

Defining a Basic Function

There are two common syntaxes for defining a function in Bash:

greet() {
    echo "Hello!"
}

or, using the function keyword:

function greet {
    echo "Hello!"
}

Both work the same way in Bash. I personally lean toward the first style (name()), since it’s also valid in POSIX sh and more portable, but either is fine for Bash-only scripts.

To call the function, just use its name:

greet

Passing Arguments to a Function

Functions don’t use named parameters like in other languages — instead, they receive arguments the same way scripts do, through $1, $2, $#, and $@:

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

greet "Alex"    # Output: Hello, Alex!

You can access all arguments and their count just like at the script level:

show_args() {
    echo "Number of arguments: $#"
    for arg in "$@"; do
        echo "Argument: $arg"
    done
}

show_args one two three

Returning Values from a Function

This is one of the more confusing parts of Bash functions for newcomers. The return statement in Bash doesn’t return arbitrary data — it sets the function’s exit status, which must be an integer between 0 and 255.

is_even() {
    if (( $1 % 2 == 0 )); then
        return 0   # success / true
    else
        return 1   # failure / false
    fi
}

if is_even 4; then
    echo "4 is even"
fi

If you need to return actual data — like a string or a computed value — the conventional approach is to echo the result and capture it with command substitution:

get_greeting() {
    echo "Hello, $1!"
}

message=$(get_greeting "Alex")
echo "$message"    # Output: Hello, Alex!

Local vs Global Variables

By default, variables inside a Bash function are global unless explicitly declared local:

counter=0

increment() {
    counter=$((counter + 1))
}

increment
increment
echo "$counter"    # Output: 2

This can lead to unexpected side effects if you’re not careful. Using local keeps a variable scoped to the function:

add_numbers() {
    local sum=$(( $1 + $2 ))
    echo "$sum"
}

result=$(add_numbers 3 5)
echo "$result"    # Output: 8

I make it a habit to declare every function-internal variable as local unless I specifically want it to affect the global scope, since it prevents subtle bugs where one function accidentally overwrites a variable another part of the script depends on.

Default Values for Function Arguments

Just like with script arguments, you can provide defaults using parameter expansion:

greet() {
    local name="${1:-Guest}"
    echo "Hello, $name!"
}

greet          # Output: Hello, Guest!
greet "Alex"   # Output: Hello, Alex!

Using Functions with Arrays

Since Bash doesn’t easily pass arrays by value into functions, the usual approach is to expand the array into arguments:

print_list() {
    local items=("$@")
    for item in "${items[@]}"; do
        echo "$item"
    done
}

my_array=("apple" "banana" "cherry")
print_list "${my_array[@]}"

For modifying the caller’s array directly, namerefs (Bash 4.3+) work well:

add_item() {
    local -n arr_ref=$1
    arr_ref+=("$2")
}

fruits=("apple" "banana")
add_item fruits "cherry"
echo "${fruits[@]}"    # Output: apple banana cherry

Recursive Functions

Bash supports recursion, though it’s not commonly used for performance-sensitive tasks:

factorial() {
    local n=$1
    if (( n <= 1 )); then
        echo 1
    else
        local prev
        prev=$(factorial $((n - 1)))
        echo $((n * prev))
    fi
}

factorial 5    # Output: 120

Checking If a Function Exists

if declare -f greet > /dev/null; then
    echo "The greet function is defined."
fi

How Functions Work Internally

When Bash encounters a function definition, it doesn’t execute anything immediately — it simply stores the function’s name and body in an internal table, similar to how it stores variables. When the function is later called, Bash creates a new execution context: it pushes the function’s positional parameters ($1, $2, etc.) onto a stack, temporarily shadowing the caller’s own positional parameters, and runs the function body within the current shell process (functions don’t fork a new subshell by default, unlike executing an external script). This is why local matters — without it, variable assignments inside a function directly modify the shell’s existing variable table rather than a separate scope. When a function calls return, Bash pops the function’s context off the stack and resumes execution at the point right after the function call, passing along the specified exit status.

Real-World Use Cases

A logging helper used throughout a script:

log() {
    local level="$1"
    shift
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $*"
}

log "INFO" "Starting backup process"
log "ERROR" "Failed to connect to remote server"

A reusable confirmation prompt:

confirm() {
    local prompt="${1:-Are you sure?}"
    read -r -p "$prompt [y/N]: " response
    [[ "$response" =~ ^[Yy]$ ]]
}

if confirm "Delete all temporary files?"; then
    echo "Deleting..."
else
    echo "Cancelled."
fi

A function library sourced across multiple scripts:

# utils.sh
is_root() {
    [ "$(id -u)" -eq 0 ]
}

# main.sh
source ./utils.sh

if is_root; then
    echo "Running as root"
else
    echo "Not running as root"
fi

Automation Example: Deployment Helper Functions

#!/bin/bash

check_prerequisites() {
    local missing=0
    for cmd in git docker curl; do
        if ! command -v "$cmd" > /dev/null 2>&1; then
            echo "Missing required command: $cmd" >&2
            missing=1
        fi
    done
    return $missing
}

deploy() {
    local env="$1"
    echo "Deploying to $env..."
    # deployment logic here
}

main() {
    if ! check_prerequisites; then
        echo "Please install missing dependencies before continuing." >&2
        exit 1
    fi

    deploy "${1:-staging}"
}

main "$@"

This structure — small, focused functions combined into a main function called at the bottom of the script — is a pattern I use in almost every non-trivial script I write, since it keeps the logic readable and testable.

Best Practices

Security Considerations

Optimization Tips

Troubleshooting

A variable set inside a function isn’t visible outside of it: This is usually intentional if you used local. If you need the value outside the function, use command substitution to capture the function’s output instead.

return doesn’t seem to “return” the value you expected: Remember that return only sets the exit status (0–255), not arbitrary data. Use echo and capture the output with $(function_name) if you need to return a string or number outside that range.

Function isn’t recognized when called from another script: Make sure you’ve sourced the file containing the function definition (using source file.sh or . file.sh) before calling it — functions aren’t automatically available across separate script files.

Common Mistakes

  1. Forgetting local, which causes variables to leak into the global scope and potentially clash with other parts of the script.
  2. Trying to return a string or a number greater than 255 directly, not realizing return is limited to exit status codes.
  3. Assuming functions can accept arrays as a single argument without expanding them first.
  4. Not organizing larger scripts with a main function, resulting in top-level code that’s hard to follow or test.

FAQs

Can Bash functions have optional parameters? Yes, using parameter expansion with defaults, like local name="${1:-default_value}".

How do I call a function from another script? Use source (or its shorthand .) to load the file containing the function definition into your current shell session before calling it.

Can a Bash function return an array? Not directly. Common workarounds include printing array elements (one per line) and capturing them with mapfile, or using namerefs to modify an array passed in by the caller.

What’s the difference between exit and return inside a function? return exits the function and resumes the calling script, while exit terminates the entire script (or subshell), even if called from within a function.

Summary

Functions bring structure and reusability to Bash scripting, letting you group related logic, avoid repetition, and keep your scripts organized around a clear flow. The key ideas to internalize are that return only communicates an exit status, that local is essential for avoiding accidental global state, and that a main function at the bottom of a script is a clean way to tie everything together. Once you start writing functions instead of long flat scripts, you’ll likely find your Bash code becomes both easier to maintain and far less error-prone.

References

Exit mobile version