Mahmoud Abas, Full-Stack Software Engineer & AI

Operating Systems 1 (2026-2027) - Bash Scripting, Part 2: Loops and Functions

In the print dialog, choose "Save as PDF" as the destination.

Operating Systems 1, Lab 12

Bash Scripting: Loops and Functions

Repeat work with while, until and for, then package it in functions that take arguments, return a status and keep their variables to themselves.

Objectives

Repeat commands with while and until, and catch the off by one error
Walk a list with for: typed words, a variable, a range with a step, for (( )), files and "$@"
Steer a loop with break and continue, read a file with while read, build a menu with select
Define and call a function, pass it $1, send back a status with return and a value with $( )
Explain scope: what local protects, and what a function can still change
Run a script from a script and read its exit code with $?

Part 1

while and until

Repeat while a test holds

The while Loop

While the test is true, keep running the body

bash

#!/bin/bash
# Basic while loop
counter=1
while [ $counter -le 10 ]
do
    echo $counter
    ((counter++))
done
echo All done

while_loop.sh

counter=1 sets the start value
Bash runs the test in [ ], exactly as in if
True: run the body between do and done
((counter++)) adds 1, then back to the test
False: continue after done

Worked Example 1: The Off by One Error

Predict the output of while_loop.sh. Then change only its test to [ $counter -lt 10 ] and predict again.

text

$ bash while_loop.sh
1
2
3
4
5
6
7
8
9
10
All done

Worked Example 1: After Changing the Test

text

$ bash while_lt.sh
1
2
3
4
5
6
7
8
9
All done

until: Repeat Until the Test Is True

bash

#!/bin/bash
# Basic until loop
counter=1
until [ $counter -gt 10 ]
do
    echo $counter
    ((counter++))
done
echo All done

until_loop.sh

Same shape as while, with the opposite meaning
The body runs until the test is true, that is, while it is false
Output: 1 to 10, then All done, exactly like while_loop.sh

Worked Example 2: Even and Divisible by 5

From the examples document. Predict what it prints.

bash

#!/bin/bash
echo "Print the numbers which are even and divisible by 5"
counter=1
while [ $counter -le 20 ]
do
    if [[ $counter%2 -eq 0 && $counter%5 -eq 0 ]]
    then
        echo "$counter"
    fi
    ((counter++))
done
echo "Done"

while.sh

text

$ bash while.sh
Print the numbers which are even and divisible by 5
10
20
Done

Worked Example 3: Counting Down with until

Its comment says it prints odd numbers. Predict the first and the last number.

bash

#!/bin/bash
n=20
until [ $n -lt 0 ]
do
    if [[ $n%2 -gt 0 ]]
    then
        echo $n
    fi
    ((n=$n-1))
done

until.sh

text

$ bash until.sh
19
17
15
13
11
9
7
5
3
1

n goes 20, 19, ..., 0; at -1 the test is true and until stops. Only odd values print.

Try It: Watch a Loop Run

Part 2

for Loops

Once for each item in a list

The for Loop

text

for var in list
do
    commands
done

the format

Take the next item of the list
Put it in the variable var
Run the commands between do and done
Back to the top; stop when the list is used up

Worked Example 4: A Week of Plans

From the examples document. Predict the lines for Tuesday and Sunday.

bash

#!/bin/bash
for day in Monday Tuesday Wednesday Thursday Friday Saturday Sunday
do
    if [[ $day == 'Monday' || $day == 'Thursday' ]]
    then
        echo "Meeting on $day at 9:30 am"
    elif [[ $day == 'Tuesday' || $day == 'Wednesday' || $day == 'Friday' ]]
    then
        echo "Training on $day at 11:00 am"
    else
        echo "$day is Holiday"
    fi
done

for.sh

text

$ bash for.sh
Meeting on Monday at 9:30 am
Training on Tuesday at 11:00 am
Training on Wednesday at 11:00 am
Meeting on Thursday at 9:30 am
Training on Friday at 11:00 am
Saturday is Holiday
Sunday is Holiday

Worked Example 5: One Item or Three?

The same list in a variable, used without and with quotes. Predict both outputs.

bash

#!/bin/bash
planets='Mercury Venus Earth'
for planet in $planets
do
    echo $planet
