What is a shell script

Shell script Page 1
What is a Shell Script?
A shell script is a computer program designed
to be run by the Unixshell, a command line
interpreter. The various dialects of shell
scriptsare considered to be scripting languages.
Typical operations performed by shell
scripts include file manipulation, program
execution, and printing text.
What is a shell in Unix?
Shell is a UNIX term for the interactive user
interface with an operating system. The shell is
the layer of programming that understands and
executes the commands a user enters. In some
systems, the shell is called a command
interpreter.
What is a bash file?
Bash is a command processor, typically run in a
text window, allowing the user to type
commands which cause actions. Bash can also
read commands from a file, called a script.
What do you mean by scripting language?
A scripting language or script language is a
programming languagethat supports scripts,
programs written for a special run-time
environment that can interpret (rather than
compile) and automate the execution of tasks
that could alternatively be executed one-by-one
by a human operator.
The following is an example of a basic shell
script:
#!/bin/ksh
# This is a comment on a line by itself
clear # This comment is sharing the line with
the clear command
echo "Text Line 1"
print "Text Line 2"
exit 0
Shell Script Comments
# This is a comment on a line by itself
Displaying Output
echo "Text Line 1"
print "Text Line 2"
Exiting a Shell Script
All shell scripts should be terminated with the
exit command:
exit 0
How to Run a Shell Script
The following command will allow only the user
(owner) of the script to execute it:
$ chmod u+x script1
If you wanted to allow everyone (all) to execute
the script, you would use this command:
$ chmod a+x script1
After the script file has been made an executable
with the chmod command, you can run the
script in a new shell by giving the path to the
script:
$ ./script1
This (./) would be the path to script1 if you are
in the same directory as the script. You can
optionally run the shell program and pass it the
script name as an argument:
$ /bin/ksh script1
This command also indicates that we are in the
same directory as script1 because the path to
the script is not specified.
If you were in a different directory than the
script, you could use one of the following
commands to run it:
$ /home/student1/script1
or
$ /bin/ksh /home/student1/script1
Running this sample script will produce the
following output:
Text Line 1
Text Line 2

Shell script Page 2
Introduction
vi hello.sh
#!/bin/sh
# This is my first script.
echo "Hello Unix"
chmod u+x hello.sh
./hello.sh
Variables
Variables are an important part of any
program or script. A variable is a simple
way to refer to a chunk of data in
memory that can be modified. A variable
in a unix script can be assigned any type
of value, such as a text string or a
number.
VARIABLE_NAME=value
Ex:1
#!/bin/sh
# This is my second script.
VAR_1=Hello
VAR_2=Unix
echo "$VAR_1 $VAR_2"
Ex:2
#!/bin/sh
# This program will print the head and
# tail of a file
# passed in on the command line.
echo "Printing head of $1..."
head $1
echo "" #this prints an extra return...
echo "Printing tail of $1..."
tail $1
Run:
./ht.sh WEB_LOG
Ex:3
#!/bin/sh
# This program will read the filename
# from user input.
echo "Enter the file: "
read FILENAME
echo "Printing head of $FILENAME..."
head $FILENAME
echo "Printing tail of $FILENAME..."
tail $FILENAME
Ex:4
#!/bin/sh
# This program will read the filename
# from user input.
echo "Enter the file: "
read FILENAME
echo "Printing head of
${FILENAME}_LOG..."
head ${FILENAME}_LOG
echo "Printing tail of
${FILENAME}_LOG..."
tail ${FILENAME}_LOG
Now if you run the script with the
command ./ht.sh WEB it will open the
file "WEB_LOG" for the user.
If/Else
Ex:5
#!/bin/sh
# This is some secure program that uses
security.
VALID_PASSWORD="secret" #this is our
password.
echo "Please enter the password:"
read PASSWORD
if [ "$PASSWORD" ==
"$VALID_PASSWORD" ]; then
echo "You have access!"
else

