Until Loop in Bash

Bash scripting provides a set of tools for automating tasks and streamlining workflows, with loops being a key feature to execute specific tasks repetitively in a controlled manner. Among various loop types such as for, while, do-while, and until, the until loop stands out for its concise approach. In this article, I will explore the bash until loop giving you some demonstration of different types of it and a few practical examples of this.

What is Until Loop in Bash?

The until loop in bash is a control statement that possesses a block of code and a condition. It executes the block of code repeatedly as long as the condition remains unsatisfied. Whereas the while loop executes the code as long as the condition remains satisfied.

Syntax of Until Loop in Bash

The common syntax of a until loop in Bash script is:

until [conditions]
do
[commands]
done

5 Cases of Bash Until Loop

The bash until loop can be implemented using single or multiple conditions. The until loop can be finite or infinite. In this section, I will demonstrate some cases of it.

1. Simple Until Loop with Single Condition

The until loop does the task specified inside the do block as long as the condition inside the condition block is true. Each execution of the do block is known as iteration.

Here is a bash script of a simple until loop:

#!/bin/bash

counter=1
until [ $counter -gt 5 ]
do
echo Counter: $counter
((counter++))
done

The above image shows that the bash until loop has printed the numbers from 1 to 5 on the terminal.

2. Array Iteration Using Until Loop

Array Iteration means going through each array element one by one. The iteration task is done using loops. For this, define an array like array_name = {item1, item2, item3, .. item4}. Then, iterate through the array using a loop.

Here is a bash script to iterate through each element of an array using the until loop:

#!/bin/bash

