How to Increment and Decrement Variable in Bash (Counter)

Posted 

3 min read

One of the most common arithmetic operations when writing Bash scripts is incrementing and decrementing variables. This is most often used in loops as a counter, but it can occur elsewhere in the script as well.

Incrementing and Decrementing means adding or subtracting a value (usually 1), respectively, from the value of a numeric variable. The arithmetic expansion can be performed using the double parentheses ((...)) and $((...)) or with the let builtin command.

In Bash, there are multiple ways to increment/decrement a variable. This article explains some of them.

Using + and - Operators

The most simple way to increment/decrement a variable is by using the + and - operators.

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

This method allows you increment/decrement the variable by any value you want.

Here is an example of incrementing a variable within an until loop:

i=0

until [ $i -gt 3 ]
do
  echo i: $i
  ((i=i+1))
done
i: 0
i: 1
i: 2
i: 3

The += and -= Operators

In addition to the basic operators explained above, bash also provides the assignment operators += and -=. These operators are used to increment/decrement the value of the left operand with the value specified after the operator.

((i+=1))
let "i+=1" 
((i-=1))
let "i-=1" 

In the following while loop we are decrementing the value of the i variable by 5.

i=20

while [ $i -ge 5 ]
do
  echo Number: $i
  let "i-=5" 
done
Number: 20
Number: 15
Number: 10
Number: 5

Using the ++ and -- Operators

The ++ and -- operators increment and decrement, respectively, its operand by 1 and return the value.

((i++))
((++i))
let "i++"
let "++i"
((i--))
((--i))
let "i--"
let "--i"

The operators can be used before or after the operand. They are also known as:

  • prefix increment: ++i
  • prefix decrement: --i
  • postfix increment: i++
  • postfix decrement: i--

The prefix operators first increment/decrement the operators by 1 and then return the new value of the operators. On the other hand, the postfix operators return the value of the operators before it has been incremented/decremented.

If you only want to increment/decrement the variable then there is no difference if you use the prefix or postfix operator. It makes a difference only if the result of the operators is used in some other operation or assigned to another variable.

The following examples demonstrates how the ++ operator works when is used before and after its operant:

x=5
y=$((x++))
echo x: $x
echo y: $y
x: 6
y: 5
x=5
y=$((++x))
echo x: $x
echo y: $y
x: 6
y: 6

Below is an example of how to use the postfix incrementor in a bash script:

#!/bin/bash
i=0
while true; do
  if [[ "$i" -gt 3 ]]; then
       exit 1
  fi
  echo i: $i
  ((i++))
done

The disadvantage of using these operators is that the variable can only be incremented or decremented by 1.

Conclusion

Incrementing and decrementing variables in Bash can be performed in many different ways. Whatever method you use, the result is the same.

If you have any questions or feedback, feel free to leave a comment.