done
echo All done

for_loop.sh

bash

#!/bin/bash
planets='Mercury Venus Earth'
for planet in "$planets"
do
    echo $planet
done
echo All done

for_quoted.sh

Worked Example 5: Answer

text

$ bash for_loop.sh
Mercury
Venus
Earth
All done

no quotes: split at the spaces, three items

text

$ bash for_quoted.sh
Mercury Venus Earth
All done

quotes: the whole string is one item

Worked Example 6: Ranges and Steps

Two dots make a range; two more set the step. Predict what each loop prints.

bash

for value in {1..5}
for value in { 1..5 }
for value in {10..0..2}

three loop headers, each with the body echo $value

Loop list	Really printed, one per line
`{1..5}`	`1` `2` `3` `4` `5`
`{ 1..5 }` (spaces inside)	`{` `1..5` `}`: three words, not a range
`{10..0..2}`	`10` `8` `6` `4` `2` `0`: counts down by `2`

The C Style for Loop

Start, test and change in one line

bash

#!/bin/bash
for ((num = 1; num <= 5; num++))
do
    echo $num
done
echo All done

for_loop_alternate_syntax.sh

num = 1 runs once, before the loop
num <= 5 is the test, checked before every pass
num++ runs at the end of every pass

The C Style for Loop: Running It

text

$ bash for_loop_alternate_syntax.sh
1
2
3
4
5
All done

Looping Over Files

A wildcard turns a folder into a list

bash

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

copy_html.sh

text

$ ls site
about.html  index.html
$ bash copy_html.sh site
$ ls site
about.html  about.php  index.html  index.php

