Local Variables and Scope

Why local Matters

Without local, any variable assigned inside a function becomes (or overwrites) a global variable, which can silently corrupt state elsewhere in the script that happens to use the same name. local varname=value confines the variable strictly to that function call.

Example: Why local Matters

#!/bin/bash
counter=100
increment() {
    local counter=0
    counter=$((counter + 1))
    echo "Inside function, counter is $counter"
}
increment
echo "Outside function, counter is still $counter"

Global Leakage Without local

If a function assigns to a variable without declaring it local, that assignment affects the global variable of the same name (creating it if it didn't exist), and the change persists after the function returns. This is a common source of hard-to-trace bugs in larger scripts.

Warning: Always use local for a function's own working variables unless you specifically intend to modify a global.

Example: Global Leakage Without local

#!/bin/bash
leaky_function() {
    message="set inside function, no local"
}
leaky_function
echo "After call, message is: $message"

Dynamic Scoping: Callees See Caller's Locals

Bash's locals are dynamically scoped, meaning a function called from inside another function can see and use that outer function's local variables, unlike lexically scoped languages where only the enclosing code block matters. This is a distinctive quirk worth knowing even though most scripts don't rely on it directly.

Example: Dynamic Scoping: Callees See Caller's Locals

#!/bin/bash
outer() {
    local shared_value="from outer"
    inner
}
inner() {
    echo "inner sees shared_value as: $shared_value"
}
outer

Separating local Declaration from Command Substitution

Combining local with a command substitution assignment on one line, like local x=$(cmd), can hide cmd's own exit status behind local's exit status. Splitting the declaration and the assignment into two lines preserves the ability to check the substituted command's real exit status.

Example: Separating local Declaration from Command Substitution

#!/bin/bash
check_status() {
    local output
    output=$(echo "data"; exit 3)
    echo "Captured output: $output"
    echo "Exit status of the command substitution: $?"
}
check_status