> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Bash Local Variable
A local variable in Bash is a variable whose scope is restricted to the execution context of the function in which it is declared, including any child functions invoked within that call stack. Declaring a local variable shadows any globally scoped variable or outer-scoped local variable sharing the same identifier until the declaring function terminates.
## Syntax and Declaration
Local variables are instantiated using the `local` shell builtin. The `local` command is functionally equivalent to `declare` but is strictly limited to function scope. It accepts the same attribute flags as `declare`.
```bash theme={"dark"}
function define_locals() {
# Standard local declaration and assignment
local var_name="string_value"
# Local declaration with attribute flags
local -i int_var=42 # Integer attribute
local -r const_var="foo" # Readonly attribute
local -a array_var=(1 2) # Indexed array attribute
local -A dict_var # Associative array attribute
}
```
## Technical Mechanics
**Dynamic Scoping**
Unlike languages that utilize lexical (static) scoping, Bash employs dynamic scoping. A local variable is visible not only to the function that declares it but also to any subsequent functions called from within that function's execution block.
```bash theme={"dark"}
function parent_func() {
local shared_var="parent_scope"
child_func
}
function child_func() {
# Inherits access to shared_var due to dynamic scoping
# Modifying it here modifies the parent_func's local instance
shared_var="modified_by_child"
}
```
**Execution Context Restriction**
The `local` builtin is strictly bound to function execution. Attempting to invoke `local` in the global scope (outside of a function definition) results in a runtime error: `bash: local: can only be used in a function`.
**Shadowing and Call Frame Restoration**
When a local variable is declared, Bash allocates a new memory space for the identifier within the current call frame. Any existing variable with the same name in a higher scope is shadowed. Once the function returns, the local call frame is destroyed, and the shadowed variable's original value and attributes are restored to the environment.
**Exit Code Masking**
A critical mechanical behavior of `local` occurs during command substitution. Because `local` is a builtin command, combining declaration and command substitution on a single line causes the exit status (`$?`) to reflect the success of the `local` assignment (which is `0`), thereby masking the exit status of the substituted command.
```bash theme={"dark"}
function masked_exit_code() {
# The exit code of 'some_command' is masked. $? will evaluate to 0.
local result=$(some_command)
# Strict mechanical approach: Declare first, assign second.
local result
result=$(some_command) # $? will correctly reflect some_command's exit status
}
```
Tired of Poor Bash Skills? Fix That With Deep Grasping!
Learn More
