Bash Scripting – While Loop

16 Feb, 2022
A while loop is a statement that iterates over a block of code till the condition specified is evaluated to true. We can use this statement or loop in our program when do not know how many times the condition is going to evaluate to false before evaluating to true.  
The syntax of a while loop in BASH is something like below:
while [ condition ];
do
    # statements
    # commands
done  
If the condition is false then the commands inside the while block are executed and are iterated again after checking the condition. Also if the condition is true the statements inside the while block are skipped and the statements after the while block are executed. 
The example of a while loop is as follows:
#!/usr/bin/bash 

a=7
while [ $a -gt 4 ];
do
    echo $a
    ((a--))
done

echo "Out of the loop"
As we can see that the loop is iterated till the condition is true. As soon as the variable a becomes 4, the condition is evaluated to true and the loop skips the command block and starts executing the commands after the block.
We can read a file with a while loop in BASH.  By parsing certain parameters to the while loop condition, we can iterate over the file line by line or by other groups like characters or words.   
#!/usr/bin/bash 

file=temp.txt

while read -r line;
do
    echo $line
done < "$file"
We use the command read to actually fetch the lines or characters from the file. The read command is passed with -r argument which ignores the escaping of characters if the \  appears and hence it is parsed as its.  We read a line from a file mentioned after the done statement. The read command reads a line from the mentioned file and the while loops end when the last line from the file is read ( no line is left to read). 
This is how we can read the contents of the file using a while loop in BASH. 
To create an infinite loop using a while loop statement. We don’t need to put any condition in the while loop and hence the loop iterates infinitely. The below is the example of an infinite while loop:
#!/usr/bin/bash 

while :
do
  echo "An Infinite loop"
  # We can press Ctrl + C to exit the script
done
Thus the while loop in the script is going to iterate for infinite time. We can manually break the loop or the script by CTRL + C.
We can use a while loop to iterate over a fixed number of times, we can set the condition to be -le or less than equal to a number, and the loop will iterate till the iterator is less than or equal to the number provided in the condition. Also, we need to increment the iterator manually so to keep the loop iterator ticking, or else the loop will go on forever. 
#!/usr/bin/bash 

i=1

# the number 4 can be the limit to 
# iterate the loop
while [ $i -le 4 ];
do
    echo $i
    ((i++))
done
In the above example, we can see that the loop iterates a defined number of times. As we have initialized the counter to 1 and the condition is to iterate the loop till the iterator is less than or equal to the number in this case 4. Thus, we can change the number in the condition as per our requirement.
We can use get ops options to read the input from the command line and if there are multiple arguments, we can check them and parse them one by one using a while loop. getopts is a tool to get user input from the command line, We can have multiple options to parse from the command line, and using getopts and while loops, we can make a professional-looking user input program.
#!/bin/bash

while getopts n:a: OPT
do
        case "${OPT}"
        in
           n) name=${OPTARG};;
           a) age=${OPTARG};;
           *) echo "Invalid option"
              exit 1;;
        esac
done

printf "My name is $name and am $age years old\n"
In this case, we have two options namely, the name and the age, you can have multiple options. We need to specify which option are we gonna use the switch case statements and from the command line using -shorthand option. In this case, we have used -n for name and -a for age. We also have a default or invalid case check to endure we do not parse wrong arguments. We can assign the value of the option using the OPTARG variable which parses the value provided to the option. 
The while loop here is used to iterate till there are no options passed from the command line. We check for the -n and -a option and iterate till the carriage return or enter key is pressed and there are no further options to be parsed. 
We can use C-styled while loop in BASH, the variables need to be evaluated with BASH style but the overall syntax feels like C. We can use the operators like <,>,<= and so on in the condition of the while loop and hence it is called like the C-styled while loop. 
#!/bin/bash

i=0
while((i < 12))
do
   echo $i
   ((i+=2))
done
In this example, we can see that the while loop has a condition with non-bash operators like -le, -ge, etc instead we use the C-styled operators in the condition. The rest of the loop is the basic loop as in BASH, the variable or iterator i is incremented by two as we can see in the last statement of the loop body. Thus the loop iterates over 5 times.
We can perform operations on a file, like reading only a particular part of a file. If we have columns that are formatted in a particular fashion, we can use variables to assign them and print them one row data time. 
#!/bin/bash

while read a b c 
do
    echo $b - $a
done < wh.txt
In this example, we have three rows, we read the contents by assigning them to the variables a,b, and c, it can be anything you like but remember to use them in the loop body. We can select a particular column like b and a and can print or perform any operations on them. This won’t be reflected in the file though as they are just the local script variables.
We can write to a file by user input in a while loop. We can use the while loop to iterate till we manually exit out of the loop using CTRL + D by saving changes to the file or by CTRL + C for avoiding writing to the file. We use the read command to input the text from the command line and parse it to the file. 
#! /bin/bash

file=wh.txt
echo "Enter the content into the file $file"
while read line
do
    echo $line >> $file
done
So from the example above, we were able to enter text into a file using a while loop and read command. To exit out of the loop and save changes to the file, we use the CTRL+ D keys, and to exit out of the loop without saving anything into the file we can use the CTRL + C keys.  Thus we enter the text from the command line to the text file using the read command and a while loop.
Break and continue are essential in a program that deals with loop statements as they control the flow of the loop statements without any explicit conditions. 
We use break statements to exit out of the loop without waiting for the condition of the while loop to evaluate to true. This statement can be used within a loop block. This can be used to exit out of an infinite loop with a programmatic condition inside the loop and thus maintain the control of the loop.
For example, we have a script that counts from 1 and forever. But we can programmatically break out of the loop using a break statement inside the body of the loop with a condition. 
#!/usr/bin/bash 

i=1
while :
do
    echo $i
    if [ $i -eq 20 ];
    then
        echo "This is end of the loop"
        break
    if
    ((i++))
done
From the script and the execution, we can see that we were able to break or exit an infinite loop with a conditional statement and the break statement. Thus the break statement is used to get the control flow of a program/script from inside a while loop to break out of the loop without the loop condition evaluating to true.
We can use the continue statement to do the opposite of the break statement. It will jump to the start of the loop block and iterate again. This can be used for skipping over certain commands for certain conditions and hence allows a change in the flow of the loop. 
For example, If we have a variable initialized to 1 and we want to display only the numbers divisible by five or in a certain pattern following a condition, we can use continue statements to do just that. This allows iterating over the loop in the desired manner.
#!/usr/bin/bash 

i=1
while [ $i -lt 30 ];
do
    ((i++))
    if [[ $(( $i % 5 )) -ne 0 ]];
    then
        continue
    if
    echo $i
done
As we can see the continue statement, jumps to the beginning of the block and starts the execution of the commands by skipping the next commands inside the block.  The while loop iterates for only the value of variable i being less than 30, thus the if condition checks if the variable i is divisible by 5, and if it’s not we iterate over again using continue and increment the value of the variable i. The variable i only gets echoed if it’s divisible by 5, thus the if condition is evaluated to false and we do not encounter a continue statement and carry with the normal flow of the loop. This is done to avoid logging of every number and only print the numbers which do not follow a pattern or condition in the if statement or other conditional statements. 
rkbhola5
Bash-Script
Picked
Linux-Unix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
tar command in Linux with examples
Conditional Statements | Shell Script
Tail command in Linux with examples
scp command in Linux with Examples
Docker - COPY Instruction
UDP Server-Client implementation in C
Cat command in Linux with examples
echo command in Linux with Examples
touch command in Linux with Examples
chown command in Linux with Examples