Shell script Page 3
echo "ACCESS DENIED!"
fi
The following table shows the different
expressions allowed.
Comparisons:
-eq equal to
-ne not equal to
-lt less than
-le less than or equal to
-gt greater than
-ge greater than or equal to
File Operations:
-s file exists and is not empty
-f file exists and is not a directory
-d directory exists
-x file is executable
-w file is writable
-r file is readable
Ex:6
#!/bin/sh
# Prompt for a user name...
echo "Please enter your name:"
read USERNAME
# Check for the file.
if [ -s ${USERNAME}_DAT ]; then
# Read the age from the file.
AGE=`cat ${USERNAME}_DAT`
echo "You are $AGE years old!"
else
# Ask the user for his/her age
echo "How old are you?"
read AGE
if [ "$AGE" -le 2 ]; then
echo "You are too
young!"
else
if [ "$AGE" -ge 100 ];
then
echo "You are
too old!"
else
# Write the age to a
new file.
echo $AGE >
${USERNAME}_DAT
fi
fi
fi
The unix command cat reads the file
named ${USERNAME}_DAT and outputs
it to the console.
Ex:7
#!/bin/sh
# Prompt for a user name...
echo "Please enter your age:"
read AGE
if [ "$AGE" -lt 20 ] || [ "$AGE" -ge 50 ];
then
echo "Sorry, you are out of the
age range."
elif [ "$AGE" -ge 20 ] && [ "$AGE" -lt 30 ];
then
echo "You are in your 20s"
elif [ "$AGE" -ge 30 ] && [ "$AGE" -lt 40 ];
then
elif [ "$AGE" -ge 40 ] && [ "$AGE" -lt 50 ];
then
fi
Looping
While Loop
The while statement is used when you
want to loop while a statement is true.
Ex:8
#!/bin/sh
# Guess the number game.
ANSWER=5 # The correct answer
CORRECT=false # The correct flag
while [ "$CORRECT" != "true" ]
do
# Ask the user for the number...
echo "Guess a number between 1 and
10. "
read NUM

Shell script Page 4
# Validate the input...
if [ "$NUM" -lt 1 ] || [ "$NUM" -gt 10
]; then
echo "The number must be
between 1 and 10!"
elif [ "$NUM" -eq "$ANSWER" ]; then
echo "You got the answer
correct!"
CORRECT=true
else
echo "Sorry, incorrect."
fi
done
Ex:9
#!/bin/sh
# Guess the number game.
ANSWER=5 # The correct answer
CORRECT=false # The correct flag
while [ "$CORRECT" != "true" ]
do
# Ask the user for the number...
echo "Guess a number between 1 and
10. "
read NUM
# Validate the input...
if [ "$NUM" -lt 1 ] || [ "$NUM" -gt 10
]; then
echo "The number must be
between 1 and 10!"
elif [ "$NUM" -eq "$ANSWER" ]; then
echo "You got the answer
correct!"
CORRECT=true
else
echo "Sorry, incorrect."
fi
done
Ex:10
Another way to loop forever is to use
the : in your while statement. Let's write
a simple program that will print out how
long it has been running until the user
presses Ctrl+C to terminate the program.
#!/bin/sh
COUNTER=0
while :
do
sleep 1
COUNTER=`expr $COUNTER + 1`
echo "Program has been running
for $COUNTER seconds..."
done
This program will loop until the user
presses Ctrl+C.
For Loop
The for statement is used when you want
to loop through a list of items. The body
of the loop is put between do and done.
Ex:11
#!/bin/sh
# Validate numbers...
echo "Please enter a list of numbers
between 1 and 100. "
read NUMBERS
for NUM in $NUMBERS
do
if [ "$NUM" -lt 1 ] || [ "$NUM" -
gt 100 ]; then
echo "Invalid Number
($NUM) - Must be between 1 and 100!"
else
echo "$NUM is valid."
fi
done
Input :"1 4 3 55 48 120 1000 4 1" and
you will have the following output:
Please enter a list of numbers between 1
and 100.
1 4 3 55 48 120 1000 4 1
1 is valid.
4 is valid.
3 is valid.
55 is valid.
48 is valid.
Invalid Number (120) - Must be between
1 and 100!

