Bash While Loop with Examples

A Bash while loop is a control flow statement that allows code to be executed repeatedly based on a given Boolean condition. The loop continues to execute as long as the specified condition evaluates to true. This powerful tool is integral for tasks that require repeated execution, making it indispensable for system administrators and developers alike.

In this blog post, we will delve deep into the world of Bash while loops. We’ll start with the basic syntax and simple examples to build a strong foundation.

Basic Syntax of a Bash While Loop

The syntax of a Bash while loop is straightforward but powerful:

while [condition]
do
    # Code to be executed
done

Here, the [condition] is a test command that returns a status of 0 (true) or 1 (false). As long as the condition evaluates to true, the block of code within the do and done keywords will execute. Once the condition evaluates to false, the loop terminates.

While Loop Examples

In this section, we will delve into several examples where while loops can simplify and automate tasks effectively. These examples will illustrate various use cases, enhancing your ability to apply while loops in your own scripting projects.

Counting Numbers

One of the simplest yet most illustrative examples of a while loop is counting numbers. This example reinforces the basic syntax and demonstrates how to control the flow of execution within the loop.

#!/bin/bash

counter=1

while [ $counter -le 10 ]
do
    echo "Counter: $counter"
    ((counter++))
done

The while loop continues as long as the condition [ $counter -le 10 ] is true. Each iteration prints the current value of counter and then increments it by 1. When counter exceeds 10, the loop terminates.

Reading a File Line by Line

Reading a file line by line is a common task in scripting, often required for processing or analyzing text data. The while loop provides an efficient way to handle this.

#!/bin/bash

filename="example.txt"

while IFS= read -r line
do
    echo "Line: $line"
done < "$filename"

Infinite Loop and How to Break It

While loops can be used to create infinite loops, which are useful for tasks that require continuous execution until an external condition changes. However, it’s crucial to know how to break out of such loops to avoid potential issues.

#!/bin/bash

while true
do
    echo "Press [CTRL+C] to stop..."
    sleep 1
done

Uses while true to create an infinite loop that will run indefinitely.

To break this loop, you typically use an external interrupt like CTRL+C. Alternatively, you can use conditional statements within the loop to break out based on certain conditions:

#!/bin/bash
while true
do
    read -p "Enter a number (0 to exit): " number
    if [ "$number" -eq 0 ]; then
        echo "Exiting..."
        break
    fi
    echo "You entered: $number"
done

The loop prompts the user for input and exits when the user enters 0. The break statement is used to terminate the loop.

This example illustrates how to manage infinite loops safely and effectively.

Using While Loops with Conditional Expressions

Combining while loops with conditional expressions allows for more granular control over the flow of your script. This technique is particularly useful for creating dynamic and responsive scripts that can adapt to varying conditions.

Nested While Loops

Nested while loops are useful for handling multi-dimensional data or performing complex iterative operations. This technique involves placing one while loop inside another, allowing for the simultaneous iteration over multiple levels of data.

Generating a Multiplication Table

#!/bin/bash

rows=5
columns=5

row=1
while [ $row -le $rows ]
do
    column=1
    while [ $column -le $columns ]
    do
        echo -n "$((row * column)) "
        ((column++))
    done
    echo
    ((row++))
done

Using While Loops with Arrays

While loops can also be employed to iterate over arrays, providing a flexible way to process collections of data. This is particularly useful when dealing with dynamic or unknown-length data sets.

#!/bin/bash

names=("Alice" "Bob" "Charlie" "Diana")

index=0
while [ $index -lt ${#names[@]} ]
do
    echo "Name: ${names[$index]}"
    ((index++))
done

The condition [ $index -lt ${#names[@]} ] ensures that the loop runs until all elements in the array have been processed.

While True Loops

A while true loop is essentially an infinite loop that repeatedly executes its body as long as the condition remains true. In this context, true is a command that always returns a status code of 0, ensuring the loop runs indefinitely. These loops are particularly useful for background tasks, monitoring systems, and handling continuous processes that need to run perpetually.

The basic syntax of a while true loop is straightforward:

while true
do
    # Code to be executed
done

This structure ensures that the block of code within the do and done keywords is executed repeatedly without interruption, unless an external condition or command within the loop causes it to terminate.

Real-Time CPU Usage Monitoring

One of the most common uses of while true loops is monitoring system resources, such as CPU usage, memory consumption, or disk space. This continuous monitoring helps in detecting issues promptly and taking necessary actions.

#!/bin/bash

threshold=80

while true
do
    usage=$(top -bn1 | grep "Cpu(s)" | sed "s/.*, *\([0-9.]*\)%* id.*/\1/" | awk '{print 100 - $1}')
    if (( $(echo "$usage > $threshold" | bc -l) )); then
        echo "High CPU usage detected: $usage%"
        # Action to take when CPU usage is high
    else
        echo "CPU usage is normal: $usage%"
    fi
    sleep 5
done

The while true loop runs indefinitely, checking CPU usage every 5 seconds. The top command retrieves CPU usage, and awk processes the output to calculate the percentage of CPU used. If CPU usage exceeds the threshold, a message is printed, and further actions can be taken, such as logging the event or sending an alert.

Running a Command Periodically

Another practical application of while true loops is executing a command or script at regular intervals. This can be useful for tasks such as backups, data synchronization, or periodic updates.

#!/bin/bash

backup_source="/path/to/source"
backup_dest="/path/to/destination"
interval=3600 # 1 hour

while true
do
    rsync -av --delete "$backup_source" "$backup_dest"
    echo "Backup completed at $(date)"
    sleep $interval
done

The while true loop runs indefinitely, performing a backup every hour. The rsync command synchronizes the source directory with the destination directory. After completing the backup, the script waits for the specified interval (3600 seconds) before repeating the process.

Conclusion

The power and flexibility of while loops make them indispensable tools in Bash scripting. Whether you are automating routine tasks, monitoring systems, or handling complex data processing, mastering while loops can significantly streamline your workflow and enhance your scripting capabilities.