$1/*.html: every .html file in the folder given as $1
basename -s .html site/about.html prints about
$( ) puts that name into the cp command: site/about.php

Looping Over the Arguments

"$@" is the list of all the script's arguments

bash

#!/bin/bash
echo "Argument values are: $1 $2"
for arg in "$@"
do
    key=$(echo $arg | cut -f1 -d=)
    value=$(echo $arg | cut -f2 -d=)
    case $key in
        id) echo "Student ID = $value";;
        mark) echo "Obtained mark = $value";;
        *)
    esac
done

cl2.sh

text

$ bash cl2.sh id=2026101 mark=90
Argument values are: id=2026101 mark=90
Student ID = 2026101
Obtained mark = 90

One pass per argument, for example id=2026101
cut -f1 -d=: the part before =; -f2: the part after it
case runs the line whose pattern matches

Part 3

Controlling Loops

break, continue, while read and select

break: Leave the Loop Now

Predict where the search stops.

bash

#!/bin/bash
for value in {22..30}
do
    if (( value % 7 == 0 ))
    then
        echo "found $value"
        break
    fi
    echo "checked $value"
done
echo All done

break_demo.sh

text

$ bash break_demo.sh
checked 22
checked 23
checked 24
checked 25
checked 26
checked 27
found 28
All done

29 and 30 are never checked

continue: Skip to the Next Pass

secret.txt has had every permission removed (chmod 000). Predict the output.

bash

#!/bin/bash
for value in $1/*
do
    if [ ! -r $value ]
    then
        echo $value not readable 1>&2
        continue
    fi
    cp $value backup/
    echo "backed up $value"
done

copy_check.sh

text

$ ls notes
a.txt  b.txt  secret.txt
$ bash copy_check.sh notes
backed up notes/a.txt
backed up notes/b.txt
notes/secret.txt not readable
$ ls backup
a.txt  b.txt

Reading a File Line by Line

Predict: why does the first method print one line?

bash

echo "Reading file using cat command"
content=`cat hardware.txt`
echo $content
echo "Reading file line by line using loop"
while read line
do
    echo $line
done < hardware.txt

from readfile.sh

text

$ bash readfile.sh
Reading file using cat command
Monitor Keyboard Mouse Scanner Printer
Reading file line by line using loop
Monitor
Keyboard
Mouse
Scanner
Printer

Menus with select

PS3 is the prompt. Predict what the invalid choice 5 prints.

bash

#!/bin/bash
planets='Mars Venus Earth Quit'
PS3='Select planet: '
select planet in $planets
do
    if [ "$planet" == 'Quit' ]
    then
        break
    fi
    echo Hello $planet
done
echo Bye

select_example.sh

Menus with select: Answer

text

$ bash select_example.sh
1) Mars
2) Venus
3) Earth
4) Quit
Select planet: 2
Hello Venus
Select planet: 1
Hello Mars
Select planet: 5
Hello
Select planet: 4
Bye

Part 4

Functions

Write it once, call it by name

Define, Then Call

bash

#!/bin/bash
# Basic function
print_something () {
    echo Hello I am a function
}
print_something
print_something

function_example.sh

text

$ bash function_example.sh
Hello I am a function
Hello I am a function

Two forms: name () { ... } or function name { ... }
The () are decoration only: never put anything inside them
The definition must come before the first call
Call it by its name, like a command

Worked Example 7: Calling Too Early

Predict both lines of output.

bash

#!/bin/bash
# Calling a function before it is defined
print_something
print_something () {
    echo Hello I am a function
}
print_something

call_before.sh

Worked Example 7: Answer

text

$ bash call_before.sh
call_before.sh: line 3: print_something: command not found
Hello I am a function

Passing Arguments

Written after the name; read inside as $1, $2, ...

bash

#!/bin/bash
# Passing arguments to a function
print_something () {
    echo Hello $1
}
print_something Mars
print_something Jupiter

arguments_example.sh

text

$ bash arguments_example.sh
Hello Mars
Hello Jupiter

print_something Mars: $1 is Mars
Every call gets its own $1
Exactly how a script reads its command line arguments

Return Status

Bash functions cannot return a value, but they can set a status. Predict the last line.

bash

#!/bin/bash
# Setting a return status for a function
print_something () {
    echo Hello $1
    return 5
}
print_something Mars
print_something Jupiter
echo The previous function has a return value of $?

return_status_example.sh

text

$ bash return_status_example.sh
Hello Mars
Hello Jupiter
The previous function has a return value of 5

Returning a Value with $( )

The function prints the result; command substitution catches it

bash

#!/bin/bash
# Setting a return value to a function
lines_in_file () {
    cat $1 | wc -l
}
num_lines=$( lines_in_file $1 )
echo The file $1 has $num_lines lines in it.

return_hack.sh

Line 4 prints the line count of the file in $1
$( ) sends that text into num_lines instead of the screen
Called without $( ), it prints 3 on the screen and num_lines stays empty

Returning a Value with $( ): Running It

text

$ cat myfile.txt
Tomato
Lettuce
Capsicum
$ bash return_hack.sh myfile.txt
The file myfile.txt has 3 lines in it.

Worked Example 8: local and global

Predict the three lines.

bash

#!/bin/bash
# Experimenting with variable scope
var_change () {
    local var1='local 1'
    echo Inside function: var1 is $var1 : var2 is $var2
    var1='changed again'
    var2='2 changed again'
}
var1='global 1'
var2='global 2'
echo Before function call: var1 is $var1 : var2 is $var2
var_change
echo After function call: var1 is $var1 : var2 is $var2

local_variables.sh

text

Before function call: var1 is global 1 : var2 is global 2
Inside function: var1 is local 1 : var2 is global 2
After function call: var1 is global 1 : var2 is 2 changed again

$ bash local_variables.sh

Why: One Name, Two Variables

Line	var1	var2
Before the call	global: `global 1`	global: `global 2`
Inside the function	local: `local 1`	global: `global 2`
After the call	global, untouched: `global 1`	global, changed inside: `2 changed again`

Try It: The Call Stack

Three Functions from the Examples Document

A message, a string left in a global, and an area calculated with bc

bash

function print_message()
{
    echo "Bash programming for beginner"
}
function ret_strdata()
{
    return_str="Learn bash programming with functions"
}

func.sh: the definitions

Three Functions: calculate_area

bash

function calculate_area()
{
    local radius=$1
    area=$(echo $radius*$radius*3.14 | bc)
    echo "Area of the circle is $area"
}

func.sh: the definitions (continued)

Three Functions: The Calls

bash

print_message
ret_strdata
echo $return_str
echo "Enter the radius value"
read rad
calculate_area $rad

func.sh: the calls

text

$ bash func.sh
Bash programming for beginner
Learn bash programming with functions
Enter the radius value
4
Area of the circle is 50.24

4 x 4 x 3.14 = 50.24; bc handles the decimals

A Function Named like a Command

bash

#!/bin/bash
# Create a wrapper around the command ls
ls () {
    command ls -lh
}
ls

override.sh

text

$ bash override.sh
total 4.0K
-rwxr-xr-x 1 student student 85 Sep 25 09:00 override.sh

A function wins over a program with the same name
command ls skips the function and runs the real ls
Without command, ls calls itself again and again: nothing prints

Part 5

Scripts Working Together

Exit codes and four ways to call a script

Exit Codes Between Scripts

Predict the answer for 55 and for 110.

bash

#!/bin/bash
echo "Enter a numeric value"
read n
if [[ $n -le 100 ]]
then
    exit 0
else
    exit 1
fi

first.sh

bash

#!/bin/bash
bash "first.sh"
if [ $? -eq 1 ]
then
    echo "The input number is greater than 100"
else
    echo "The input number is less than or equal to 100"
fi

second.sh

Exit Codes Between Scripts: Answer

text

$ bash second.sh
Enter a numeric value
55
The input number is less than or equal to 100

text

$ bash second.sh
Enter a numeric value
110
The input number is greater than 100

source, bash, eval, exec

From callpro.sh in the examples document, really run

Call	What happens
`source add.sh`	runs inside this script: its `result` (`100`) is still set afterwards
`bash subtract.sh 50 20`	a new Bash; its `result` (`30`) vanishes, ours is still `100`
`eval bash multiply.sh $a $b`	builds the command line (`6`, `7`), then runs it: `42`
`exec divide.sh 30`	replaces this script: prints `15`, and no line after it runs

Part 6

Practice

About 30 minutes: answer on paper, then run it in ~/lab12

About 4 minutes

Practice 1: Predict Two Loops

bash

#!/bin/bash
counter=10
until [ $counter -lt 4 ]
do
    echo -n "$counter "
    ((counter-=3))
done
echo
for value in {15..3..4}
do
    echo -n "$value "
done
echo

p1.sh

Practice 1: Answer

text

$ bash p1.sh
10 7 4 
15 11 7 3

About 5 minutes

Practice 2: Even or Odd

Write even_odd.sh: print the numbers 1 to 10, one per line
After each number print is even or is odd
The first two lines: 1 is odd and 2 is even

Practice 2: Answer

bash

#!/bin/bash
for n in {1..10}
do
    if [[ $n%2 -eq 0 ]]
    then
        echo "$n is even"
    else
        echo "$n is odd"
    fi
done

even_odd.sh

text

$ bash even_odd.sh
1 is odd
2 is even
3 is odd
4 is even
5 is odd
6 is even
7 is odd
8 is even
9 is odd
10 is even

About 6 minutes

Practice 3: A Grade Function

Function grade: put $1 in a local mark; print A for at least 85, B for at least 65, else C
Loop over the marks 92 70 40 85
Catch each letter with $( ) in g and print mark 92 gets A

Practice 3: Answer

bash

grade () {
    local mark=$1
    if [ $mark -ge 85 ]
    then
        echo A
    elif [ $mark -ge 65 ]
    then
        echo B
    else
        echo C
    fi
}

grade.sh: the function

bash

for m in 92 70 40 85
do
    g=$( grade $m )
    echo "mark $m gets $g"
done

grade.sh: the loop

Practice 3: Running It

text

$ bash grade.sh
mark 92 gets A
mark 70 gets B
mark 40 gets C
mark 85 gets A

About 4 minutes

Practice 4: Predict the Scope

bash

#!/bin/bash
count=0
add () {
    local step=$1
    count=$(( count + step ))
    step=100
}
step=7
add 5
add 3
echo "count=$count step=$step"

scope.sh

Practice 4: Answer

text

$ bash scope.sh
count=8 step=7

count has no local copy: both calls change the global, 0 + 5 = 5, then 5 + 3 = 8
step is local in add, so step=100 changes only the local copy; the global stays 7

About 6 minutes

Practice 5: A Validity Check

Function valid: return status 0 for a mark from 0 to 100, status 1 otherwise
Loop over 45 120 100 -3 and call valid for each
Test $? after each call: print 45 ok or 120 invalid

Practice 5: Answer

bash

valid () {
    if [[ $1 -ge 0 && $1 -le 100 ]]
    then
        return 0
    else
        return 1
    fi
}

valid.sh: the function

bash

for m in 45 120 100 -3
do
    valid $m
    if [ $? -eq 0 ]
    then
        echo "$m ok"
    else
        echo "$m invalid"
    fi
done

valid.sh: the loop

Practice 5: Running It

text

$ bash valid.sh
45 ok
120 invalid
100 ok
-3 invalid

About 5 minutes

Practice 6: Number the Lines

Write number_lines.sh: read hardware.txt with while read
Print each line after its number: 1: Monitor
Finish with the total: Total: 5 lines

Practice 6: Answer

bash

#!/bin/bash
n=0
while read line
do
    ((n++))
    echo "$n: $line"
done < hardware.txt
echo "Total: $n lines"

number_lines.sh

text

$ bash number_lines.sh
1: Monitor
2: Keyboard
3: Mouse
4: Scanner
5: Printer
Total: 5 lines

Key Takeaways

while runs while its test is true, until until it becomes true; check the first and the last pass
for takes one item per pass: words, a quoted or unquoted variable, a range with a step, files, "$@"
break leaves the loop, continue skips one pass, while read reads a file line by line
A function is defined before it is called and reads its arguments as $1, $2, ...
return sets a status in $?; print a value and catch it with $( )
Make function variables local, or the function changes the globals

Open this lesson

Mahmoud AbasBash Scripting, Part 2: Loops and Functions

#!/bin/bash echo "Print the numbers which are even and divisible by 5" counter=1 while [ $counter -le 20 ] do if [[ $counter%2 -eq 0 && $counter%5 -eq 0 ]] then echo "$counter" fi ((counter++)) done echo "Done"

#!/bin/bash for day in Monday Tuesday Wednesday Thursday Friday Saturday Sunday do if [[ $day == 'Monday' || $day == 'Thursday' ]] then echo "Meeting on $day at 9:30 am" elif [[ $day == 'Tuesday' || $day == 'Wednesday' || $day == 'Friday' ]] then echo "Training on $day at 11:00 am" else echo "$day is Holiday" fi done

$ bash for.sh Meeting on Monday at 9:30 am Training on Tuesday at 11:00 am Training on Wednesday at 11:00 am Meeting on Thursday at 9:30 am Training on Friday at 11:00 am Saturday is Holiday Sunday is Holiday

Loop list

Really printed, one per line

{1..5}

1 2 3 4 5

{ 1..5 } (spaces inside)

{ 1..5 }: three words, not a range

{10..0..2}

10 8 6 4 2 0: counts down by 2

#!/bin/bash echo "Argument values are: $1 $2" for arg in "$@" do key=$(echo $arg | cut -f1 -d=) value=$(echo $arg | cut -f2 -d=) case $key in id) echo "Student ID = $value";; mark) echo "Obtained mark = $value";; *) esac done

#!/bin/bash # Setting a return status for a function print_something () { echo Hello $1 return 5 } print_something Mars print_something Jupiter echo The previous function has a return value of $?

#!/bin/bash # Experimenting with variable scope var_change () { local var1='local 1' echo Inside function: var1 is $var1 : var2 is $var2 var1='changed again' var2='2 changed again' } var1='global 1' var2='global 2' echo Before function call: var1 is $var1 : var2 is $var2 var_change echo After function call: var1 is $var1 : var2 is $var2

Line

var1

var2

Before the call

global: global 1

global: global 2

Inside the function

local: local 1

global: global 2

After the call

global, untouched: global 1

global, changed inside: 2 changed again

Call

What happens

source add.sh

runs inside this script: its result (100) is still set afterwards

bash subtract.sh 50 20

a new Bash; its result (30) vanishes, ours is still 100

eval bash multiply.sh $a $b

builds the command line (6, 7), then runs it: 42

exec divide.sh 30

replaces this script: prints 15, and no line after it runs