Question

I had used several ways to do some simple integer arithmetic in BASH (3.2). But I can’t figure out the best (preferred) way to do it.

result=`expr 1 + 2`
result=$(( 1 + 2 ))
let "result = 1 + 2"

What are the fundamental differences between those expressions?
Is there other ways to do the same?

Is the use of a tool like bc mandatory for floating point arithmetic?

result=`echo "7/354" | bc`

Answer 1

In Bash, let allows multiple assignments on a line:

let a=3 b=4 c=5

As you show in your question, quoting the argument to let allows you to put spaces around the operators. You can, however, omit the quotes if you avoid using spaces.

Another form using double parentheses at the beginning of the statement (instead of the i=$((j + 1)) form) allows you to include spaces around the equal sign or do post- or pre- increment or decrement and additional assignment operations:

(( a = ( b + c ) * 4 ))
(( count++ ))
(( d = --c**2 ))
(( e *= 2 ))
(( f = 3, g = 5 ))    # multiple operations require a comma separator

If you do help "((" it says that the double parentheses is ‘Equivalent to “let EXPRESSION“.’

You can use the declare builtin to make assignments, including indirectly:

blue=2
name=blue
declare $name=4
echo $blue    # result: 4
echo ${!name} # result: 4

Edit:

The $(()) construct is called “arithmetic expansion” and causes the contents to be evaluated as an integer expression. It’s a syntax element of the shell.

If a variable is declared as an integer you don’t need to use either form of double parentheses, you can omit the dollar sign from the variable name (as in the double-parentheses forms), but you can’t add spaces around operators:

declare -i x=1   # set integer, initialize to 1
declare +i s=1   # clear integer, initialize to 1
x+=1             # could also be x=x+1
echo $x          # result: 2 (addition)
s+=1             # could also be s=$s+1, requires a "$"
echo $s          # result: 11 (string concatenation)

Unlike the forms above, calling expr involves spawning an external executable which can be quite expensive for a lot of calculations in a loop. The only time it should be used is in environments where the shell can’t do its own arithmetic or for portability when a script may find its way into such an environment. POSIX shells have arithmetic capability so it would be a concern only with older systems.

Regarding the use of bc for floating point arithmetic, it or something similar is required when using Bash and many other shells. POSIX says that “Only signed long integer arithmetic is required.”

Two shells that do support float math are ksh and zsh. In addition to bc, you can use dc, AWK, Python, Perl and others from within a Bash script.

One thing that Bash will do with floating point numbers is print them with the printf builtin (note that there is also an external printf, but builtins have priority).

printf "%'14.4f\n" 1234.56  # result "    1,234.5600" (in my locale)