Linux: Bash Loops!

Ryan's Tutorials ^ | Current | Ryan Chadwick

[ShadowAce]

Introduction

Bash loops are very useful. In this section of our Bash Scripting Tutorial we'll look at the different loop formats available to us as well as discuss when and why you may want to use each of them.

Loops allow us to take a series of commands and keep re-running them until a particular situation is reached. They are useful for automating repetitive tasks.

There are 3 basic loop structures in Bash scripting which we'll look at below. There are also a few statements which we can use to control the loops operation.

While Loops

One of the easiest loops to work with is while loops. They say, while an expression is true, keep executing these lines of code. They have the following format:

while [ <some test> ]
do
<commands>
done

You'll notice that similar to if statements the test is placed between square brackets [ ].

In the example below we will print the numbers 1 through to 10:

while_loop.sh

1. #!/bin/bash
2. # Basic while loop
4. counter=1
5. while [ $counter -le 10 ]
6. do
7. echo $counter
8. ((counter++))
9. done
11. echo All done

Let's break it down:

• Line 4 - We'll initialise the variable counter with it's starting value.
• Line 5 - While the test is true (counter is less than or equal to 10) let's do the following commands.
• Line 7 - We can place any commands here we like. Here echo is being used as it's an easy way to illustrate what is going on.
• Line 8 - Using the double brackets we can increase the value of counter by 1.
• Line 9 - We're at the bottom of the loop so go back to line 5 and perform the test again. If the test is true then execute the commands. If the test is false then continue executing any commands following done.

1. user@bash$./while_loop.sh
2. 1
3. 2
4. 3
5. 4
6. 5
7. 6
8. 7
9. 8
10. 9
11. 10
12. All done
13. user@bash$

A common mistake is what's called an off by one error. In the example above we could have put -lt as opposed to -le (less than as opposed to less than or equal). Had we done this it would have printed up until 9. These mistakes are easy to make but also easy to fix once you've identified it so don't worry too much if you make this error.

Until Loops

The until loop is fairly similar to the while loop. The difference is that it will execute the commands within it until the test becomes true.

until [ <some test> ]
do
<commands>
done

until_loop.sh

1. #!/bin/bash
2. # Basic until loop
4. counter=1
5. until [ $counter -gt 10 ]
6. do
7. echo $counter
8. ((counter++))
9. done
11. echo All done

As you can see in the example above, the syntax is almost exactly the same as the while loop (just replace while with until). We can also create a script that does exactly the same as the while example above just by changing the test accordingly.

So you may be asking, 'Why bother having the two different kinds of loops?'. We don't necessarily. The while loop would be able to handle every scenario. Sometimes, however, it just makes it a little easier to read if we phrase it with until rather than while. Think about the following statement:

Leave the towel on the line until it's dry.

We could have said:

Leave the towel on the line while it is not dry.

Or:

Leave the towel on the line while it is wet.

But they just don't seem as elegant and easy to understand. So by having both while and until we can pick whichever one makes the most sense to us and as a result, end up with code that is easier for us to understand when we read it.

We should always strive for clean, obvious and elegant code when writing our Bash scripts.

For Loops

The for loop is a little bit different to the previous two loops. What it does is say for each of the items in a given list, perform the given set of commands. It has the following syntax.

for var in <list>
do
<commands>
done

The for loop will take each item in the list (in order, one after the other), assign that item as the value of the variable var, execute the commands between do and done then go back to the top, grab the next item in the list and repeat over.

The list is defined as a series of strings, separated by spaces.

Here is a simple example to illustrate:

for_loop.sh

1. #!/bin/bash
2. # Basic for loop
4. names='Stan Kyle Cartman'
6. for name in $names
7. do
8. echo $name
9. done
11. echo All done

Let's break it down:

• Line 4 - Create a simple list which is a series of names.
• Line 6 - For each of the items in the list $names assign the item to the variable $name and do the following commands.
• Line 8 - echo the name to the screen just to show that the mechanism works. We can have as many commands here as we like.
• Line 11 - echo another command to show that the bash script continued execution as normal after all the items in the list were processed.

