 Unix Shell programming:

– Shell scripts.
• Definition.
• Uses of shell scripts.
• Writing shell scripts.
 Shell scripts
 A shell script is a text file with Unix
commands in it.
 Shell scripts usually begin with a #! and a
shell name (complete pathname of shell).
– Pathname of shell be found using the which
command.
– The shell name is the shell that will execute
this script.
• E.g: #!/bin/bash
 Shell scripts (contd.)
 If no shell is specified in the script file, the
default is chosen to be the currently
executing shell.
 Shell scripts (contd.)
 Any Unix command can go in a shell script
– Commands are executed in order or in the
flow determined by control statements.
 Different shells have different control
structures
– The #! line is very important.
– We will write shell scripts with the Bourne
shell (bash).
 Shell scripts (contd.)
 A shell script as a standalone is an
executable program:
– Must use chmod to change the permissions of
the script to be executable also.
 Can run script explicitly also, by
specifying the shell name.
– E.g: $ bash myscript
– E.g: $ csh myscript
 Shell scripts (contd.)
 Consider the example
– $ bash myscript
– Invokes the bash shell and then runs the script
using it.
– Its almost as if we had the line #! /bin/bash in
the file myscript.
– Similarly with the second example using csh.
– myscript need not be an executable as bash is
running the script on its behalf.
 Shell scripts (contd.)
 Why write shell scripts ?
– To avoid repetition:
• If you do a sequence of steps with standard Unix
commands over and over, why not do it all with
just one command?
• Or in other words, store all these commands in a
file and execute them one by one.
 Shell scripts (contd.)
 Why write shell scripts ?
– To automate difficult tasks:
• Many commands have subtle and difficult options
that you don’t want to figure out or remember
every time .
 Simple Example
 Assume that I need to execute the
following commands once in a while when
I run out of disk space:
rm -rf $HOME/.netscape/cache
rm -f $HOME/.netscape/his*
rm -f $HOME/.netscape/cookies
rm -f $HOME/.netscape/lock
rm -f $HOME/.netscape/.nfs*
rm -f $HOME/.pine-debug*
rm -fr $HOME/nsmail
 Simple Example (contd.)
 We can put all those commands into a shell
script, called myscript.
[axgopala@nitrogen axgopala]$ cat myscript
#! /bin/bash
rm -rf $HOME/.netscape/cache
rm -f $HOME/.netscape/his*
rm -f $HOME/.netscape/cookies
rm -f $HOME/.netscape/lock
rm -f $HOME/.netscape/.nfs*
rm -f $HOME/.pine-debug*
rm -fr $HOME/nsmail
 Sample Example (contd.)
 To run the script:
– Step 1:
• $ chmod u+x myscript
– Step 2:
• Run the script:
• $ ./myscript
 Each line of the script is processed in
order.
 Shell scripts (contd.)
 Shell variables:
– Declared by:
– varname=varvalue
– To make them an environment variable, we
export it.
– export varname=varvalue
 Shell scripts (contd.)
 Assigning the output of a command to a
variable:
– Using backquotes, we can assign the output of
a command to a variable:

#! /bin/bash
filelist=`ls`
echo $filelist
 Shell scripts (contd.)
 Example:

[axgopala@nitrogen public]$ ls
a b c html/
[axgopala@nitrogen public]$ filelist=`ls`
[axgopala@nitrogen public]$ echo $filelist
a b c html/
[axgopala@nitrogen public]$
 Shell scripts (contd.)
 The expr command:
– Calculates the value of an expression.
– E.g:

[axgopala@nitrogen axgopala]$ value=`expr 1 + 2`

[axgopala@nitrogen axgopala]$ echo $value
3
[axgopala@nitrogen axgopala]$
 Notes on expr
 Why do we need the expr command ???
– E.g:

[axgopala@nitrogen public]$ file=1+2

[axgopala@nitrogen public]$ echo $file
1+2
[axgopala@nitrogen public]$

NOTE: 1+2 is copied as it is into val and not the result of

the expression, to get the result, we need expr.
 Notes on expr
 Variables as arguments:

[axgopala@nitrogen axgopala]$ count=5

[axgopala@nitrogen axgopala]$ count=`expr $count + 1`
[axgopala@nitrogen axgopala]$ echo $count
6
[axgopala@nitrogen axgopala]$

NOTE: count is replaced with its value by

the shell!
 Notes on expr
 expr supports the following operators:
– arithmetic operators: +,-,*,/,%
– comparison operators: <, <=, ==, !=, >=, >
– boolean/logical operators: &, |
– parentheses: (, )
– precedence is the same as C, Java
 Control statements
 Without control statements, execution
within a shell scripts flows from one
statement to the next in succession.
 Control statements control the flow of
execution in a programming language.
 Control statements
 The three most common types of control
statements:
– conditionals: if/then/else, case, ...
– loop statements: while, for, until, do, ...
– branch statements: subroutine calls (good
programming practice), goto (usage not
recommended).
 for loops
 for loops allow the repetition of a
