Shell Scripting Structured Commands

Shell Scripting – Using Structured
Commands
Objectives:
Write shell scripts that:

• Alter the command flow
• Use of-then logic
• Nesed if-thens
• Test conditions
• Loops through commands

Concepts
Many programs require some sort of logic flow control between the commands in the script. This means
that the shell executes certain commands given one set of circumstances but it has the ability to execute
other commands given a different set of circumstances. There is a whole class of commands that allows
the script to skip over or loop through commands based on conditions of variable values or the result of
other commands. These commands are generally referred to as structured commands.

The structured commands allow you to alter the flow of operation of the program, executing some
commands under some conditions, while skipping others under other conditions. There are quite a few
structured commands available in the bash shell, so for the rest of the activity, we will look at them
individually.

Working with the if-then Statement
The most basic type of structured command is the if-then statement . The if-then statement has the
following format:

if command
then
commands
fi

The bash shell if statement runs the command defined on the if line. If the exit status of the command is
zero (command completed successfully), the command listed under the then section are executed. If
the exit status of the command is anything else, the then commands aren’t executed and the bash shell
moves on to the next in the script.

test8.sh
#!/bin/bash
#testing the if statement
if date
then
echo “It worked!”
fi

You are not limited to just one command in the then section. You can list commands just as in the rest of
the shell script. The bash shell treats the commands as a block, executing all of them if the command in
the if statement lines return a zero exit status or skipping all of them if the command returns a non-zero
exit status.

You might see an alternative form of the if-then statement used in some scripts:

if command; then
commands
fi
By putting a semicolon at the end of the command to evaluated, you can include the then statement on
the same line, which looks more like how if-then statements are handled in some other programming
languages.

The if-then-else Statement
In the if-then statements, you only have one option of whether or not a command is successful. If the
command returns a non-zero exit status code, the bash shell just moves on to the next command in the
script. In this situation, it would be nice to be able to execute an alternate set of commands. That’s
exactly what the if-then-else statement if for.

The if-then-else statement provides another group of command in the statement:

if command
then
commands
else
commands
fi

If the command in the if statement line returns with an exit status code of zero, the commands listed in
the then section are executed, just as in a normal if-then statement. If the command are in the if
statement line returns a non-zero exit status code, the bash shell executes the commands in the else
section.

test9.sh
#!/bin/bash
#testing the else section
testuser=”badtest”
if grep $testuser /etc/passwd
then
echo “The files for user $testuser are:”
ls –a /home/$testuser/.b*
else
echo “The user name $testuser doesn’t exists on this system”
fi

Nesting ifs
Instead of having to write separate if-then statements, you can use an alternative version of the else
section called elif.

The elif continues an else section with another if-then statement:

if command1
then
command set 1
elif command2
then
command set 2

elif command3
then
command set 3
elif command4
then
command set 4
fi

The elif statement line provides another command to evaluate, similarly to the original if statement
line. If the exit status code from the elif command is zero, bash executes the commands in the second
then statement section.
Each block of commands is executed depending on which command returns the zero exit status code.
Remember, the bash shell will execute the if statements in order and only the first one that returns a
zero exit status will result in the then section being executed.

The test Command
You might be wondering if the bash if-then statement has the ability to evaluate any condition other
than the exit status code.

The answer is no, it can’t. However, there’s a neat utility available in the bash shell that helps us
evaluate other things, using the if-then statement.

The test command provides a way to test different conditions in an if-then statement. If the
condition listed in the test command evaluates to true, the test command exits with a zero exit status
code, making if-then statement behave in much the same way that if-then statements work in other
programming languages. If the condition is false, the test command exits with a one, which causes the
if-then statement to fail.
The format of the test command is pretty simple:

test condition

The condition is a series of parameters and values that the test command evaluates. When used in an
if-then statement, the test command looks like this:

if test condition
then
commands
fi

The bash shell provides an alternative way of declaring the test command in an if-then statement

if [ condition ]
then
commands
fi

The square brackets define the condition that’s used in the test command. Be careful; you
must have a space after the first bracket and a space before the last bracket or you’ll get an
error message.

