Softpanorama (slightly skeptical) Open Source Software Educational Society

May the source be with you, but remember the KISS principle ;-) Softpanorama Search

Arithmetic Expressions in BASH

Older UNIX shells like Borne shell  have clumsy, extremely inconvenient and confusing way of doing arithmetic.  When Perl arrived, it was clear the shell is an outdated crap for most system administration tasks that involve substantial calculations. So ksh93 was created to fight back the lost ground. While it failed to stop Perl, ksh93 was a big improvement, and later bash re-implemented most of the advanced features of ksh93 plus a couple of its own.  The version to look for the features described is bash 3.2 or later.

First of all in BASH you can (and should) use $(( )) or let for integer arithmetic expressions. For example:

	i=$(( i + 1 ))
	let i+=1

or

	i=$(( i++))
	let i++

You must not have spaces around the equals sign, as with any bash variable assignment. As long as you keep to integer arithmetic, you can use all the standard C-language operators inside of $(()). Spaces are treated as in any normal algorithmic language: they are options.  But again, please be aware that space before equal sign confuses bash into thinking that this is a function invocation:

	i = $(( i + 5 )) # not what you think!

In this case bash will try to run a program named i and its first argument would be an equal sign, and its second argument would be the number you get adding 5 to the value of $i.

Another oddity to these expressions is that the R-value rule ($ should be prefixed to the shell variable on the right side of assignment statement to get its value) is not applicable inside the double parentheses. But at the same time you do need the dollar sign for positional parameters (e.g.,$2) to distinguish it from a numeric constant (e.g., "2"). Here's an example:

	i=$(( i + $2 ))

There is a several shortcuts supported by BASH. One is += type of operators (familiar to any programmer):

	let i=i+5

can be written as

	let i+=5

	let i++

	(( i++ ))

These assignment operators are also available with $(( )) provided they occur inside the double parentheses. The outermost assignment is still just plain old shell variable assignment.

The assignments can also be cascaded, through the use of the comma operator:

	echo $(( X+=2 , Y++ ))

which will do both assignments and then echo the result of the second expression (since the comma operator returns the value of its second expression).

Unlike many other places in bash scripts where certain characters have special meanings (like the asterisk for wildcard patterns or parentheses for subshell execution), in these expressions we don't need to use quotes or backslashes to escape them since they don't have their special meaning in let statements or inside of the $(( )) construct:

	let Y=(X+2)*10

	Y=$(( ( X + 2 ) * 10 ))

The $(( )) syntax allows all sorts of whitespace within the parentheses. For that reason, it is both less prone to errors and makes the code much more readable and is, therefore, our preferred way of doing bash integer arithmetic. However, an exception can be made for the occasional += assignment or ++ operator, or when we get nostalgic for the early days of BASIC programming (which had a LET statement).

The differences between the ((...)) command and let command

There are two major differences:

• all characters between the (( and )) are treated as quoted (no macro expension).
• The let statement requires that there be no spaces around not only the assignment operator (the equal sign), but around any of the other operators as well; it must all be packed together into a single word. You need to use quotes if you want to use spaces between tokens of the expression for example
  let "i = i +  1"

The ((...)) command is more convenient to use than let, because some of the arithmetic operators (like *) have special meaning to the shell.  The only contract that is often used with let is inrement like in

let i++

This commands is equivalent to:

let i=i+1 

and to

(( i=i + 1 ))

(( i++ ))  

X=`expr $X + 1` 

There is a similar mechanism for integer arithmetic with shell variables using the bash built-in let statement. It uses the same arithmetic operators as the $(( )) construct:

	let i=i+5 

When using let, there are some fancy assignment operators we can use such as this (which will accomplish the same thing as the previous line):

	let i+=5

function mess
{
   if (( "$1" > 0 )) ; then>
      total=$1
   else
      total=100
   fi
   tail -$total /var/adm/messages | more

}

Using Array Variables

Initialization of arrays in bash has format similar to Perl:

	solaris=(serv01 serv02 serv07 ns1 ns2)

Each element of the array is a separate word in the list enclosed in parentheses. Then you can refer to each this way:

	echo solaris is installed on ${solaris[2]}

If you omit index writing  echo $solaris you will get the first element too.

array=(red green blue yellow magenta)
len=${#array[*]}
echo "The array has $len members. They are:"
i=0
while [ $i -lt $len ]; do
	echo "$i: ${array[$i]}"
	let i++
done                          

$ ./myscript.sh

The array has 5 members. They are:
0: red
1: green
2: blue
3: yellow
4: magenta

Old News ;-)

[Jun 19, 2008] Bash Arrays  by Mitch Frazier

Linux Journal

