Building a Number Checker Script: Bash If-Elif-Else and String Testing

Building practical scripts that can handle different scenarios is where bash scripting becomes truly powerful. In this tutorial, we'll create a number checker script that demonstrates input validation and multiple conditional paths using if-elif-else statements.

🚀 Building the Number Checker Script

Let's create a practical script that takes a number as input and tells us whether it's above 10, exactly 10, or below 10. This script will demonstrate proper input validation and multiple conditional branches.

📝 Step 1: Create the Script File

Let's start by creating our script file:

touch numbercheck.sh

This creates an empty file called numbercheck.sh that we'll use for our number checking script.

✏️ Step 2: Write the Script Logic

Open the file with nano (or your preferred text editor):

nano numbercheck.sh

Add the following script content:

#!/bin/bash
if [ -z "$1" ]; then
	echo "No number provided. Usage: ./numbercheck.sh <number>"
	exit 1
fi
number=$1
if [ $number -gt 10 ]; then
	echo "Above 10"
elif [ $number -eq 10 ]; then
	echo "Exactly 10"
else
	echo "Below 10"
fi

Let's examine what this script does step by step.

🔍 Understanding the -z Operator

The -z operator is a string testing operator that checks if a string is empty (has zero length).

How -z Works

# -z returns true if the string is empty
if [ -z "$variable" ]; then
    echo "Variable is empty"
fi

In our script:

if [ -z "$1" ]; then
    echo "No number provided. Usage: ./numbercheck.sh <number>"
    exit 1
fi

Why We Use -z for Validation

# User runs: ./script.sh
if [ -z "$1" ]; then
    echo "Please provide a number"
    exit 1
fi
# Script stops here with helpful message

# User runs: ./script.sh
number=$1  # number is empty
if [ $number -gt 10 ]; then
    # Error: unary operator expected
fi

🔢 Step 3: Make the Script Executable

After saving the script, make it executable:

chmod +x numbercheck.sh

Now the script can be run directly with ./numbercheck.sh.

🧪 Step 4: Test the Script

Let's test our script with different inputs to see how it behaves:

Test 1: Number Above 10

$ ./numbercheck.sh 15
Above 10

The script correctly identifies that 15 is greater than 10.

Test 2: Number Exactly 10

$ ./numbercheck.sh 10
Exactly 10

The script recognizes when the input is exactly 10.

Test 3: Number Below 10

$ ./numbercheck.sh 5
Below 10

The script identifies that 5 is less than 10.

Test 4: No Argument Provided

$ ./numbercheck.sh
No number provided. Usage: ./numbercheck.sh <number>

The -z validation catches the missing argument and provides a helpful usage message.

🏗️ Understanding the Script Structure

Let's break down the complete script logic:

Input Validation Block

if [ -z "$1" ]; then
	echo "No number provided. Usage: ./numbercheck.sh <number>"
	exit 1
fi

• Line 1: Check if first argument is empty using -z
• Line 2: Display error message and usage instructions
• Line 3: Exit with error code 1 to indicate failure

Variable Assignment

number=$1

After validation, we know $1 contains a value, so we assign it to a descriptive variable name.

Multiple Condition Chain

if [ $number -gt 10 ]; then
	echo "Above 10"
elif [ $number -eq 10 ]; then
	echo "Exactly 10"
else
	echo "Below 10"
fi

This demonstrates the if-elif-else structure:

• if: First condition to check
• elif: Additional condition (else-if)
• else: Fallback for all other cases
• fi: End of the conditional block

🔄 How the Script Execution Flows

Let's trace through different execution paths:

Path 1: Valid Number Above 10

1. Check if $1 is empty → false (contains "15")
2. Assign number=15
3. Check if 15 > 10 → true
4. Execute: echo "Above 10"
5. Skip elif and else blocks
6. Script ends successfully

Path 2: Valid Number Equal to 10

1. Check if $1 is empty → false (contains "10")
2. Assign number=10
3. Check if 10 > 10 → false
4. Check if 10 = 10 → true
5. Execute: echo "Exactly 10"
6. Skip else block
7. Script ends successfully

Path 3: Valid Number Below 10

1. Check if $1 is empty → false (contains "5")
2. Assign number=5
3. Check if 5 > 10 → false
4. Check if 5 = 10 → false
5. Execute else block: echo "Below 10"
6. Script ends successfully

Path 4: No Argument Provided

1. Check if $1 is empty → true (no argument provided)
2. Execute: echo "No number provided..."
3. Execute: exit 1
4. Script terminates with error code 1

🎯 Why This Pattern Is Useful

This script demonstrates several important bash scripting patterns:

Robust Input Validation

# Always check if required arguments exist
if [ -z "$1" ]; then
    echo "Error message with usage instructions"
    exit 1
fi

Clear User Feedback

# Provide helpful messages for different outcomes
echo "Above 10"      # Clear, concise output
echo "Exactly 10"    # Specific case handling
echo "Below 10"      # Covers remaining cases

Logical Flow Control

# Use if-elif-else for mutually exclusive conditions
if [ condition1 ]; then
    # Handle first case
elif [ condition2 ]; then
    # Handle second case
else
    # Handle all other cases
fi

🧪 Testing Different Scenarios

Let's verify our script handles edge cases correctly:

# Test various numbers
$ ./numbercheck.sh 100
Above 10

$ ./numbercheck.sh 11
Above 10

$ ./numbercheck.sh 10
Exactly 10

$ ./numbercheck.sh 9
Below 10

$ ./numbercheck.sh 0
Below 10

$ ./numbercheck.sh -5
Below 10

# Test validation
$ ./numbercheck.sh
No number provided. Usage: ./numbercheck.sh <number>

🎯 Key Takeaways

💬 Discussion

I'd love to hear about your script building experience:

• What other validation scenarios have you encountered?
• How do you prefer to handle invalid input in your scripts?
• What practical scripts are you building with if-elif-else logic?
• Any creative uses for the -z operator you've discovered?

Connect with me:

• 🐙 GitHub - Number checker script and variations
• 📧 Contact - Script validation questions and discussions