There are three classes of conditions that the test command can evaluate:

• Numeric comparisons
• String comparisons
• File comparisons

Numeric Comparisons
The most common method for using the test command is to perform a comparison of two numeric
values.

The numeric test conditions can be used to evaluate both numbers and variables.

test Numeric Comparisons
Comparison Description
N1 -eq N2 Check if N1 is equal to N2
N1 -ge N2 Check if N1 is greater than or equal to N2
N1 -gt N2 Check if N1 is greater than N2
N1 -le N2 Check if N1 is less than or equal to N2
N1 -lt N2 Check if N1 is less than N2
N1 -ne N2 Check if N1 is not equal to N2

test10.sh
#!/bin/bash
#using numeric test comparisons
val1=10
val2=11
if [ $val1 –gt 5 ]
then
echo “The test value $val1 is greater than 5”
fi
if [ $val1 –eq $val2 ]
then
echo “ The values are equal “
else
echo “The values are different”
fi

String Comparisons
The test command also allows you to perform comparisons on string values. Performing comparisons
on strings can get tricky. The table below shows the comparison functions you can use to evaluate two
strings

Comparison
Str1 = Str2 Check if Str1 is the same as string Str2
Str1 != Str2 Check if Str1 is not the same as string Str2
Str1 < Str2 Check if Str1 is less than Str2
Str1 > Str2 Check if Str1 is greater than Str2
-n Str1 Check if Str1 has a length greater then zero
-z Str1 Check if Str1 has a length of zero

String equality
The equal and not equal conditions are fairly self-explanatory with strings.

test11.sh
#!/bin/bash
#testing string equality
testuser=rich
if [ $USER = $testuser ]
then
echo “Welcome $testuser”
fi

The test comparisons take all punctuation and capitalization into account when comparing strings for
equality.

String order
Trying to determine if one string is less than or greater than another is where things start getting tricky.
There are problems that often plague shell programmers when trying to use the greater-than or less
than features of the test command.

• The greater-than and less-than symbols must be escaped or the shell will use them as
redirection symbols with the string values as filenames
• The greater-than and less-than order is not the same as that used with the sort command.

test12.sh
#!/bin/bash
#testing string sort order
val1=”Testing”
val2=”testing”
if [ $val1 > $val2 ]
then
echo “ $val1 is greater than $val2”
else
echo “$val1 is less than $val2”
fi

Notice that test command uses the standard mathematical comparison symbols for string
comparison and text codes for numerical comparisons. This is a subtle feature that many
programmers manage to get reversed. If you use the mathematical comparison symbols for numeric
values, the shell interprets them as string values and may not produce the correct results.

String size
The –n and –z comparisons are handy when trying to evaluate if a variable contains data or not.

test13.sh
#!/bin/bash
#testing string length
val1=”testing”
val2=’’
if [ -n $val1 ]
then
echo “The string ‘$val1’ is not empty”
else
echo “The string ‘$val1’ is empty”
fi
if [ -z $val2 ]
then
echo “The string ‘$val2’ is empty”
else
echo “The string ‘$val2’ is not empty”
fi

Empty and uninitialized variables can have catastrophic effects on your shell script tests. If
you’re not sure of the contents of a variable, it’s always best to test if the variable contains a
value using –n or –z before using it in a numeric or string comparison.

File Comparisons
The test command allows you to rest the status of files and directories on the Linux filesystem . The
table below shows the list of these comparisons.

Comparison Description
-d file Check if file exits and is a directory
-e file Checks if file exists
-f file Checks if file exits and is a file
-r file Checks if file exists and is readable
-s file Checks if file exists and is not empty
-w file Checks if file exists and is writable
-x file Checks if file exists and is executable
-O file Checks if file exists and is owned by the current user
-G file Checks if file exits and the default group is the same as the current
file1 – nt file2 Checks if file1 is newer than file2
file1 -ot file2 Checks if file1 is older than file2

test14.sh
#!/bin/bash
#look before you leap
if [ -d $HOME ]
then
echo “Your HOME directory exists”
cd $HOME
ls –a
else
echo “There’s a problem with your HOME directory”
fi

