Bash Scripting – Until Loop

The Bash has three types of looping constructs namely for, while, and until. The Until loop is used to iterate over a block of commands until the required condition is false.

Syntax of `Until` Loop

until [ condition ];
do
 block-of-statements
done

Here, the flow of the above syntax will be –

• Check the condition.
• If the condition is false, then execute the statements and go back to step 1.
• If the condition is true, then the program control moves to the next command in the script.

Example:

#!/bin/bash
echo "until loop"
i=10
until [ $i == 1 ]
do
    echo "$i is not equal to 1";
    i=$((i-1))
done
echo "i value is $i"
echo "loop terminated"

In this example, the script starts with the value of i set to 10. The “until” loop checks the condition [ $i == 1 ] before executing the block of statements inside the loop.

• At the first iteration, i is 10, and the condition [ $i == 1 ] is false, so it enters the loop and executes echo "$i is not equal to 1", which displays “10 is not equal to 1”.
• Then, it decreases the value of i by 1 using i=$((i-1)), so i becomes 9, and it goes back to check the condition again.
• This process repeats until the value of i becomes 1.
• At the point where i is 1, the condition [ $i == 1 ] evaluates to true, and the loop terminates. It skips the block of statements inside the loop and proceeds to the next command in the script.
• Finally, it prints the value of i which is now 1, and then “loop terminate

Output:

until loop

Infinite Loop using Until

In this example the until loop is infinite i.e it runs endlessly. If the condition is set in until the loop is always false then, the loop becomes infinite.

Program:

#!/bin/bash
condition=false
iteration_no=0
until $condition
do
    echo "Iteration no : $iteration_no"
    ((iteration_no++))
    sleep 1
done

The script starts by setting the variable condition to false, which means the condition used in the “until” loop will always be false.

• iteration_no is set to 0, and it will be used to keep track of the number of iterations.
• The “until” loop is defined with the condition $condition. Since $condition is false, the loop will continue executing indefinitely.
• Inside the loop, it first echoes the current iteration number using echo "Iteration no : $iteration_no".
• Then, ((iteration_no++)) increments the value of iteration_no by 1, so the script keeps track of the number of iterations.
• sleep 1 introduces a one-second delay in each iteration. This sleep is not necessary for the infinite loop itself but can be used to control the pace of iterations and prevent the loop from running too quickly.

Since the condition $condition is always false, the loop will never terminate. It will keep printing the iteration number and incrementing it indefinitely, causing an infinite loop.

If you run this script in your terminal, you’ll see it continuously printing the iteration number without stopping until you manually interrupt the script (for example, by pressing Ctrl+C).

Output:

Infinite loop

Until Loop with break and continue

This example uses the break and the continue statements to alter the flow of the loop.

• break: This statement terminates the current loop and passes the program control to the following commands.
• continue: This statement ends the current iteration of the loop, skipping all the remaining commands below it and starting the next iteration.

Program

#!/bin/bash
count=1

# this is an infinite loop
until false
do
    
    if [[ $count -eq 25 ]]
    then
    
        ##   terminates the loop.
        break
    elif [[ $count%5 -eq 0 ]]
    then
    
        ## terminates the current iteration.
        continue
    fi
    echo "$count"
    ((count++))
done

The script starts the infinite “until” loop.

In each iteration, it checks the conditions:

• If count is equal to 25, it breaks out of the loop immediately.
• If count is a multiple of 5, it skips the rest of the commands and starts the next iteration.
• If neither condition is met, it echoes the current value of count.

The loop continues until count becomes 25. At that point, the “break” statement is executed, and the loop terminates.

Output:

Break continue statement

Until Loop with Single condition

This is an example of a until loop that checks for only one condition.

Program

#!/bin/bash
i=0
until [[ $i -eq 5 ]]
do
    echo "$i"
    ((i++))
done

Now, let’s see how the script behaves:

• The script starts the “until” loop with i set to 0.
• In the first iteration, i is 0, and the condition [[ $i -eq 5 ]] is false, so it echoes 0 and increments i to 1.
• In the second iteration, i is 1, and the condition is still false, so it echoes 1 and increments i to 2.
• This process continues until i becomes 5.
• When i is 5, the condition [[ $i -eq 5 ]] becomes true, and the loop terminates.

Output:

Single condition

Until Loop with Multiple conditions

Until loop can be used with multiple conditions. We can use the and : ‘&&’ operator and or: ‘||’ operator to use multiple conditions.

Program

#!/bin/bash
n=1
sum=0
until [[ $n -gt 15  || $sum -gt 20 ]]
do
    sum=$(($sum + $n))
    echo "n = $n & sum of first n = $sum"
    ((n++))
done

Now, let’s see how the script behaves:

• The script starts the “until” loop with n and sum set to 1.
• In the first iteration, it calculates the sum of values from 1 to 1, which is 1, and echoes n = 1 & sum of first n = 1.
• It increments n to 2 and goes to the next iteration.
• This process continues until either n becomes greater than 15 or the sum becomes greater than 20.
• The loop stops when n is 16 because the first part of the condition ($n -gt 15) becomes true, and the loop terminates.

Output:

Multiple loop

Exit status of a command:

We know every command in the shell returns an exit status. The exit status of 0 shows successful execution while a non-zero value shows the failure of execution. The until loop executes till the condition returns to a non-zero exit status.