> ## 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 Function Declaration
A Bash function is a named, reusable block of commands that executes within the current shell execution environment. It acts as a user-defined command that supersedes external executables and shell built-ins of the same name during the shell's command resolution process.
Bash supports three distinct syntactic forms for declaring functions. In all forms, the body of the function can be *any* valid Bash compound command, optionally followed by standard shell redirections.
**1. POSIX Standard Syntax (Recommended)**
This is the most portable declaration method, compatible with strictly POSIX-compliant shells.
```bash theme={"dark"}
function_name() compound-command [redirection]
```
**2. Bash-Specific Keyword Syntax**
This form uses the `function` reserved word and omits the parentheses. It is specific to Bash and KornShell (ksh).
```bash theme={"dark"}
function function_name compound-command [redirection]
```
**3. Combined Syntax**
This form uses both the `function` keyword and parentheses. While valid in Bash, it is redundant and generally discouraged in strict style guides.
```bash theme={"dark"}
function function_name() compound-command [redirection]
```
## Compound Commands as Function Bodies
While the grouping command `{ ... }` is the most common function body, Bash allows a function body to be *any* compound command. This includes subshells `( ... )`, arithmetic evaluations `(( ... ))`, conditional expressions `[[ ... ]]`, and loops (e.g., `for`, `while`, `case`).
```bash theme={"dark"}
# Grouping command (executes in current shell environment)
my_func() { echo "Standard block"; }
# Subshell (executes in a child process)
my_func() ( cd /tmp && ls )
# Arithmetic evaluation
my_func() (( var++ ))
# Conditional expression
my_func() [[ -f "$1" ]]
# Loop
my_func() for i in "$@"; do echo "$i"; done
```
## Lexical and Syntactic Rules
* **Reserved Word Delimiting:** The opening curly brace `{` is a reserved word, not a shell metacharacter. It must be delimited by whitespace *or a shell metacharacter*. If the first command inside the block starts with a metacharacter (such as `(`, `<`, or `>`), no space is required after the `{`. Conversely, `(` and `)` are metacharacters, so `function_name(){` is valid without a space before the brace.
* **Command Termination:** When using the `{ ... }` grouping command, the list of commands within the body must be explicitly terminated. The final command before the closing brace `}` must end with a newline, a semicolon (`;`), or an ampersand (`&`). Subshells `( ... )` do not require this explicit termination before the closing parenthesis.
```bash theme={"dark"}
# Valid: Space after {, terminated with ;
my_func() { command1; command2; }
# Valid: No space after { because ( and > are metacharacters
my_func(){(command1);}
my_func(){>out.txt command1;}
# Invalid: Missing command terminator before }
my_func() { command1; command2 }
```
## Declaration Mechanics
* **Sequential Parsing:** Bash is an interpreted language that parses sequentially. A function must be declared lexically prior to its invocation. The shell does not hoist function declarations.
* **Symbol Table Overwriting:** If a function is declared with a name that already exists in the shell's function environment, the new declaration overwrites the previous one. **Exception:** If the existing function has been marked as read-only using `readonly -f`, Bash will throw an error (`bash: function_name: readonly function`) and refuse to overwrite it.
* **Command Precedence:** Once declared, functions take high precedence in the shell's execution hierarchy. In default Bash, the resolution order is: Aliases > **Functions** > Built-ins (both special and regular) > External Executables (in `$PATH`). *Note: Special built-ins only supersede functions when Bash is invoked in strict POSIX mode.*
* **Removal:** A declared function remains in the current shell's memory until the shell terminates or the function is explicitly removed from the symbol table using the `unset` built-in with the `-f` flag.
```bash theme={"dark"}
unset -f function_name
```
Tired of Poor Bash Skills? Fix That With Deep Grasping!
Learn More