Compound Condition Testing
The if-then statement allows you to use Boolean logic to combine tests. There are two Boolean
operators you can use:

• [ condition1 ] && [ condition2 ]
• [ condition1 ] | | [ condition2 ]

The first Boolean operation uses the AND Boolean operator to combine two conditions. Both conditions
must be met for the then section to execute.

The second Boolean operation uses the OR Boolean operator to combine two conditions. If either
condition evaluates to a true condition, the then section is executed.

test15.sh
#!/bin/bash
#testing compound comparisons
if [ -d $HOME ] && [ -w $HOME/testing ]
then
echo “The file exists and you can write to it”
else
echo “I can’t write to the file. “
fi

Advanced if-then Features
There are two relatively recent additions to the bash shell that provide advanced features that you can
use in if-then statements.

• Double parentheses for mathematical expressions

• Double square brackets for advanced string handling functions

Using double parentheses
The double parentheses command allows you to incorporate advanced mathematical formulas in your
comparisons. The double parentheses command provides more mathematical symbols that
programmers from other languages are used to using. The format of the double parentheses command
is:

( ( expression ) )
The expression term can be any mathematical assignment or comparison expression. Besides the
standard mathematical operators that the test command uses, the table below shows the list of
additional operators available for use in the double parentheses command.

The Double Parentheses Command Symbols

Symbol Description
val++ Post-increment
val- - Post-decrement
++val Pre-increment
--val Pre-decrement
! Logical negation
~ Bitwise negation
** Exponentiation
<< Left bitwise shift
>> Right bitwise shift
& Bitwise Boolean AND
| Bitwise Boolean OR
&& Logical AND
|| Logical OR

test16.sh
#!/bin/bash
#using double parenthesis
val1=10
if ( ( $val1 ** 2 > 90 ) )
then
( ( val2=$val1 ** 2 ) )
Echo “The square of $val1 is $val2”
fi

Using double brackets
The double bracket command provides advanced features for string comparisons. The double bracket
command format is:

[ [ expression ] ]
The double bracketed expression use the standard string comparison used in the test command.
However, it provides an additional feature that test command doesn’t; pattern matching.

In pattern matching, you can define a regular expression that’s matched against the string value:

test17.sh
#!/bin/bash
#using pattern matching
if [ [ $USER == r* ] ]
then
echo “Hello $USER”
else
echo “Sorry. I don’t know you”
fi

The double bracket command matches the $USER environment variable to see if it starts with letter r.

The case Command
Bash provides a case statement that lets you compare a string with several possible values and execute
a block of code when it finds a match. Here's an example of the case command:

case varname in
value1)
statements
;;
value2)
statements
;;
*)
statements
;;
esac

The case command compares the variable specified against different patterns. If the variable matches
the pattern, the shell executes the commands specified for the pattern. The asterisk symbol is the
catch-all for values that don’t match any of the listed patterns. You must signal the end of the construct
with the esac command.

test18.sh
#!/bin/bash
#looking for a possible value using the case command
case $USER in
diplab2)
echo “Welcome $USER”
echo “Please enjoy your visit”
;;
user)
echo “Special Live User account”
;;
root)
echo “Do not forget to login when you are done”
;;
*)
echo “Sorry you are not allowed here!”
;;
esac

The for Command
Iterating through a series of commands is a common programming practice. Often you need to
repeat a set of commands until a specific condition has been met, such as processing all of the
files in the directory, all of the users in a system or all of the lines in a text file.

The bash shell provides the for command to allow you to create a loop that iterates through a
series of values. Each iteration performs a defined set of commands using one of the values in
the series. The basic format of the bash shell for command is:

for var in list
do
commands
done

You supply the series of values in the iterations in the list parameter.

In each iteration, the variable var contains the current value in the list. The commands entered
between the do and done statements can be one or more standard bash shell commands.
Within the commands the $var variable contains the current list item value for the iteration.

Reading values in a list

test19.sh
#!/bin/bash
#basic for command
for test in Alabama Alaska Arizona Arkansas California Colorado
do
echo “The next state is $test.”
done

