The major one is the ability to nest them, commands within commands, without losing your sanity trying to figure out if some form of escaping will work on the backticks.

An example, though somewhat contrived:

deps=$(find /dir -name $(ls -1tr 201112[0-9][0-9]*.txt | tail -1l) -print)

which will give you a list of all files in the /dir directory tree which have the same name as the earliest dated text file from December 2011 ^(a).

Another example would be something like getting the name (not the full path) of the parent directory:

pax> cd /home/pax/xyzzy/plugh
pax> parent=$(basename $(dirname $PWD))
pax> echo $parent
xyzzy

^(a) Now that specific command may not actually work, I haven't tested the functionality. So, if you vote me down for it, you've lost sight of the intent :-) It's meant just as an illustration as to how you can nest, not as a bug-free production-ready snippet.

This is a backtick. A backtick is not a quotation sign. It has a very special meaning. Everything you type between backticks is evaluated (executed) by the shell before the main command (like chown in your examples), and the output of that execution is used by that command, just as if you'd type that output at that place in the command line.

So, what

sudo chown `id -u` /somedir

effectively runs (depending on your user ID) is:

sudo chown 1000 /somedir
  \    \     \     \
   \    \     \     `-- the second argument to "chown" (target directory)
    \    \     `-- your user ID, which is the output of "id -u" command
     \    `-- "chown" command (change ownership of file/directory)
      `-- the "run as root" command; everything after this is run with root privileges

Have a look at this question to learn why, in many situations, it is not a good idea to use backticks.

Btw, if you ever wanted to use a backtick literally, e.g. in a string, you can escape it by placing a backslash (\) before it.

Text between backticks is executed and replaced by the output of the command (minus the trailing newline characters, and beware that shell behaviors vary when there are NUL characters in the output). That is called command substitution because it is substituted with the output of the command. So if you want to print 5, you can't use backticks, you can use quotation marks, like echo "$b" or just drop any quotation and use echo $b.

As you can see, since $b contains 5, when using backticks bash is trying to run command 5 and since there is no such command, it fails with error message.

To understand how backticks works, try running this:

$ A=`cat /etc/passwd | head -n1`
$ echo "$A"

cat /etc/passwd |head -n1 should print first line of /etc/passwd file. But since we use backticks, it doesn't print this on console. Instead it is stored in A variable. You can echo $A to this. Note that more efficient way of printing first line is using command head -n1 /etc/passwd but I wanted to point out that expression inside of backticks does not have to be simple.

So if first line of /etc/passwd is root:x:0:0:root:/root:/bin/bash, first command will be dynamically substituted by bash to A="root:x:0:0:root:/root:/bin/bash".

Note that this syntax is of the Bourne shell. Quoting and escaping becomes quickly a nightmare with it especially when you start nesting them. Ksh introduced the $(...) alternative which is now standardized (POSIX) and supported by all shells (even the Bourne shell from Unix v9). So you should use $(...) instead nowadays unless you need to be portable to very old Bourne shells.

Also note that the output of `...` and $(...) are subject to word splitting and filename generation just like variable expansion (in zsh, word splitting only), so would generally need to be quoted in list contexts.

What you've typed is a backtick - it is the start of an instruction to bash to evaluate what you type as a command. The > is displayed to indicate you are still entering the command on the next line.

If you close the backtick you'll find the whole command will run. E.g.

~$ cd `
> echo /var`
/var$

No, the backticks do not have a special meaning and you even could run the wget command without them in the if statement.
if always evaluates the exit code of the command followed.

A more comprehensive overview can be found here.

EDIT

Backticks initiate a command substitution which is executed in a subshell and returns an exit code. if just checks return codes, it does not make use of the output of the command.

To compare the output of a command you could use the [ , which must be closed with ], which basically is a test. The test could be anything

• from man test

• a string comparison

  [ "hello" == "test" ]
  

• an integer test

  [ 2 -eq 3 ]  
  

If the test succeeds you get an exit code 0 ( true ), otherwise not 0 ( false ) which is again evaluated by if.

So you have something in mind like follows.

if [ "`wget google.com -T 2 -t 1 -o /dev/null`" == "" ]
then 
    echo "emptY"
fi

But this wouldn't make much sense, due to redirecting the output to /dev/null you will always get true from [ "wget google.com -T 2 -t 1 -o /dev/null" == "" ].
On the other hand it also would not be useful to check if the output of the wget command does contain output, leaving out the -o /dev/null, because even in an error situation you will get output, but different return codes.

The `` is called Command Substitution and is almost equivalent to $() (parenthesis), while you are using ${} (curly braces).

So all of these expressions are equal and mean "interpret the command placed inside":

joulesFinal=`echo $joules2 \* $cpu | bc`
joulesFinal=$(echo $joules2 \* $cpu | bc)
#            v                          v
#      ( instead of {                   v
#                                 ) instead of }

While ${} expressions are used for variable substitution.

Note, though, that backticks are deprecated, while $() is POSIX compatible, so you should prefer the latter.

From man bash:

Command substitution allows the output of a command to replace the command name. There are two forms:

          $(command)
   or
          `command`
   

# later on in the man page:
When the old-style backquote form of substitution is used, backslash retains its literal meaning except when followed by $, `, or \. The first backquote not preceded by a backslash terminates the command substitution. When using the $(command) form, all characters between the parentheses make up the command; none are treated specially.

Also, `` are more difficult to handle, you cannot nest them for example. See comments below and also Why is $(...) preferred over ... (backticks)?.

Use dollar. Backticks are semi-deprecated, because they are more complicated to use (see the link), and there are no advantages to them unless you're doing code golf and absolutely need to save a single character. They probably won't be removed from popular shells anytime soon though, so you're safe using either for now.

What you are missing here is $.

There is 2 forms of command substitution on bash, backticks, as exemplified by you, and enclosing by $(command).

What you should use is:

#!/bin/bash

a=$(echo Hello!)

echo $a

Inside double quotes, backticks are being interpreted by shell, resulting in table being treated as a command. You need to escape them:

hive -e "alter table ${database}.\`${table}\` SET TBLPROPERTIES('EXTERNAL'='FALSE')"

Alternatively, you can use a variable to hold the backticks:

bt="\`"
hive -e "alter table ${database}.$bt${table}$bt SET TBLPROPERTIES('EXTERNAL'='FALSE')"

The issue with your second command

hive -e "alter table ${database}.$(table) SET TBLPROPERTIES('EXTERNAL'='FALSE')"

is that the construct $(table) works the same way as table inside backticks - it is just a better way of doing command substitution in Bash. Hence you get the same error as earlier.

Related posts:

• Difference between single and double quotes in Bash
• What is the benefit of using $() instead of backticks in shell scripts?

For the sake of example, consider that variable foo contains uname (foo=uname).

• echo "$foo" outputs uname, substituting variables in text.
  • For a literal $ character inside " quotes, use \$; for a literal ", use \".
• echo '$foo' outputs $foo, the exact string.
  • Even ' can't be escaped as \' inside ' quotes. But you can use 'foo'\''bar'.
• echo `$foo` outputs Linux, executing the content of the variable and echo printing it.