> ## 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 Command Substitution Command substitution is an expansion mechanism in Bash that executes a specified command in a subshell and replaces the command itself with its standard output (stdout). ## Syntax Bash supports three primary syntaxes for command substitution: ```bash theme={"dark"} # Modern (POSIX-compliant, preferred) $(command) # Legacy (Bourne shell compatible) `command` # Bash-specific fast file read $(< file) ``` The `$(< file)` syntax is a Bash-specific optimization. It is functionally equivalent to `$(cat file)` but executes faster because it is handled internally by Bash, avoiding the overhead of forking an external `cat` process. ## Execution Mechanics When Bash encounters a command substitution, it performs the following sequence of operations: 1. **Subshell Invocation:** Bash forks a new subshell environment to execute the enclosed `command`. State changes (such as variable assignments or directory changes) within this subshell do not propagate back to the parent shell. 2. **Output Capture:** The standard output stream of the subshell is captured. Standard error (stderr) is not captured unless explicitly redirected to stdout within the substitution (e.g., `$(command 2>&1)`). 3. **Newline Stripping:** Bash automatically removes all trailing newline characters from the captured output. Embedded newlines within the output are preserved. 4. **Exit Status:** The exit status of a command substitution is the exit status of the last command executed within the subshell. If the substitution contains no commands, the exit status is `0`. 5. **Substitution:** The original command string is replaced by the processed output. ## Parsing and Expansion Rules The evaluation of the substituted text depends heavily on its quoting and the parsing context in which it is evaluated. ```bash theme={"dark"} # Unquoted command argument: Subject to word splitting and pathname expansion process_data $(command) # Quoted command argument: Protected from word splitting and pathname expansion process_data "$(command)" # Scalar variable assignment: Splitting and expansion are inherently suppressed result=$(command) # Array variable assignment: Unquoted to intentionally trigger word splitting arr=($(command)) ``` * **Unquoted Substitution:** When an unquoted substitution is evaluated as a command argument, Bash subjects the resulting text to **word splitting** (using the characters defined in the `$IFS` variable as delimiters) and **pathname expansion** (globbing). * **Quoted Substitution:** Enclosing the substitution in double quotes (`"$(command)"`) suppresses word splitting and pathname expansion. The captured output, including spaces and embedded newlines, is preserved and treated as a single word or argument. * **Variable Assignment Context:** The right-hand side of a simple scalar variable assignment is a special parsing context. Bash explicitly suppresses word splitting and pathname expansion during scalar assignment, meaning `result=$(command)` and `result="$(command)"` behave identically. Conversely, compound array assignments (`arr=($(command))`) require the substitution to be unquoted if the output needs to be split into distinct array elements. ## Exit Status in Assignments When a command substitution is assigned directly to a scalar variable, the assignment operation inherits the exit status of the command substitution. This is critical for error handling. However, combining variable declaration builtins (`local`, `export`, `declare`, `typeset`) with the assignment creates a common pitfall: it masks the substitution's exit status. The exit status of the pipeline becomes the exit status of the builtin command (which is almost always `0`), discarding the exit status of the substituted command. ```bash theme={"dark"} # The exit status ($?) reflects the result of 'command' result=$(command) # The exit status ($?) reflects the result of 'local' (usually 0), masking 'command' local result=$(command) # Correct approach to preserve exit status with local variables local result result=$(command) ``` ## Nesting and Escaping The primary technical advantage of the modern `$()` syntax over legacy backticks is its parsing logic, particularly regarding nesting and escaping. With `$()`, the characters between the parentheses are parsed as a completely independent command line. This allows for direct, unescaped nesting and preserves standard quoting rules inside the substitution. ```bash theme={"dark"} # Modern syntax nesting (clean parsing) result="$(command1 "$(command2)")" ``` Conversely, the legacy backtick syntax retains historical, non-intuitive escaping rules. To nest backticks, the inner backticks must be escaped with backslashes. Additionally, backslashes within backticks retain their literal meaning only if not followed by `$`, `` ` ``, `\`, or a `` character. ```bash theme={"dark"} # Legacy syntax nesting (requires escaping) result=`command1 \`command2\`` ```
Tired of Poor Bash Skills? Fix That With Deep Grasping! Learn More