The $test variable can be used just like any other script variable within the for command statements.
After the last iteration, the $test variable remains valid throughout the remainder of the shell script. It
retains the last iteration value.

Reading a list from a variable

test20.sh
#!/bin/bash
#using a variable to hold the list
list=”Alabama Alaska Arizona Arkansas Colorado”
list=$list” Connecticut”
for state in $list
do
echo “Have you ever visited $state?”
done

Notice that the code also uses another assignment statement to add (or concatenate) an item to the
existing list contained in the $list variable. This is a common method for adding text to the end of an
existing text string stored in a variable.

Reading values from a command
test21.sh
#!/bin/bash
file=”states”
for state in `cat $file`
do
echo “Visit beautiful $state”
done

Changing the field separator
The IFS (internal field separator) environment variable define a list of characters the bash shell
uses as field separator. By default, the bash shell considers the following characters as field separators:

• Space
• Tab
• Newline

If the bash shell sees any of these characters in the data, it’ll assume you’re starting a new data field in
the list. When working with data that contain spaces(such as filenames), this can be annoying.

To solve problems arising from such, you can temporarily change the IFS environment variable values in
your shell script to restrict the characters the bash shell recognizes as field separators. If you want to
change the IFS value to only recognize the newline character, you need to do this:

IFS=$’n’

Adding this statement to your script tells the bash shell to ignore spaces and tabs in data values.

When working on long scripts, it’s possible to change the IFS value in one place, then forget about it and
assume the default value elsewhere in the script. A safe practice to get into is to save the original IFS
value before changing it, then restore it when you’re done.

This technique can be coded like this:

IFS.OLD=$IFS
IFS=$’n’

Reading a directory
You can use the for command to automatically iterate through a directory if files. To do this, you must
use a wildcard character in the file or pathname. This forces the shell to use file globbing. File globbing is
the process of producing file or path names that match a specified wildcard character.