Shell script Page 5
Invalid Number (1000) - Must be
between 1 and 100!
4 is valid.
1 is valid.
Cases
Many programming languages and
scripting languages have the concept of
a case or select statement. This is
generally used as a shortcut for writing
if/else statements. The case statement is
always preferred when there are many
items to select from instead of using a
large if/elif/else statement. It is usually
used to implement menus in a script.
The case statement is terminated
with esac(case backwards).
Ex:12
#!/bin/sh
echo "Enter a number between 1 and 10.
"
read NUM
case $NUM in
1) echo "one" ;;
2) echo "two" ;;
3) echo "three" ;;
4) echo "four" ;;
5) echo "five" ;;
6) echo "six" ;;
7) echo "seven" ;;
8) echo "eight" ;;
9) echo "nine" ;;
10) echo "ten" ;;
*) echo "INVALID NUMBER!" ;;
esac
Ex:13
#!/bin/sh
# Wedding guest meals
# These variables hold the counters.
NUM_CHICKEN=0
NUM_STEAK=0
ERR_MSG=""
# This will clear the screen before
displaying the menu.
clear
while :
do
# If error exists, display it
if [ "$ERR_MSG" != "" ]; then
echo "Error:
$ERR_MSG"
echo ""
fi
# Write out the menu options...
echo "Chicken: $NUM_CHICKEN"
echo "Steak: $NUM_STEAK"
echo ""
echo "Select an option:"
echo " * 1: Chicken"
echo " * 2: Steak"
echo " * 3: Exit"
# Clear the error message
ERR_MSG=""
# Read the user input
read SEL
case $SEL in
1)
NUM_CHICKEN=`expr $NUM_CHICKEN +
1` ;;
2) NUM_STEAK=`expr
$NUM_STEAK + 1` ;;
3) echo "Bye!"; exit ;;
*) ERR_MSG="Please
enter a valid option!"
esac
# This will clear the screen so
we can redisplay the menu.
clear
done
Functions
When your scripts start to become very
large, you may tend to notice that you are
repeating code more often in your
scripts.
You have the ability to create functions
inside of your script to help with code
reuse.
Writing the same code in multiple
sections of your script can lead to severe
maintenance problems. When you fix a
bug in a section of code you need to be
sure that all sections of code that are
repeated will also have those fixes.

Shell script Page 6
A function is a block of code that can be
called from other parts of your script. It
can have parameters passed to it as if it
were a separate script itself.
Ex:14
#!/bin/sh
# logit function declaration.
logit()
{
MSG_LEVEL=$1
# Shifts the position of the
parameters over one place.
shift
if [ "$MSG_LEVEL" -ge 1 ] && [
"$MSG_LEVEL" -le 3 ]; then
if [ "$LEVEL" -eq 1 ]
&& [ "$MSG_LEVEL" -ge 1 ]; then
echo "Msg
Level $MSG_LEVEL: $@"
elif [ "$LEVEL" -eq 2 ]
echo "Msg
elif [ "$LEVEL" -eq 3 ]
echo "Msg
fi
fi
}
#Load the log level from the command
line...
LEVEL=$1
# Call the function a couple of times.
logit 1 Logit Test one
logit 2 Logit Test two
logit 3 Logit Test three
logit 4 Logit Test four
Let's save this file and run it several
times with different input levels...
$ test.sh 1
Msg Level 1: Logit Test one
Msg Level 2: Logit Test two
Msg Level 3: Logit Test three
$ test.sh 2
Msg Level 2: Logit Test two
$ test.sh 3
$ test.sh 4
$
Ex:14 Factorial
#!/bin/sh
fac()
{
if [ "$1" -gt 1 ]; then
NEXT=`expr $1 - 1`
REC=`fac $NEXT`
PROD=`expr $1 *
$REC`
echo $PROD
else
echo 1
fi
}
echo "Enter a number: "
read NUM
echo "$NUM! = `fac $NUM`"
A recursive function is a function that
calls itself. Notice at line 7 in the script,
it calls the fac function inside itself.
Recursive functions have the possibility
of going in an endless loop and crashing
if you do not code them right, so only use
a recursive function
Reading & Writing Files
Reading and writing files in linux is
simple, you just use the standard utilities
for reading files such
as cat, grep, tail, head, awketc.. And you
primarily use the output redirect
operator > and standard commands
like sed for writing files.
Ex:15
#!/bin/sh
OP=$1
if [ "$1" == "-a" ]; then
ID=$2
FIRST=$3

