Unix Shell Scripting

UNIX SHELL SCRIPTING:
UNIX shell is considered as a master utility program that enables a user to gain access to all other utilities and resources
of the computer.
Shell Script
A shell script is a text file that contains a sequence of commands for a UNIX-based operating system. The shell is
the operating system's command interpreter and the set of commands you use to communicate with the system.
The most commonly used shells are SH(Bourne SHell) , CSH(C SHell) and KSH(Korn SHell), most of the other shells you
encounter will be variants of these shells and will share the same syntax.
Like: KSH & BASH(Bourne Again shell) are based on SH and TCSH Extended C Shell.
It is case sensitive
Declaration:
Declare the type of shell in order to control how the shell is going to run
eg:
#!/usr/bin/sh OR #!/bin/sh Declares a Bourne shell

#!/usr/bin/ksh OR #!/bin/ksh Declares a Korn shell
#!/usr/bin/csh OR #!/bin/csh Declares a C shell
#!/usr/bin/bash OR #!/bin/bash Declares a Bourne-Again shell
If something starts with (#) is considered as commented but if it is followed by (!) it is considered as the special and th e
path followed is the location of the shell which will interpret the script.
Eg : Shell script can be created as
$ vi test.sh
#!/bin/ksh
cd /usr/local/edw
wc -l > count
echo $count
Shell Scripting Basics:

Commands redirecting and pipelines
Redirecting
By default a normal command accepts input from standarad input and directs it to standarad output.
stdin > stdout
But we can also direct output to somewhere other than standard output.
Eg:
ls > file - It will redirect the output to a file

grep searchitem < file-It will serach for the character specified from the directed file (given after the symbol).
Date >> file it will append date value to the file
command 2> - it will redirect all errors for a executed command to a file
Pipelines
It is used to chain commands so that powerfulcomposite comands can be constructed .

the pipe symbol '|' takes the stdout from the command preceding it and redirects it to the command following it:
ls -l | grep searchword | sort r
The Evaluation of Shell Variables/Conditional Substitution

$var value of var; nothing if var undefined
${var} same; useful if alphanumerics follow
variable name
${var-str} value of var if defined; else
str; $var unchanged.
${var=str} value of var if defined; else
str; if undefined, $var set to str.
${var?str} if defined, $var; else, print
str and exit shell; if str empty, print:
var:parameter not set
${var+str} str if $var defined, else null.
Variables:
Global variables: also called environmental variables
VARIABLE_NAME=value
Export VARIABLE_NAME
EXAMPLE
PATH=/bin:/usr/bin
export PATH
Local Variables:
New variables can be instantiated like this
Variable_name=value
Variables are referenced like this: $name

name=John Doe
x=5
echo name
name
To extract the value from variables, a dollar sign is used
echo $name
John Doe
A variable may be referenced like so ${VARIABLENAME}, this allows one to place characters immediately preceding the
variable like ${VARIABLENAME}aaa without the shell interpreting aaa as being part of the variable name
The Global and Local Variables

When a variable is referenced, it is known only to the shell which created it. A new shell created by typing sh, is born
unaware of the parent shells
variables.
The same variable name (as in the parent shell) can be given a different value in the new shell. Such a variable is called
a local variable that is
known only to the child shell.
In many instances, it may be necessary for the child shell to know about the parent shells variables. They are known as
global variables.
$ city=Bombay ; echo $city # Create variable; Response: Bombay
$ sh ; echo $city # create a child shell; No response
$ city=Delhi; echo $city # Create new variable; Response: Delhi
<Press ^d> # Return to parent
echo $city # Parent continues to have value Bombay
The global variables must be exported so that the child shell is aware of them as follows:
$ export city # only the copy passed to the child
Command Line Arguments
Command line arguments are treated as special variables within the script,The command line arguments are
enumerated in the following manner $0, $1, $2, $3, $4,
$5, $6, $7, $8 and $9.
$0 is special in that it corresponds to the name of the script itself

$1 is the first argument
$2 is the second
argument and so on
Shift Command
Often used when you wish to be passwd more that 10 ($0-$9) parameters.
After the shift command is executed, the positional parameters from $2 ... are renamed $1 ...
For example, if commandfile is invoked as:
commandfile arg1 arg2 arg3 arg4 arg5 arg6
$0 $1 $2 $3 $4 $5 $6
After a shift command is executed:
commandfile arg1 arg2 arg3 arg4 arg5 arg6
$0 gone $1 $2 $3 $4 $5
eg:
cat shift.sh
echo Some
echo $1
shift
echo $1
shift
echo $1
$ ksh shift.sh were here there
were
here
there
Set commnads:
One can explicitly force values into the positional parameters using the set command.
For example set -- abc def ghi is equivalent to:
$1=abc
$2=def
$3=ghi
Note:
Positional parameters are not allowed on the left hand side of an
assignment statement.
$ vi setex
set -- THESE THREE VALUES
echo $1 $2 $3
$ sh setex
THESE THREE VALUES
Command Substitution
Command substitution allows the output of a command to be substituted in place of the command
name itself
eg: cat shift.sh

#!/bin/ksh
my_name='John'
echo `echo \ $my_name`
Output: John
Arithmetic Expansion
Arithmetic expansion is also allowed and comes in the form:
$((expression))
#!/bin/bash
first_num=0
second_num=0
echo -n "Enter the first number -->"

read first_num
echo -n "Enter the second number ->"
read second_num
echo "first number + second number = $((first_num + second_num))"

echo "first number - second number = $((first_num - second_num))"
echo "first number * second number = $((first_num * second_num))"
echo "first number / second number = $((first_num / second_num))"
echo "first number % second number = $((first_num % second_num))"
Operators:
The Bourne shell uses the built-in test command operators to test numbers and strings
Equality:
= string
!=string
eq=string
-ne=string
Relational:
-gt Greater than
-ge Greater than equal to
-lt less than
-le less than ,equal to
Logical
-a And
-o OR
! NOT
Test Command
test command is used to see if an expression is true or not
Syntax: test expression

or
[expression]
Example:$ cat > ispostive

#!/bin/sh
# Script to see whether argument is positive #
if test $1 -gt 0 then
echo "$1 number is positive"
fi
Run:$ ispostive 5
5 number is positive
Run:$ispostive -45
Nothing is printed
Control Constructs
The flow of control within SH scripts is done via four main constructs;
If
If..else
If..elif..else
Case Statement
While
Until
For..Loop
If
Syntax:
if command
then
block of statements
fi
or
if [ expression ]
then
block of statements
fi
The if construct is followed by a

command
If an expression is to be tested, it
is enclosed in square brackets
The then keyword is placed after
the closing parenthesis
An if must end with a fi
Eg: if -s $file_name
then
echo File is present
fi
If...Elif..Else
Syntax:
if [ expression ]
then
block of statements
elif [ expresssion ]
then
block of statements
else
block of statements
fi
eg:
#!/bin/sh
if [ "$1" = "1" ]
then
echo "The first choice is nice"
elif [ "$1" = "2" ]
then
echo "The second choice is just as nice"
elif [ "$1" = "3" ]
then
echo "The third choice is excellent"
else
echo "I see you were wise enough not to choose"
echo "You win"
fi
Case statement:
The case statement is terminated with esac (case backwards)
;; indicates that program flow should jump to the end of the entire case statement*) is the default
case .
Syntax:
case variable_name in
pattern1)
statements
;;
pattern2)
statements
;;
*) default value
;;
esac
eg:
case $color in
blue)
echo $color is blue
;;
green)
echo $color is green
;;
*)
echo Not a color # default
esac
Do...While
Syntax:
The Do...While takes the following generic form:
As long as the expression is true, the body of statements between do and done will be executed
while [ expression]
do
block of statements
done
eg:
a=0
while [ $a -lt 10 ]
do
echo $a
a=`expr $a + 1`
done
Until:
The until loop is just like the while loop, except the body of the loop will be executed as long as the expression is false
Syntax:
until [expression]
do
block of statements
done
eg:
until test -f file
do
echo file not created yet
sleep 300;
done
For Loop:
The for loop used to iterate through a list
The for loop is followed by a variable name, the in key word, and a list of words and then a block of statements, and
terminates with the done keyword.
Syntax:
for VARIABLE in 1 2 3 4 5 .. N
do
block of statements
done
eg:
#!/bin/bash
myList=1 2 3 4 5
for i in $myList
do
echo "Welcome $i times
done

Unix Shell Scripting

Uploaded by

Copyright:

Available Formats

Unix Shell Scripting

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unix Shell Scripting

Uploaded by

Copyright:

Available Formats

UNIX SHELL SCRIPTING:

#!/usr/bin/sh OR #!/bin/sh Declares a Bourne shell

Eg : Shell script can be created as

Shell Scripting Basics:

stdin > stdout

ls > file - It will redirect the output to a file

It is used to chain commands so that powerfulcomposite comands can be constructed .

ls -l | grep searchword | sort r

The Evaluation of Shell Variables/Conditional Substitution

Global variables: also called environmental variables

Variables are referenced like this: $name

The Global and Local Variables

Command Line Arguments

$0 is special in that it corresponds to the name of the script itself

eg: cat shift.sh

echo -n "Enter the first number -->"

echo "first number + second number = $((first_num + second_num))"

Syntax: test expression

Example:$ cat > ispostive

The if construct is followed by a

You might also like