command for a specific set of values.
 Syntax:
for var in value1 value2 ...
do
command_set
done
– command_set is executed with each value of
var (value1, value2, ...) in sequence
 Notes on for
 Example: Listing all files in a directory.
#! /bin/bash

for i in *
do
echo $i
done

NOTE: * is a wild card that stands for all files in the

current directory, and for will go through each value
in *, which is all the files and $i has the filename.
 Notes on for
 Example output:

[axgopala@nitrogen public]$ chmod u+x listfiles

[axgopala@nitrogen public]$ ./listfiles
a
b
c
html
listfiles
[axgopala@nitrogen public]$
 Conditionals
 Conditionals are used to “test” something.
– In Java or C, they test whether a Boolean
variable is true or false.
– In a Bourne shell script, the only thing you can
test is whether or not a command is
“successful”.
 Conditionals
 Every well behaved command returns back
a return code.
– 0 if it was successful
– Non-zero if it was unsuccessful (actually
1..255)
– This is different from C.
 The if command
 Simple form:
if decision_command_1
then
command_set_1
fi
 The if command
 Importance of having then on the next line:
– Each line of a shell script is treated as one
command.
– then is a command in itself
• Even though it is part of the if structure, it is
treated separately.
 Example

grep returns 0 if it finds something

returns non-zero otherwise

if grep unix myfile >/dev/null

then
echo "It's there"
fi redirect to /dev/null so that
"intermediate" results do not get
printed
 Using else with if
 Example:

#! /bin/bash
if grep "UNIX" myfile >/dev/null
then
echo UNIX occurs in myfile
else
echo No!
echo UNIX does not occur in myfile
fi
 Using elif with if
#! /bin/bash
if grep "UNIX" myfile >/dev/null
then
echo UNIX occurs in myfile
elif grep “DOS” myfile > /dev/null
then
echo DOS appears in myfile not UNIX
else
echo nobody is here in myfile
fi
 Using colon in shell scripts
 Sometimes, we do not want a statement to
do anything.
– In that case, use a colon ‘:’
• if grep UNIX myfile > /dev/null
• then
• :
• fi
• Does not do anything when UNIX is found in
myfile .
 The test command
 Use for checking validity.
 Three kinds:
– Check on files.
– Check on strings.
– Check on integers
 Notes on test
 Testing on files.
– test –f file: does file exist and is not a
directory?
– test -d file: does file exist and is a directory?
– test –x file: does file exist and is executable?
– test –s file: does file exist and is longer than 0
bytes?
 Example
#!/bin/bash
count=0
for i in *; do
if test –x $i
then
count=`expr $count + 1`
fi
done
echo Total of $count files executable
NOTE: expr $count + 1 serves the purpose
of count++
 Notes on test
 Testing on strings.
– test –z string: is string of length 0?
– test string1 = string2: does string1 equal
string2?
– test string1 != string2: not equal?
 Example
#! /bin/bash
if test -z $REMOTEHOST
then
:
else
DISPLAY="$REMOTEHOST:0“
export DISPLAY
fi

NOTE: This example tests to see if the value of

REMOTEHOST is a string of length > 0 or not,
and then sets the DISPLAY to the appropriate value.
 Notes on test
 Testing on integers.
– test int1 –eq int2: is int1 equal to int2 ?
– test int1 –ne int2: is int1 not equal to int2 ?
– test int1 –lt int2: is int1 less than to int2 ?
– test int1 –gt int2: is int1 greater than to int2 ?
– test int1 –le int2: is int1 less than or equal to int2 ?
– test int1 –ge int2: is int1 greater than or equal to int2 ?
 Example
#!/bin/bash
smallest=10000
for i in 5 8 19 8 7 3
do
if test $i -lt $smallest
then
smallest=$i
fi
done
echo $smallest

NOTE: This program calculates the smallest among

the numbers 5, 8, 19, 8, 3.
 Notes on test
 The test command has an alias ‘[]’.
– Each bracket must be surrounded by spaces
#!/bin/bash
smallest=10000
for i in 5 8 19 8 7 3
do
if [ $i -lt $smallest ]
then
smallest=$i
fi
done
echo $smallest
 The while loop
 While loops repeat statements as long as
the next Unix command is successful.
 Works similar to the while loop in C.
 Example
#! /bin/bash
i=1
sum=0
while [ $i -le 100 ]
do
sum=`expr $sum + $i`
i=`expr $i + 1`
done
echo The sum is $sum.

NOTE: The value of i is tested in the while to see if

it is less than or equal to 100.
 The until loop
 Until loops repeat statements until the
next Unix command is successful.
 Works similar to the do-while loop in C.
 Example

#! /bin/bash
x=1
until [ $x -gt 3 ]
do
echo x = $x
x=`expr $x + 1`
done

NOTE: The value of x is tested in the until to see if

it is greater than 3.