Bash Command Substitution

Command substitution in Bash allows you to execute a command and use its output as part of another command or assign it to a variable. There are two common syntaxes: backticks (``) or the dollar sign and parentheses ($()). This feature is useful for dynamically generating values or incorporating the results of commands into larger operations, enhancing the flexibility and functionality of Bash scripts.

Backticks ( ) Syntax:
# Store the result of 'date' command in the variable 'current_date' current_date=`date` # Print the result echo "Current date is: $current_date"

Dollar Sign and Parentheses ($()) Syntax

# Store the result of 'pwd' command in the variable 'current_directory' current_directory=$(pwd) # Print the result echo "Current directory is: $current_directory"

Both syntaxes achieve the same result, but the $() syntax is generally preferred as it is more readable and allows for nesting commands more easily.

Command Substitution in Complex Commands

You can use command substitution in more complex commands or within strings:

# Display the number of files in the current directory echo "Number of files: $(ls -l grep -v ^d wc -l)"

In this example, ls -l grep -v ^d wc -l is a command that lists files in the current directory, filters out directories, and then counts the remaining lines. The result is substituted into the larger command.

Nesting Command Substitution

You can also nest command substitutions:

# Display the result of a nested command substitution echo "Today is $(date), and the directory is $(pwd)"

Here, date and pwd commands are nested within the main command, and their respective outputs are substituted into the larger command.

Best Practices for Using Command Substitution

When using command substitution in Bash, there are several best practices to follow to ensure code readability, maintainability, and reliability:

Use $() syntax

Prefer the $() syntax over backticks for command substitution. It is more modern, supports nesting, and is generally considered more readable.


Quote your variables

Always quote variables that result from command substitution to handle cases where the output contains spaces or special characters.


Avoid unnecessary subshells

Minimize the use of unnecessary subshells, as each subshell introduces a new process. This can impact performance, especially in scripts with frequent command substitution.

# Avoid unnecessary subshell value=$(echo "Hello") # Preferred way value="Hello"

Use command substitution in a readable manner

Use command substitution where it enhances readability and simplifies complex commands. Avoid overusing it, as excessive nesting can make code hard to understand.

# Less readable result="Today is $(date), and the directory is $(pwd)" # More readable current_date=$(date) current_directory=$(pwd) result="Today is $current_date, and the directory is $current_directory"

Handle errors and edge cases

Check the return status of commands within command substitution and handle potential errors or unexpected outputs to avoid unintended consequences in your script.

result=$(command) # Check if the command was successful if [ $? -eq 0 ]; then echo "Command succeeded: $result" else echo "Command failed" fi


  1. Consider alternatives: Sometimes, directly iterating through data structures might be more efficient than command substitution, especially for large datasets.
  2. Avoid excessive use: Don't overuse command substitution if simpler options exist. Analyze if simpler alternatives like loops or direct manipulation can achieve the same outcome.


Command substitution in Bash allows you to capture the output of a command and use it as part of another command or assign it to a variable. Using either backticks or the more modern $() syntax, this feature enhances the flexibility and readability of Bash scripts by dynamically incorporating the results of commands into larger operations. It is essential to handle quoting, errors, and readability to ensure robust and maintainable scripts.