Using expr, $(()), (())

Question

In shell script we can substitute expr $a*$b with $(($a+$b)).

But why not just with (($a+$b)), because in any resource it is written that (()) is for integer computation.

So we use $(()) when there are variables instead of integer values do we? And what should we use instead of $(()) when variables can receive float values?

Answer 1

1. For arithmetic, expr is archaic. Don't use it.*

2. $((...)) and ((...)) are very similar. Both do only integer calculations. The difference is that $((...)) returns the result of the calculation and ((...)) does not. Thus $((...)) is useful in echo statements:

    $ a=2; b=3; echo "$((a*b))" 6 

   ((...)) is useful when you want to assign a variable or set an exit code:

    $ a=3; b=3; ((a==b)) && echo yes yes 

3. If you want floating point calculations, use bc or awk:

   $ echo '4.7/3.14' | bc -l 1.49681528662420382165 $ awk 'BEGIN{print 4.7/3.14}' 1.49682 

*As an aside, expr remains useful for string handling when globs are not good enough and a POSIX method is needed to handle regular expressions.

Answer 2

expr is old, but it does have one limited use I can think of. Say you want to search a string. If you want to stay POSIX with grep, you need to use a pipe:

if echo november | grep nov then : do something fi 

expr can do this without a pipe:

if expr november : nov then : do something fi 

the only catch is expr works with anchored strings, so if you want to match after the beginning you need to change the REGEXP:

if expr november : '.*ber' then : do something fi 

Regarding (( )), this construct is not POSIX, so should be avoided.

Regarding $(( )), you do not have to include the dollar sign:

$ fo=1 $ go=2 $ echo "$((fo + go))" 3 

Answer 3

It seems that the following programs do more or less the same and they don't really differ. But that is not true.

#!/bin/bash s=-1000 for (( i=0; i<1000000; i++ )); do s=$((s+1)) done echo "$s" 

This is the correct way to implement this. The expression s+1 is evaluated by the shell and can be assigned to a variable.

#!/bin/bash s=-1000 for (( i=0; i<1000000; i++ )); do s=`expr "$s" + 1` done echo "$s" 

Here the expression will be calculated by the program expr, which isn't a shell builtin but an external Unix program. So instead of simply adding 1 and s a program must be started und its output must be read and written to the variable. Starting a programm needs a lot of resources and a lot of time. And this program is run 1000000 times. So the program will be much slower than the previous. Nevertheless the code works correctly.

#!/bin/bash -e s=-1000 for (( i=0; i<1000000; i++ )); do ((s=s+1)) done echo "$s" 

If the -e flag isn't set, the program will work correctly, too. But if -e is set when s=-1 and ((s=s+1)) is calculated. The expression s=s+1 evaluates to 0 and the exit code of ((0)) is >0 which is interpreted as an error by the shell and the shell exits the program.

The reason to set the -e flag is that it is the simplest way of error processing: stop if an error ocurrs.