1. ./for_loop.sh
2. Stan
3. Kyle
4. Cartman
5. All done

Ranges

We can also process a series of numbers

for_loop_series.sh

1. #!/bin/bash
2. # Basic range in for loop
4. for value in {1..5}
5. do
6. echo $value
7. done
9. echo All done

• Line 4 - It's important when specifying a range like this that there are no spaces present between the curly brackets { }. If there are then it will not be seen as a range but as a list of items.

1. ./for_loop_series.sh
2. 1
3. 2
4. 3
5. 4
6. 5
7. All done

When specifying a range you may specify any number you like for both the starting value and ending value. The first value may also be larger than the second in which case it will count down.

It is also possible to specify a value to increase or decrease by each time. You do this by adding another two dots ( .. ) and the value to step by.

for_loop_stepping.sh

1. #!/bin/bash
2. # Basic range with steps for loop
4. for value in {10..0..2}
5. do
6. echo $value
7. done
9. echo All done

1. ./for_loop.sh
2. 10
3. 8
4. 6
5. 4
6. 2
7. 0
8. All done

One of the more useful applications of for loops is in the processing of a set of files. To do this we may use wildcards. Let's say we want to convert a series of .html files over to .php files.

convert_html_to_php.sh

1. #!/bin/bash
2. # Make a php copy of any html files
4. for value in $1/*.html
5. do
6. cp $value $1/$( basename -s .html $value ).php
7. done

Controlling Loops: Break and Continue

Most of the time your loops are going to through in a smooth and ordely manner. Sometimes however we may need to intervene and alter their running slightly. There are two statements we may issue to do this.

Break

The break statement tells Bash to leave the loop straight away. It may be that there is a normal situation that should cause the loop to end but there are also exceptional situations in which it should end as well. For instance, maybe we are copying files but if the free disk space get's below a certain level we should stop copying.

copy_files.sh

1. #!/bin/bash
2. # Make a backup set of files
4. for value in $1/*
5. do
6. used=$( df $1 | tail -1 | awk '{ print $5 }' | sed 's/%//' )
7. if [ $used -gt 90 ]
8. then
9. echo Low disk space 1>&2
10. break
11. fi
12. cp $value $1/backup/
13. done

Continue

The continue statement tells Bash to stop running through this iteration of the loop and begin the next iteration. Sometimes there are circumstances that stop us from going any further. For instance, maybe we are using the loop to process a series of files but if we happen upon a file which we don't have the read permission for we should not try to process it.

copy_check.sh

1. #!/bin/bash
2. # Make a backup set of files
4. for value in $1/*
5. do
6. if [ ! -r $value ]
7. then
8. echo $value not readable 1>&2
9. continue
10. fi
11. cp $value $1/backup/
12. done

Select

The select mechanism allows you to create a simple menu system. It has the following format:

select var in <list>
do
<commands>
done

When invoked it will take all the items in list (similar to other loops this is a space separated set of items) and present them on the screen with a number before each item. A prompt will be printed after this allowing the user to select a number. When they select a number and hit enter the corresponding item will be assigned to the variable var and the commands between do and done are run. Once finished a prompt will be displayed again so the user may select another option.

A few points to note:

• No error checking is done. If the user enters something other than a number or a number not corresponding to an item then var becomes null (empty)
• If the user hits enter without entering any data then the list of options will be displayed again.
• The loop will end when an EOF signal is entered or the break statement is issued.
• You may change the system variable PS3 to change the prompt that is displayed.

Here is a simple example to illustrate it's usage:

select_example.sh

1. #!/bin/bash
2. # A simple menu system
4. names='Kyle Cartman Stan Quit'
6. PS3='Select character: '
8. select name in $names
9. do
10. if [ $name == 'Quit' ]
11. then
12. break
13. fi
14. echo Hello $name
15. done
17. echo Bye

Let's break it down:

• Line 4 - Set up a variable with the list of characters and a last option which we may select to quit. Note that the items are separated by a space.
• Line 6 - Change the value of the system variable PS3 so that the prompt is set to something a little more descriptive. (By default it is #?)
• Lines 10 - 13 - If the last option, 'Quit', is selected then break out of the select loop.
• Line 14 - Print out a message just to demonstrate the mechanism has worked. You may have as many commands here as you like.
• Line 17 - Print a message just to show that the script has continued as normal after the select loop.

And now let's run the Bash script:

1. ./select_example.sh
2. 1) Kyle     3) Stan
3. 2) Cartman  4) Quit
4. Select character: 2
5. Hello Cartman
6. Select Character: 1
7. Hello Kyle
8. Select character: 4
9. Bye

Summary

while do done

Perform a set of commands while a test is true.

until do done

Perform a set of commands until a test is true.

for do done

Perform a set of commands for each item in a list.

break

Exit the currently running loop.

continue

Stop this iteration of the loop and begin the next iteration.

select do done

Display a simple menu system for selecting items from a list.

Clarity

There are several Bash loop mechanisms. Pick the one which makes your code the easiest to follow.

Planning

Now that your scripts are getting a little more complex you will probably want to spend a little bit of time thinking about how you structure them before diving in.

Activities

Now we have quite a collection of tools under our belt, we can tackle some more interesting problems.

• Create a simple script which will print the numbers 1 - 10 (each on a separate line) and whether they are even or odd.
• Write a Bash script which will take a single command line argument (a directory) and will print each entry in that directory. If the entry is a file it will print it's size. If the entry is a directory it will print how many items are in that directory.
• Create a command line version of the game Mastermind. Instead of coloured marbles you could use letters or numbers or be creative and find another way.
• Create a command line version of the game Tic Tac Toe. Make it so you can play against the computer.

[ShadowAce]

[taxcontrol]

Loops are bad
Loops are a pain
Loops make you do things
again and again

... sorry wrong type of bash

[Paal Gulli]

An imminently practical function. One habitual task I use it for is to mute system sound on my PC for a prescribed period of time. Very handy when listening to streaming talk radio because they all seem to only be able to sell ads for men’s virility pills and ambulance-chasing lawyers, which I choose not to listen to.

At invocation, the script mutes the master system sound volume, then asks me how long I want to mute it for. Then it uses a while/if loop of the “sleep” function to count down that many seconds before un-muting.

I wrote similar batch file for Windows using if/then looping. It’s such a relief not to have to listen to that moronic woman teach me how to spell the name of her dog food.

[zeugma]

Loops are awesome and powerful. One really useful thing that you can do in a loop is to test for the existence (or absense) of a file. If the file exists, you can do one thing, if the file doesn't you can do another.

In the following the script checks for the file /tmp/i_exist. If it is there, it sleeps a bit and checks again. Once the file is deleted, it exits. You can use this as a poor man's job control. Let's say you have a job that kicks off every day and does some work. Let's also say that you have a separate job that needs to run, but it is dependent upon the first job finishing successfully before it can run. You can have the first job create a check file, and delete it when it finishes, which will allow the 2nd to execute.

$ cat loopers
#!/bin/bash

while [ -f /tmp/i_exist ]
do
echo "It exists"
sleep 5
done
echo "It no longer exists. Exiting"
exit 0

$ ./loopers 
It exists
It exists
It exists
It exists
It no longer exists. Exiting
$

Another use for something like this is to test to see if a job is already running. You could have the script create a run file. If the job is running it exists. If you start the same job a second time, it could see that the file already exists, and refuse to run. There are other possible ways to do this as well, but this is quick and dirty, and generally works, as long as the job completes successfully and cleans up after itself. If the script is killed while executing, it might not do so, so subsequent executions will see the file and thus refuse to run.

$ cat loopers
#!/bin/bash

if [ -f /tmp/i_exist ]
do
echo "Check file exists! Check to see if another copy of this program is running."
exit 1
done
echo "Now I can create the file"
touch /tmp/i_exist
echo "Real work would be done here, since the file didn't exist."
echo "Now I clean up after myself..."
rm /tmp/i_exist
exit 0

Note that above I used "if" instead of 'while'. Either would work in this instance.

[zeugma]

Syntax error. In the second script the “do” should be “then”. That’s what I get for writing on the fly without testing.