Shell script Page 7
LAST=$4
AGE=$5
echo "$ID,$FIRST,$LAST,$AGE"
>> users.dat
echo "User Added"
elif [ "$1" == "-l" ]; then
cat users.dat
fi
The code for this is very simple. To add a
user you simple use echo to print out the
fields with commas between them, then
you redirect the output using
the >> operator. Using the > will redirect
the output STDOUT to a file and
overwrite the entire file, this is why we
use >> instead, because it will append to
a file instead of overwriting the file. And
to print out the file, we simply use
thecat command, which will print out a
file to the console.
Now let's add some users to have a test
data set. Let's call the script users.sh.
./users.sh -a jsmith John Smith 25
./users.sh -a adoe Ann Doe 32
./users.sh -a bgates Bob Gates 17
./users.sh -a kmelvin Kay Melvin 47
./users.sh -a jgamez Joe Gamez 24
./users.sh -a msmith Mike Smith 18
./users.sh -a svai Steve Vai 42
This gave us a nice data set, so now if we
want to print out the users, we can use
the -l option which gives us this list of
data:
jsmith,John,Smith,25
adoe,Ann,Doe,32
bgates,Bob,Gates,17
kmelvin,Kay,Melvin,47
jgamez,Joe,Gamez,24
msmith,Mike,Smith,18
svai,Steve,Vai,42
Searching & Sorting
grep
The unix grep command is a simple but
powerful tool for using in your scripts.
You can use it to search in files for
certain words or even search by regular
expression. Before we get into using
these tools, let's define a file that we can
manipulate. Create a file on your
filesystem with the following contents:
root 192.168.1.1 10/11/2005
/usr/local/bin/one_app
root 192.168.1.1 10/12/2005
/usr/local/bin/two_app
root 192.168.1.1 10/12/2005
/var/logs/system.log
root 192.168.1.2 10/13/2005
/var/logs/approot.log
user1 192.168.1.3 10/13/2005
user1 192.168.1.3 10/13/2005
/usr/local/src/file.c
user1 192.168.1.3 10/14/2005
user2 192.168.1.4 10/14/2005
user2 192.168.1.5 10/15/2005
user2 192.168.1.5 10/15/2005
Save this file as "testfile". The file is an
access log for the file system. It has four
fields separated by spaces: user, ip
address, date and filename. Files such as
this can get very large and hard to find
things when using just a file editor.
Suppose that we wanted to find all rows
that for the file
"/usr/local/bin/one_app". To do this, we
would use the following command and
get the following results:
$ grep "/usr/local/bin/one_app"
testfile
root 192.168.1.1 10/11/2005
user1 192.168.1.3 10/13/2005
This makes the file much easier to search
through. You can also redirect the output
of a command by using > filename after
the command. For instance, let's say that
we want to find all rows for the user
name "root" and redirect it to a file. If we
simply did a grep for "root", we would