test22.sh
#!/bin/bash
#iterate through all the files in a directory
for file in /home/diplab2/*
do
if [ -d “$file” ]
then
echo “$file is a directory”
elif [ -f “$file” ]
then
echo “$file is a file”
fi
done

The while Command
The while command allows you to define a command to test, then loop through a set of commands for
a as long as the defined test command returns a zero exit status. It test the test command at the start of
each iteration. When the test command returns a non-zero exit status, the while command stops
executing the set of commands

The format of the while command is:

while test command
do
other commands
done

test23.sh
#!/bin/bash
#while command test
var1=10
while [ $var1 –gt 0 ]
do
echo “$var1”
var1=$[ $var1 - 1 ]
done

The until Command
The until command requires that you specify a test command that normally produces a non-zero exit
status. As long as the exit status of the test command is non-zero, the bash shell executes the
commands listed in the loop. Once the test command returns a zero exit status, the loop stops.

The format of the until command is:

until test commands
do
other commands
done

test24.sh
#!/bin/bash
#using the until command
var1=100
until [ $var1 -eq 0 ]
do
echo “$var1”
var1=$[ $var1 - 25 ]
done

The C-Style for Command
The C language for command has a specific method for specifying a variable, a condition that must
remain true for the iteration to continue and a method for altering the variable for each iteration. When
the specified condition becomes false, the for loop stops. The condition equation is defined using
standard mathematical symbols .

The bash shell supports a version of the for loop that looks similar to the C-style for loop. Here is the
basic format of the C-style bash for loop:

for ( ( variable assignment ; condition ; iteration process ) )
Here’s what a C-style for command looks like:

for ( ( a = 1; a < 10; a++ ) )
Notice that there are a couple of things that don’t follow the standard bash shell for method

• The assignment of the variable value can contain spaces
• The variable in the condition isn’t preceded with a dollar sign

• The equation for the iteration process doesn’t use the expr command format

test25.sh
#!/bin/bash
for ( ( i = 1; I <= 10; i++ ) )
do
echo “The next number is $i”
done

Controlling the Loop
You might be tempted to think that once you start a loop, you’re stuck until the loop finishes all of its
iterations. This is not true. There are a couple of commands that help us control what happens inside a
loop:

• The break command
• The continue command

The break Command
The break command is a simple way to escape out of a loop in progress. You can use the break
command to exit out of any type of loop, including while and until loops.

test26.sh
#!/bin/bash
#breaking out of a for loop
for var1 in 1 2 3 4 5 6 7 8 9 10
do
if [ $var1 -eq 5 ]
then
break
fi
echo “Iteration number: $var1”
done
echo “The for loop is completed”

The continue Command
The continue command is a way to prematurely stop processing commands inside if a loop but not
terminate the loop completely. This allows you to set conditions within a loop where the shell won’t
execute commands

test27.sh
#!/bin/bash
#using the continue command
for ( ( var1 = 1; var1 < 15; var1++ ) )
do
if [ $var1 -gt 5 ] && [ $var1 -lt 10 ]
then
continue
fi
echo “Iteration number: $var1”
done

Processing the Output of a Loop
You can either pipe or redirect the output of a loop within your shell script. You do this by adding
the processing command to the end of the done command.

test28.sh
#!/bin/bash
#redirecting the for output to a file
for ( ( a = 1; a < 10; a++; ) )
do
echo “The number is $a”
done > test23.txt

Summary
Structured commands allow you to alter the normal flow of execution on the shell script. The most basic
structured command is the if-then command. This statement allows you to evaluate a command and
perform other commands based on the outcome of the command you evaluated.

You can expand the if-then statement to include a set of commands the bash shell executes if the
specified command fails as well. The if-then-else statement allows you to execute commands only if
the command being evaluated returns a non-zero exit status code.

You can link if-then-else statement together, using the elif statement. The elif is equivalent to
using an else if statement, providing for additional checking if the original command that was
evaluated failed.

In most scripts, instead of evaluating a command, you’ll want to evaluate a condition such as a numeric
value, the contents of a string, or the status of a file or directory. The test command provides an easy
way for you to evaluate all of these conditions. If the condition evaluates to a true condition, the test
command produces a zero exit status code for the if-then statement. If the condition evaluates to a
false condition, the test command produces a non-zero exit status code for the if-then statement.

The square brackets are a special bash command that is a synonym for the test command. You can
enclose a test condition in square brackets in the if-then statement to test for numeric, string,
and file conditions.

The double parentheses command allows you to perform advanced mathematical evaluations
using additional operators and the double square brackets command allows you to perform
advanced string pattern-matching evaluations

The case command is a shorthand way of performing multiple if-then-else commands, checking the
value of a single variable against a list of values.

Looping is an integral part of programming. The bash shell provides three different looping commands
that we can use in our scripts. The for command allows us to iterate through a list of values, either
supplied within the command line, contained in a variable or obtained by using file globbing to
extract file and directory names from a wildcard character.

The while command provides a method to loop based on the condition of a command, using either
ordinary commands or the test command, which allows us to test conditions of variables. As long as
the command (or condition) produces a zero exit status code, the while loop will continue to iterate
through the specified set of commands.

The until command also provides a method to iterate through commands but it bases its iteration on a
command (or condition) producing a non-zero exit status code. This feature allows us to get a condition
that must be met before the iteration stops.

You can combine loops in the shell scripts, producing multiple layers of loops. The bash shell provides
the continue and break commands, which allow us to alter the flow of the normal loop process on
different values within the loop.

The bash shell also allows us to use standard command redirection and piping to alter the output
of a loop. You can use redirection to redirect the output of a loop to a file or piping to redirect the
output of a loop to another command. This provides a wealth of features with which you can control
your shell script execution.

Activity Exercises:

Supply what is asked for each script.

Exer21.sh
1 #!/bin/bash
2 if asdfgd
3 then
4 echo “it didn’t work”
5 fi
6 echo “we are outside of the if statement”

- What is the output of the shell script? Why did it have that output?
- What do you think is the exit status for line 2

exer22.sh
1 #!/bin/bash
2 testuser=”diplab2”
3 if grep $testuser /etc/passwd
4 then
5 echo “The bash files for user $testuser are:
6 ls -a /home/$testuser/.b*
7 fi
- What is the output of the shell script?
- Explain line by line exer22.sh

exer23.sh
1 #!/bin/bash
2 val1=`echo “scale=4; 10 / 3 “ | bc`
3 echo “The test value is $val1”
4 if [ $val1 -gt 3 ]
5 then
6 echo “The result is larger than 3”
7 fi
- What is the output of the shell script? Why did it have that output?
- Explain what line 2 does.

exer24.sh
1 #!/bin/bash
2 val1=baseball
3 val2=hockey
4 if [ $val1 > $val2 ]
5 then
6 echo “$val1 is greater than $val2”
7 else
8 echo “$val1 is less than $val2”
9 fi
- What is the purpose of script exer24.sh?

Referring to exer24.sh as an example create a script that implements all the String comparison that can
be found on the table presented above and name it as exer25.sh

exer26.sh
1 #!/bin/bash
2 if [ -e $HOME ]
3 then
4 if [ -e $HOME/testing ]
5 then
6 date >> $HOME/testing
7 else
8 date > $HOME/testing
9 fi
10 else
11 echo “Sorry, you don’t have a HOME directory”
12 fi
- What is the output of the script?
- Explain line by line script exer26.sh

exer27.sh
1 #!/bin/bash
2 pwfile=”/etc/shadow”
3 if [ -f $pwfile ]
4 then
5 if [ -r $pwfile ]
6 then

7 tail $pwfile
8 else
9 echo “Sorry, I’m unable to read the $pwfile file”
10 fi
11 else
12 echo “Sorry, the file $ file doesn’t exists”
13 fi
- What is the expected output for this script?
- Explain line by line the exer27.sh

Referring to exer27.sh, create a script that will check if a file is empty. If the file is empty, append to the
file the current date and time. Name it as exer28.sh

Referring to exer27.sh, create a script that will check if a file is writable. If it is, append to the file the
current date and time. Name if as exer29.sh

Refer to test18.sh. Convert the script using the elif shell scripting construct. Save your script as
exer210.sh

exer211.sh
1 #!/bin/bash
2 for ( ( a = 1; a <= 3; a++ ) )
3 do
4 echo “Starting loop at $a:”
5 for ( ( b = 1; b <= 3; b++ ) )
6 do
7 echo “ Inside the loop: $b”
8 done
9 done

- On your own understanding, describe how exer211.sh runs.
- What is the output of the said script?

Referring to exer211.sh, Reconstruct the said script and use the while command. Name the script as
exer212.sh .

exer213.sh: Create a script that will result to the corresponding output below:
Outer loop 5:
Inner loop: 5 * 1 = 5
Outer loop 4:
Outer loop 3:
Outer loop 2:
Outer loop 1:
Outer loop 0:
Inner loop: 0 * 1 =0

exer214.sh
1 #!/bin/bash
2 for ( ( a = 1; a < 4; a++ ) )
3 do
4 echo “Outer loop: $a”
5 for ( ( b = 1; b < 100; b++ ) )
6 do
7 if [ $b -gt 4 ]
8 then
9 break 2
10 fi
11 echo “ Inner loop: $b”
12 done
13 done

- Describe the output of the script.
- How does line 9 works?

exer215.sh

1 #!/bin/bash
2 for ( ( a = 1; a <= 5; a++ ) )
3 do
4 echo “ Iteration $a: “
5 for ( ( b = 1; b < 3; b++ ) )
6 do
7 if [ $a -gt 2 ] && [ $a -lt 4 ]
8 then
9 continue 2
10 fi
11 var3=$[ $a * $b ]
12 echo “ The result of $a * $b is $var3 “
13 done
14 done
- What is the output of script exer21.5.sh
- Describe line by line exer215.sh
- How does line 9 works?

Shell Scripting Structured Commands

Recommended

More Related Content

What's hot (7)

Viewers also liked (11)

Similar to Shell Scripting Structured Commands (20)

More from Don Bosco BSIT (16)

Shell Scripting Structured Commands