Command Substitution

## What command substitution does Command substitution runs a command and replaces the whole construct with that command's standard output. Both spellings — `$(command)` and `` `command` `` — do exactly that: bash runs the command in a subshell, collects everything it writes to stdout (stderr is *not* captured and goes straight to the terminal unless you redirect it), removes all trailing newlines, and substitutes what is left in place of the construct. ```bash now=$(date +%F) # now=2026-08-20 old=`date +%F` # identical result ``` The result is then subject to the usual expansion rules — if you leave it unquoted it is word-split and glob-expanded, which is why the habit is `"$(cmd)"` with quotes. That splitting behaviour is a topic of its own; the point here is that it applies identically to both spellings. ## The real difference is the parser The two forms differ in *how bash finds the end of the command and how it treats characters inside*. For `$( )`, bash scans forward keeping track of nesting and quoting until it finds the matching `)`. Everything between the parentheses is then parsed as a completely fresh command, exactly as if it appeared on its own line. Nothing inside needs escaping on account of being inside a substitution. For backticks, bash scans forward for the *next* backtick character. There is no nesting to track — a backtick is a backtick. Inside the backticks, backslash keeps its literal meaning except when it precedes `$`, `` ` `` or `\`, where it is consumed as an escape. That extra escape layer is where all the pain comes from. ## Nesting Because `$( )` tracks its own nesting, this is unremarkable: ```bash script_dir=$(dirname "$(readlink -f "$0")") ``` The same thing in backticks needs the inner pair escaped so the parser does not treat the second backtick as the closing one: ```bash script_dir=`dirname "\`readlink -f "$0"\`"` ``` And it gets worse per level: three levels deep, backslashes multiply, because each layer of parsing eats one. In practice nobody writes correct three-level backticks; they write `$( )`. ## Quoting Inside `$( )`, double quotes are just double quotes — the inner `"$0"` above is a normal quoted expansion, independent of the outer quotes. Inside backticks that appear within double quotes, the quoting interacts, and the classic result is that an inner quoted string terminates the outer one or a backslash disappears. A concrete example of the backslash rule: ```bash echo "$(echo '\$')" # prints \$ echo "`echo '\$'`" # the backslash is consumed differently ``` The rule to remember is that backticks add one round of backslash processing before the command is parsed; `$( )` adds none. ## Readability and tooling Backticks are visually easy to confuse with single quotes in a monospace font, and hard to see in a dense pipeline. ShellCheck emits SC2006 ("Use `$(...)` notation instead of legacy backticks") on every occurrence, so a linted codebase will not contain them. `$( )` has been in POSIX since POSIX.1-2001, so choosing it is not a bashism and does not cost portability — a `#!/bin/sh` script on dash, ash or busybox handles it fine. The only place you still see backticks is very old scripts and pre-1990s Bourne shells. ## What is the same, and worth not forgetting Everything else about the two forms is identical, and those shared properties are usually what the interview is really driving at: - The command runs in a **subshell**, so variables it assigns do not survive. - **All** trailing newlines are stripped, not just one. - Only **stdout** is captured; stderr passes through. Use `2>&1` inside the substitution if you want both. - The substitution's exit status is the exit status of the command it ran, which matters as soon as you put it on the right-hand side of a declaration. ## The short answer to give "They do the same thing, but `$( )` parses the inside as a fresh command so nesting and quoting are natural, while backticks re-scan for the next backtick and impose an extra backslash layer, so every nested level needs escaping. `$( )` is POSIX and lint-clean; write that."