Shell script Page 8
also pick up any rows that are for access
to the file "/var/logs/approot.log". What
we really want to do is find any line that
starts with "root". To do this, we will use
the regular expression character ^, which
means "starts with". We will call this
command and have it redirect the output
to the file "output.txt", then we will use
the unix cat command to display the
output.txt file.
$ grep "^root" testfile > output.txt
$ cat output.txt
root 192.168.1.1 10/11/2005
root 192.168.1.1 10/12/2005
root 192.168.1.1 10/12/2005
root 192.168.1.2 10/13/2005
awk
If you only want to view certain fields in
the file, you will want to use the
unix awk command. If you are using
linux, this will most likely be
called gawk, but for this tutorial I will
use the unix name for the command. Let's
say that we want to see all files that were
accessed that end with the text "_app".
We don't want to see the whole rows, we
only want to see column number 4 in the
file (the filename). In order to do this, we
will need to use both grep and awk, then
we will need to pipe the output from one
command to the other. To find a line that
ends with a certain text, we use the
regular expression character $ at the end
of the text. See the following example:
$ grep "_app$" testfile | awk '{print
$4}'
We use the | character to pipe the output
of the grep command to the input of
the awk command. To print the fourth
column of the input data, we give awk the
script contents '{print $4}'. If we want to
display the user name as well, we can
print column $1, but we must separate
the two columns with a comma.
$ grep "_app$" testfile | awk '{print $1,
$4}'
root /usr/local/bin/one_app
root /usr/local/bin/two_app
user1 /usr/local/bin/one_app
user2 /usr/local/bin/two_app
user2 /usr/local/bin/two_app
sort
Another common need in scripts is the
ability to sort input. Luckily unix has
a sort command. All you need to do is
pipe your output to the sort command
and it will be sorted. If you want to see
all files (column 4) in the file and you
want them sorted, use the following
command:
$ awk '{print $4}' testfile | sort
Another common need related to sorting
is to get only unique items. The
unix sort command has a flag -u that tells
it to only display unique items. Let's use
this command to only see unique file
names.
$ awk '{print $4}' testfile | sort -u
Using these commands in a script
All of these commands can be used inside
of your scripts and can make for a very
powerful toolset for developing programs

