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:

# 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.

# 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.

# 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.

# 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 <newline> character.

# Legacy syntax nesting (requires escaping)
result=`command1 \`command2\``

Master Bash with Deep Grasping Methodology!

Learn More