If you're used to a "standard" *NIX shell you may not be familiar with bash's array feature. Although not as powerful as similar constructs in the P languages (Perl, Python, and PHP) and others, they are often quite useful.

Bash arrays have numbered indexes only, but they are sparse, ie you don't have to define all the indexes. An entire array can be assigned by enclosing the array items in parenthesis:

  arr=(Hello World)

Individual items can be assigned with the familiar array syntax (unless you're used to Basic or Fortran):

  arr[0]=Hello
  arr[1]=World

But it gets a bit ugly when you want to refer to an array item:

  echo ${arr[0]} ${arr[1]}

To quote from the man page:

The braces are required to avoid conflicts with pathname expansion.

 

In addition the following funky constructs are available:

  ${arr[*]}         # All of the items in the array
  ${!arr[*]}        # All of the indexes in the array
  ${#arr[*]}        # Number of items in the array
  ${#arr[0]}        # Length if item zero

The ${!arr[*]} is a relatively new addition to bash, it was not part of the original array implementation.

 

The following example shows some simple array usage (note the "[index]=value" assignment to assign a specific index):

#!/bin/bash

array=(one two three four [5]=five)

echo "Array size: ${#array[*]}"

echo "Array items:"
for item in ${array[*]}
do
    printf "   %s\n" $item
done

echo "Array indexes:"
for index in ${!array[*]}
do
    printf "   %d\n" $index
done

echo "Array items and indexes:"
for index in ${!array[*]}
do
    printf "%4d: %s\n" $index ${array[$index]}
done

Running it produces the following output:

Array size: 5
Array items:
   one
   two
   three
   four
   five
Array indexes:
   0
   1
   2
   3
   5
Array items and indexes:
   0: one
   1: two
   2: three
   3: four
   5: five

Note that the "@" sign can be used instead of the "*" in constructs such as ${arr[*]}, the result is the same except when expanding to the items of the array within a quoted string. In this case the behavior is the same as when expanding "$*" and "$@" within quoted strings: "${arr[*]}" returns all the items as a single word, whereas "${arr[@]}" returns each item as a separate word.

The following example shows how unquoted, quoted "*", and quoted "@" affect the expansion (particularly important when the array items themselves contain spaces):

#!/bin/bash

array=("first item" "second item" "third" "item")

echo "Number of items in original array: ${#array[*]}"
for ix in ${!array[*]}
do
    printf "   %s\n" "${array[$ix]}"
done
echo

arr=(${array[*]})
echo "After unquoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
    printf "   %s\n" "${arr[$ix]}"
done
echo

arr=("${array[*]}")
echo "After * quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
    printf "   %s\n" "${arr[$ix]}"
done
echo

arr=("${array[@]}")
echo "After @ quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
    printf "   %s\n" "${arr[$ix]}"
done

When run it outputs:

Number of items in original array: 4
   first item
   second item
   third
   item

After unquoted expansion: 6
   first
   item
   second
   item
   third
   item

After * quoted expansion: 1
   first item second item third item

After @ quoted expansion: 4
   first item
   second item
   third
   item

Mitch Frazier is the System Administrator at Linux Journal.

Arithmetic expansion with double parentheses, and using let 

The use of backticks (backquotes) in arithmetic expansion has been superseded by double parentheses -- ((...)) and $((...)) -- and also by the very convenient let construction.

z=$(($z+3))
z=$((z+3))                                  #  Also correct.
                                            #  Within double parentheses,
                                            #+ parameter dereferencing
                                            #+ is optional.

# $((EXPRESSION)) is arithmetic expansion.  #  Not to be confused with
                                            #+ command substitution.



# You may also use operations within double parentheses without assignment.

  n=0
  echo "n = $n"                             # n = 0

  (( n += 1 ))                              # Increment.
# (( $n += 1 )) is incorrect!
  echo "n = $n"                             # n = 1


let z=z+3
let "z += 3"  #  Quotes permit the use of spaces in variable assignment.
              #  The 'let' operator actually performs arithmetic evaluation,
              #+ rather than expansion.

 

Recommended Links

---

In case of broken links please try to use Google search. If you find the page please notify us about new location

Advanced Bash-Scripting Guide

• The URL of the preferred download site for the pdf version of the ABS Guide is:
  
  http://personal.riverusers.com/~thegrendel/abs-guide.pdf
  
  This version is specially book-formatted for duplex printing and is usually more up-to-date than the version you can download from the LDP site. Note that it's a 2.6 MB download.
• http://personal.riverusers.com/~thegrendel/abs-guide-5.2.tar.bz2 The "bleeding edge" branch is the 'tar/BZ2' link. It will generally run anywhere from a few days to a couple of months ahead of the main release on the LDP site.

Linux.com Turn Vim into a bash IDE

Debugging

Reference