Shell script Page 9
in unix. For an example of using these
commands in a script, let's write a script
that uses our current data file. The script
will get all users that are in the file and
will then display how many files that
user accessed. We will also have the
script get all files in the file and display
how many times each file was accessed.
There are much more efficient ways of
doing these specific functions, but for
this example we will do it to better show
how you can use these commands in a
script.
#!/bin/sh
# First let's get the list of unique users:
USERS=àwk '{print $1}' testfile | sort -u`
echo "Users:"
# Now loop through each user.
for USER in $USERS
do
# Get the number of lines that
start with the user name.
NUM=`grep -c "^$USER" testfile`
echo " - $USER: $NUM files
accessed."
done
# Now let's get the list of unique files:
FILES=àwk '{print $4}' testfile | sort -u`
echo ""
echo "Files:"
# And loop through each file.
for FILE in $FILES
do
# Get the number of lines that
end with the file name.
NUM=`grep -c "$FILE$" testfile`
echo " - $FILE: $NUM accesses."
done
Notice that we use the command line
parameter -c for grep, this returns a row
count instead of a list of rows. Another
thing to notice is that we are reading the
whole file 2 + (num_users * 2) times. In
our case, that's 8 times. A smarter
program would be able to read the file
once and get the data it needs to parse
out, because I/O calls on a system (such
as reading a file) are always slower than
reading from memory (variables).
Now let's save the script as test.sh and
run it. We get the following output:
$ ./test.sh
Users:
- root: 4 files accessed.
- user1: 3 files accessed.
- user2: 3 files accessed.
Files:
- /usr/local/bin/one_app: 2 accesses.
- /usr/local/bin/two_app: 3 accesses.
- /usr/local/src/file.c: 1 accesses.
- /var/logs/approot.log: 2 accesses.
- /var/logs/system.log: 2 accesses.
Advanced Topics
Substrings
Often times a programmer needs to be
able to get a substring from a variable at
a given position. In unix you can use
the exprcommand to do this with
the substr parameter. Let's say that we
have the text string
"5283username$$2384/" and we want to
get the text "username". To do this we
need to read from position 5 for a length
of 8. The parameters for substr are the
input string, the starting position, and
the length. See the following example:
#!/bin/sh
INPUT="5283username$$2384/"
USER=èxpr substr $INPUT 5 8`
echo "Sub: '$USER'"
Find in a string
Sometimes you need to find text in a
string. Maybe you want to list files but
print only the text appearing before the
".". So if the filename is asdf.txt, you
would want to print only asdf. To do this,

Shell script Page 10
you will use expr index, and pass it the
string followed by the text for which you
are searching. Let's try an example:
#!/bin/sh
# Get the files:
FILES=`ls -1`
for FILE in $FILES
do
IDX=èxpr index $FILE .`
if [ "$IDX" == 0 ]; then
IDX=èxpr length
$FILE`
else
IDX=èxpr $IDX - 1`
fi
SUB=èxpr substr $FILE 1 $IDX`
echo "Sub File: $SUB"
done
If the substring doesn't exist, 0 is
returned. If 0 is returned, we want to
make the IDX variable the length of the
name so that we just display the whole
filename. If a dot is found in the file, we
want to subtract 1 from
our $IDX variable because we don't want
to display the dot.
To lower/upper case
If you want to transform a string to
upper or lower case, you can do so with
the unix tr command. Here's a simple
example.
#!/bin/sh
STR_ORIGINAL=aBcDeFgHiJkLmNoP
STR_UPPER=ècho $STR_ORIGINAL | tr a-
z A-Z`
STR_LOWER=ècho $STR_ORIGINAL | tr
A-Z a-z`
echo "Original: $STR_ORIGINAL"
echo "Upper : $STR_UPPER"
echo "Lower : $STR_LOWER"
Editing a file with sed
If you want to edit a file from within your
script, you can use the
unix sed command. It will take a regular
expression and a filename and put the
file manipulations to standard output.
For instance, let's say that we have a file
with two fields "username" and "home
directory". All the home directories start
with "/home", but what if the admin
changes the location of the "/home"
directory to "/usr/local/home". We can
have sed automatically update our file.
Here is the file, save it as testfile2.
user1 /home/user1
root /home/root
user2 /home/user2
user3 /home/user3
We want our regular expression to search
for "/home" and replace it with
"/usr/local/home", a search expression
is in the following format:
"s/find/replace/", where "find" is the
string you are searching for and
"replace" is what you want to replace it
with. Since the / character is a special
character, we will need to escape it with
a backslash in our find and replace
strings. Here is the command we will use
to do the file edit:
$ sed
"s//home//usr/local/home/"
testfile2 > tmp; cp tmp testfile2
$ cat testfile2
user1 /usr/local/home/user1
root /usr/local/home/root
Notice that we redirect the output of sed
to a file named tmp, we then on the same
line copy the tmp file over the testfile2
file. We cannot specify testfile2 to be the
output since it is also being read from by
sed during the command. On the next line
we cat the output and you can see the file
modifications.
Automating another application

Shell script Page 11
Sometimes we may want to automate
another program or script. If the other
script expects user input, we may want to
write a script to automatically fill in that
information. First let's create a simple
program that accepts a user name and
password:
#!/bin/sh
#Grab user name:
echo "user: "
read USER
#Grab password:
echo "pass: "
read PWD
if [ "$USER" == "dreamsys" ] && [
"$PWD" == "soft" ]; then
echo "Login Success!"
else
echo "Login Failed!"
fi
Save this file as up.sh. Now we need to
create a script to automate this script. To
do this, all we need to do is output the
user name followed by the password to
the command line, we will pass these as
two parameters:
#!/bin/sh
USER=$1
PWD=$2
echo $USER
echo $PWD
Now to run this automation script, we
simply need to pipe the output to
the up.sh script. First we will try to run
it with an invalid user and password,
then we will try to run it with the correct
user and password:
$ ./auto.sh testuser testpass | ./up.sh
user:
pass:
Login Failed!
$ ./auto.sh dreamsys soft | ./up.sh
user:
pass:
Login Success!

What is a shell script

More Related Content

What's hot (20)

Viewers also liked (15)

Similar to What is a shell script (20)

More from Dr.M.Karthika parthasarathy (20)

Recently uploaded (20)

What is a shell script