Why does `local var=$(cmd)` suppress a subshell’s exit code?

Why does `local var=$(cmd)` Suppress a Subshell’s Exit Code?

When working with bash scripting, understanding the behavior of local variable assignment and its interaction with subshell exit codes can be crucial for debugging and ensuring your scripts work as expected. Here, we’ll delve into a common scenario that can cause unexpected behavior, helping both new and seasoned scripters gain deeper insights.

Q: When I use `local var=$(cmd)` in a function in my script, why can't I access the exit code of `cmd` through `$?`?

A: When you use local var=$(cmd) within a function, the exit code of the cmd is indeed executed, but immediately overwritten by the exit code of the local itself. local is a shell builtin that returns an exit status based on its own execution – mostly successful, hence an exit status of 0. This overwrites the exit code of $(cmd), rendering it unobtainable directly after the assignment.

Background and Further Explanation

Let's take a deeper look with some additional simple examples:

Consider a bash function:

function example {
    local output=$(ls non_existent_file)
    echo $?
}

In the above script, $(ls non_existent_file) tries to list a non-existent file, which should traditionally return a non-zero exit status (error). However, when this command is subsumed within local output=, the $?, which should theoretically hold the exit status of ls, will instead show the exit status of the local command.

To correctly capture the exit status of $(cmd), you can split the declaration and assignment:

function example {
    local output
    output=$(ls non_existent_file)
    echo $?
}

This modification ensures that $? captures the exit status of ls and not that of the local.

Conclusion

Understanding the nuances of bash scripting, such as the behavior of subshell exit codes when using local, can greatly improve the robustness and reliability of your scripts. By considering the examples provided and adjusting your script structure accordingly, you can handle errors more effectively and create more predictable script outcomes.