# Define an array
colors=("red" "green" "blue")
# Get the length of the array
array_length=${#colors[@]}
# Initialize an index
index=0
# Use an until loop to iterate through the array
until [ $index -ge $array_length ]; do
echo "Element at index $index: ${colors[$index]}"
((index++))
done

The image shows that the until loop has iterated through each element of the colors array.

3. Until Loop with “break” and “continue” Statement

The break command exits the current loop and passes the control to the following statement, and the continue command skips the current iteration and jumps to the next iteration of the loop. Incorporating these two commands programmers can skip a certain iteration on a until loop, or break the until loop and accomplish the desired task.

Here I have tried a bash script incorporating both the break and the continue commands:

#!/bin/bash

counter=0
until false
do
((counter++))
if [[ $counter -eq 6 ]]
then
  continue
elif [[ $counter -ge 10 ]]
  then
  break
fi
echo "Counter = $counter"
done

The image shows that the until loop has printed 1 to 9 and skipped 6 using the break command and the continue command.

4. Infinite Loop Using Until

The until loop ends when the condition within the until loop is satisfied. If the condition inside the until loop is constant “false”, and nothing makes the condition true, the until loop becomes an infinite loop. In such cases, the loop does a certain task for infinite times.

Here is a sample bash script on an infinite loop using until:

#!/bin/bash

until false
do
echo "Infinite loop. Press CTRL+C to exit!"
sleep 1
done

The above image shows that the until loop has executed an infinite loop which has been interrupted by pressing CTRL+C.

5. Until Loop with Multiple Conditions

The condition block within the until loop can contain multiple conditions. These conditions can exist in the condition block of the until loop with the help of logical and (&&) or logical or(||) operators. In the case of the logical or operator(||), if all of the conditions are false then the loop will execute the commands. And, in the case of the logical and operator(&&) if any of the conditions are false then the loop will execute the commands. This facilitates programmers to set the conditions of the until loop depending on multiple criteria.

Here is a bash script of the until loop containing multiple conditions in the condition statement:

#!/bin/bash

n=1
sum=0
until [[ $n -gt 10  || $sum -gt 18 ]]
do
sum=$(($sum + $n))
echo "n = $n & Summation of first n = $sum"
((n++))
done

The image shows that the until loop has printed the iteration value and summation result depending on the two conditions of the until loop.

5 Practical Examples of Bash Until Loop

The bash until loop can be used to solve various kinds of real-life problems. Here are some of the practical examples of using the until loop in bash:

1. Automating File Existence Checks in Bash

The bash until loop gives programmers a means to check the existence of a file. It is a convenient feature to search for an important file in a server that might contain thousands of files. An easy approach is to keep the file-checking command on the condition block of the until loop. It will iterate the checking process again and again until the file is created by a user in the background and the file-checking command returns a zero status.

Here is the complete bash script to wait for a file to exist:

#!/bin/bash

file_path="/home/susmit/file.txt"
until [ -f $file_path ]
do
echo "Waiting for the file to be detected.."
sleep 1
done
echo "The file exists."

The above image shows that the file.txt has been found.

2. Waiting for Valid Input from User

Input from a user can be used inside the condition of the until loop. To check the validity of the input from the user, compare the input from the user with your desired input. If the input is valid, the until loop will be terminated and the command after the loop will be executed. If the input is not as desired, the until loop will ask for input again and will not be terminated before getting a valid input.

Here’s how you can do it:

#!/bin/bash

input=""
until [ "$input" = "yes" ] || [ "$input" = "no" ]; do
read -p "Please enter 'yes' or 'no': " input
done
echo "Valid input received: $input"

3. Guess the Number Game

The until loop executes the specified command until the condition inside the until loop becomes true. A number-guessing game can easily be implemented by using the until loop where the main task will be to guess a number. The script will repeatedly ask you to guess the number until the guess is correct.

Here is the bash script of a number guessing game:

#!/bin/bash

original_number=29
your_guess=0
trial=1
until [ $your_guess -eq $original_number ]; do
read -p "Guess the secret number: " your_guess
((trial++))
if [ $your_guess -lt $original_number ]; then
echo "Too low!"
elif [ $your_guess -gt $original_number ]; then
echo "Too high!"
fi
done
echo "Congratulations! You guessed the secret number correctly in $trial trial."

4. Creating a Simple Timer

A timer or countdown timer counts a certain time. The until loop incorporated with the sleep command can develop a simple yet effective timer that counts a certain time. The sleep command defines the wait time during each iteration of the until loop and continues until the condition becomes true.

Here is a bash script of a simple timer:

#!/bin/bash

seconds=5
until [ $seconds -eq 0 ]; do
echo "Countdown: $seconds"
sleep 1
((seconds--))
done
echo "Time's up!"

5. Check Network Connectivity

The easy approach to checking network connectivity is to send a single Internet Control Message Protocol (ICMP) echo request to www.google.com and receive the consequent response. The until loop can be used to check the connectivity where the ping command will do the task of request sending and receiving the response as long as an appropriate response is not received.

Here is a bash script for checking network connectivity:

#!/bin/bash

#Until loop that continues until a successful ping to www.google.com
until ping -c1 www.google.com &>/dev/null
do
echo "Waiting for www.google.com - network down?"
sleep 5
done
echo "Ping successful! www.google.com is reachable."

Conclusion

In conclusion, the bash until loop is a useful feature in Bash scripting for scenarios where programmers want to repeatedly execute a block of code until a specific condition becomes true. From basic syntax to practical examples, this article is your one-stop solution to learn the skill of looping in Bash. Do not forget to share your thoughts in the comment box!

People Also Ask

What is the difference between the while loop and the until loop in Linux?

The prime distinction between the while loop and the until loop is the condition block. The while loop runs as long as the condition is true. On the contrary, the until loop runs as long as the condition is false. The until loop terminates as soon as the condition becomes true.

What is the until loop condition in Bash?

The until loop condition in Bash is a control flow statement that permits the execution of code repeatedly until a specific condition is satisfied.

What are the three types of loops in Bash scripting?

There are three types of loops in Bash scripting. These are the for loop, the while loop, and the until loop.

What is the until operator in Bash?

The until operator is a part of the bash until loop. The until loop iterates through a block of commands as long as the condition is false.

How do I restart a loop in Bash?

The continue statement can restart a loop in Bash. It skips the current iteration and jumps into the next iteration without executing the subsequent codes of the loop.

Can you loop through an array in Bash?

Yes, you can loop through an array in Bash. Firstly, you have to define an array. Then access the array element one by one using your preferred types of loop.

Related Articles

• For Loop in Bash
• While Loop in Bash
• Select Loop in Bash [5 Practical Examples]
• How to Use Loop Control in Bash [Break & Continue Statement]

---

<< Go Back to Loops in Bash | Bash Scripting Tutorial