## 1. Overview

The modulo operator can be useful for various tasks in Bash scripting, such as checking if a number is divisible by another number or if a number is even or odd.

In this tutorial, we’ll explore some examples of how we can use the modulo operator in Bash and how we can apply it effectively.

The commands used in this tutorial were tested in Bash shell version 5.1.16.

## 2. The Modulo Operator

The modulo operator, also known as the remainder operator, is a binary operator that evaluates the remainder of a division between two integers. In Bash, we represent the modulo operator with the % symbol.

For instance, 5 % 3 returns 2 because 5 / 3 is 1 with a remainder of 2.

## 3. Basic Usage of %

In Bash scripting, we use % basically in two ways:

• arithmetic expressions
• assignments

Let’s look at these in the following sections.

### 3.1. Using % in Arithmetic Expressions

An arithmetic expression is a combination of numbers, variables, operators, and parentheses that evaluates to a single value. We can use the modulo operator in arithmetic expressions to perform calculations that involve the remainder of a division:

``````\$ echo \$((10 % 4))
2``````

In the code snippet above, we use the \$((…)) construct to perform an arithmetic expression, which evaluates the expression inside and prints out the result with the echo command. We use the modulo operator with 10 as the dividend and 4 as the divisor, and the result is 2, which is the remainder of 10 / 4.

In addition, we can also use % with more complex arithmetic:

``````\$ echo \$(((10 + 5) % 4))
3``````

In the snippet above, we use parentheses to change the order of operations and avoid errors. We add 10 and 5 first, then use the modulo operator with 4 as the divisor. The result is 3, which is the same as (10 + 5) % 4.

### 3.2. Using % With Assignment

We can also use % with variables and parameters in arithmetic expressions:

``````\$ n=10
\$ m=3
\$ echo \$((n % m))
1``````

Here, we declare two variables, n and m, with the values 10 and 3, respectively. We then use % to get the remainder of 3 in 10.

However, we can also assign the result of a modulo operator to a variable using the = operator:

``````\$ x=\$(((10 + 5) % 4))
\$ echo \$x
3``````

Here, we assign the value of (((10 + 5) % 4)) to variable x, and we print out x using the echo command.

Furthermore, we can use the modulo operator with different types of operands and operators, such as negative numbers, hexadecimal numbers, bitwise operators, or conditional operators:

``````\$ echo \$((0x0A % 0x03))
1``````

In this command, we use the modulo operator with hexadecimal numbers as operands. We use the prefix 0x to indicate that the number is in base 16. The modulo operator then returns the remainder of the division between two integers. The result is 1, which is the remainder of hexadecimal A divided by hexadecimal 3.

## 4. Applications of %

We can use the modulo operator for various applications in Bash scripting, depending on the problem we want to solve. Let’s look at some of the common applications.

### 4.1. Checking if a Number Is Even or Odd

One of the simplest applications we can use the modulo operator for is to check if a number is even or odd.

We can do this by using the modulo operator with 2 as the divisor. If the result is 0, then the number is even. Otherwise, it’s odd.

Let’s look at an example to demonstrate this:

``````\$ n=10
\$ if [ \$((n % 2)) -eq 0 ]; then
>   echo "Number \$n is even"
> else
>   echo "Number \$n is odd"
> fi
Number 10 is even
\$ n=7
\$ if [ \$((n % 2)) -eq 0 ]; then
>   echo "Number \$n is even"
> else
>   echo "Number \$n is odd"
> fi
Number 7 is odd``````

In the code snippet above, we tested for two possibilities: whether the number we declared is even or odd using the if else statement. The if statement executes the commands based on the condition we enclosed inside square brackets [ ]. We then use the square brackets to test the expression and return a status of 0 (true) or 1 (false). Furthermore, we use the construct \$((…)) to evaluate the expression inside it and replace it with its value. We then use the -eq operator to compare the two numbers for equality.

After that, we display the value of the variable if it’s even and use the else statement to mark the end of the command for the true branch of the if statement and start the command for the false branch. We then display the result with the echo command.

We also use the fi keyword to show that there are no more commands for either branch of the if statement.

### 4.2. Checking if a Number Is Divisible by Another

Another application of using the modulo operator is to check if a number is divisible by another number. We can do this by using the modulo operator with the divisor as the second operand. If the result is 0, then the number is divisible by the divisor. Otherwise, it’s not.

Let’s look at an example to demonstrate this:

``````\$ n=15
\$ m=3
\$ if [ \$((n % m)) -eq 0 ]; then
>   echo "Number \$n is divisible by \$m"
> else
>   echo "Number \$n is not divisible by \$m"
> fi
Number 15 is divisible by 3
\$ n=16
\$ m=3
\$ if [ \$((n % m)) -eq 0 ]; then
>   echo "Number \$n is divisible by \$m"
> else
>   echo "Number \$n is not divisible by \$m"
> fi
Number 16 is not divisible by 3``````

In this example, we use the same logic as before but with different operands. However, we can use this technique to check for divisibility by any number, such as 5, 10, or 100.

### 4.3. Generating Cyclic Patterns or Sequences

In addition, another application we can use the modulo operator for is to generate cyclic patterns or sequences in Bash scripting. We can do this by using the modulo operator with a fixed number as the divisor and a variable number as the dividend. The result will be a sequence of numbers that repeat after a certain interval:

``````\$ n=1
\$ while [ \$n -le 10 ]; do
>   echo \$((n % 3))
>   n=\$((n + 1))
> done
1
2
0
1
2
0
1
2
0
1``````

In the code snippet above, we use a while loop to iterate over a range of numbers from 1 to 10 and the -le option to compare two numbers for less than or equal to. We use the modulo operator with 3 as the divisor and \$n as the dividend. The result is a sequence of numbers between 0 and 2. We can use this technique to generate any cyclic pattern or sequence, such as days of the week, months of the year, or colors of the rainbow.

## 5. Conclusion

In this article, we’ve learned how we can use the modulo operator in Bash scripting.

Firstly, we discussed the % operator itself. We also looked at how we can use the % operator to perform arithmetic operations and assignments.

Finally, we looked at some typical applications of using the modulo operator, such as checking if a number is odd or even, checking if a number is divisible by another number, and generating cyclic patterns or sequences.

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.