## 1. Introduction

Sometimes, we need to validate whether a number falls within a specified range. For example, we can check if resource utilization is within a range for smooth system operation.

In this tutorial, we’ll discuss methods like conditional statements, arithmetic expressions, functions, and the bc command to check if a number is within a range using the Linux shell.

Moreover, we’re assuming that the range boundaries represent a valid range and are specified using command-line arguments.

## 2. Using the -ge and -le Conditional Operators

The conditional operators play an important role in making decisions based on the argument we provide to them. Here, we’ll incorporate conditional operators with an if-else conditional statement.

The primary purpose of conditional statements is to introduce decision-making capabilities in code. Usually, we first check the desired condition with an if construct. If it’s true, the code inside its body is executed. Otherwise, the else statement is executed.

Let’s use this construct to check whether a number falls within a range:

``````\$ cat ifrange.sh
#!/bin/bash

number="\$1"
lower_limit="\$2"
upper_limit="\$3"

if [ "\$number" -ge "\$lower_limit" ] && [ "\$number" -le "\$upper_limit" ]; then
echo "The number is within the range"
else
echo "The number is outside the range"
fi``````

This script assigns the command-line arguments \$1, \$2, and \$3 to the variables number, lower_limit, and upper_limit, respectively.

Next, we use the if condition to compare the variable number with lower_limit and upper_limit. If the variable number is greater than or equal to (-ge) the lower_limit and less than or equal to (-le) the upper_limit, we see “The number is within the range”. Otherwise, the else statement prints “The number is outside the range”.

Notably, we can also replace the conditional operators -ge and -le with -gt and -lt in the script. This substitution would be appropriate if we intend to exclude upper_limit and lower_limit from the range.

## 3. Using Arithmetic Expressions

We can use arithmetic expressions to check for the conditions that involve numerical values. The arithmetic expression can help us determine whether a specific relationship between numbers is true or false:

``````\$ cat arithrange.sh
#!/bin/bash

number="\$1"
lower_limit="\$2"
upper_limit="\$3"

if ((number >= lower_limit && number <= upper_limit)); then
echo "The number is within the range."
else
echo "The number is outside the range."
fi``````

In this case, we compare the variable number with lower_limit and upper_limit using the arithmetic expression ((…)) inside the if-else conditional statement. Although it utilizes conditionals, the syntax within an arithmetic expression is different.

Similarly, if we’re doing an exclusive range check, we may need to slightly modify the arithmetic expression inside the if conditional statement:

``if ((number > lower_limit && number < upper_limit));``

Thus, the expression checks if the variable number is greater than the lower_limit and less than the upper_limit, indicating that it falls within the specified range.

## 4. Using a Function

Often, we can use functions to break the large script into smaller manageable pieces to improve the overall readability of the code.

Furthermore, once we’ve written the functions, we can reuse them in different parts of the code to minimize redundancy, thereby effectively reducing the code length.

Let’s write another script that defines a function for checking whether a given number is within a range and then calls that function with some example values:

``````\$ cat funcrange.sh
#!/bin/bash

check_range() {
local number="\$1"
local lower_limit="\$2"
local upper_limit="\$3"

if [ "\$number" -ge "\$lower_limit" ] && [ "\$number" -le "\$upper_limit" ]; then
echo "\$number is within the range [\$lower_limit, \$upper_limit]"
else
echo "\$number is outside the range [\$lower_limit, \$upper_limit]"
fi
}

number=15
lower_limit=10
upper_limit=20

check_range "\$number" "\$lower_limit" "\$upper_limit"
``````

In this example, we define a function named check_range that takes three parameters: number, lower_limit, and upper_limit. Next, we declare three local variables inside the function.

Then, we call check_range with specific values for variable number, lower_limt, and upper_limit. Lastly, we test the values inside the body of the if-else condition.

Finally, the function prints the corresponding message by evaluating the variable number based on the provided range.

Notably, we can access the defined function by name from the command line if we source this file, or we can simply define the function within the shell session.

## 5. Using the bc Command

The bc (basic calculator) tool is a command-line calculator that’s particularly useful for performing calculations within shell scripts:

``````\$ cat bcrange.sh
#!/bin/bash

number="\$1"
lower_limit="\$2"
upper_limit="\$3"

output=\$(echo "\$number >= \$lower_limit && \$number <= \$upper_range" | bc)

if [ "\$output" -eq 1 ]; then
echo "The number is within the range."
else
echo "The number is outside the range."
fi``````

Instead of directly using numeric values to represent mathematical expressions, we use the echo command to construct a string. This string includes the values of the variables number, upper_limit, and lower_limit.

Then, we pass the constructed string as input to the bc command using the pipe (|) operator. In turn, the bc command evaluates the mathematical expression. If the expression is true, the bc command returns 1; otherwise, it returns 0.

We store the result inside a new variable named output, which we test within the if-else condition.

## 6. Conclusion

In this article, we learned several ways to check if a certain number is within a desired range.

First, we used conditional statements for basic decision-making, which is not only efficient but also easy to understand. Next, we used arithmetic expressions that offer a concise approach to handle numeric values. Then, we turned to functions as a good choice for enhancing code readability and reusability.

Finally, we used the bc command, which is suitable for handling complex mathematical expressions.

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