Linux Shell Scripting

Linux Bash Shell script
4/8/2015 LINUX BASH SHELL SCRIPT 1

A script is a list of system commands stored in a file.
Steps to write a script :-
Use any editor like vi or vim
chmod permission your-script-name.
Examples:-
$ chmod +x <filename.sh>
$ chmod 755 <filename.sh>
Execute your script as:
$ bash filename.sh
$ bash fileneme.sh
$ ./filename.sh

My first shell script
clear
echo “hello world“
$ ./first
$ chmod 755 first
$ ./first
Variables in Shell:
In Linux (Shell), there are two types of variable:
(1) System variables :
(2) User defined variables :

$ echo $USERNAME
$ echo $HOME
User defined variables :
variable name=value
Examples:
$x = 10
echo Command:
echo command to display text

Shell Arithmetic
arithmetic operations
Syntax:
expr op1 math-operator op2
Examples:
$ expr 10 + 30
$ expr 20 – 10
$ expr 100 / 20
$ expr 200 % 30
$ expr 100 * 30
$ echo `expr 60 + 30`

Renaming files
mv test1 test2
Deleting files
rm -i test1
Creating directories
mkdir dir3
Deleting directories
rmdir dir3

processes
$ ps
PID TTY TIME CMD
$ ps -ef
UID PID PPID C STIME TTY TIME CMD
$ ps -l
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY
TIME CMD
$ ps -efH
UID PID PPID C STIME TTY TIME CMD

Creating files:
$ touch test1
$ ls -il test1
Copying files:
cp source destination
cp test1 test2
Linking files:
There are two different types of file links in Linux:
a. A symbolic, or soft, link
b. A hard link

Quotes
" Double
Quotes
Double Quotes" -
Anything enclose in
double quotes removed
meaning of that
characters (except
and $).
' Single quotes 'Single quotes' - Enclosed in
single quotes remains
unchanged.
` Back quote `Back quote` - To execute
command

Pipes:
who | wc –l
Reading from Files:
$ read message
$ echo $message
Read command to read lines from files
Command substitution:
Var=`date`
Var=$(date)
Background Processes:
ls -R /tmp &

Reading with While
while read ip name alias
do
if [ ! -z “$name” ]; then
# Use echo -en here to suppress ending the line;
# aliases may still be added
echo -en “IP is $ip - its name is $name”
if [ ! -z “$aliases” ]; then
echo “ Aliases: $aliases”
else
# Just echo a blank line
echo
fi
fi
done < /etc/hosts

Stopping processes
kill pid
disk space
$ df
$ df –h
Disk usages:
$ du
Commands:
$ cat file1
$ sort file1
$ cat file2
$ sort file2
$ sort -n file2

Searching for data
grep [options] pattern [file]
The grep command searches either the input
or the file you specify for lines that contain
characters that match the specified pattern.
The output from grep is the lines that contain
the matching pattern.

RANDOM produces a random number between 0 and
32767. This simple recipe produces 10 random
numbers between 200 and 500:
$ cat random.sh
#!/bin/bash
MIN=200
MAX=500
let “scope = $MAX - $MIN”
if [ “$scope” -le “0” ]; then
echo “Error - MAX is less than MIN!”
fi
for i in `seq 1 10`
do
let result=”$RANDOM % $scope + $MIN”
echo “A random number between $MIN and $MAX is
$result”
Done
$ ./random.sh

Problem 1: Code to calculate the length of the hypotenuse
of a Pythagorean triangle
$ cat hypotenuse.sh
#!/bin/sh
# calculate the length of the hypotenuse of a Pythagorean
triangle
# using hypotenuse^2 = adjacent^2 + opposite^2
echo -n “Enter the Adjacent length: “
read adjacent
echo -n “Enter the Opposite length: “
read opposite
osquared=$(($opposite ** 2)) # get o^2
asquared=$(($adjacent ** 2)) # get a^2
hsquared=$(($osquered + $asquared)) # h^2 = a^2 +
o^2
hypotenuse=`echo “scale=3;sqrt ($hsquared)” | bc`
# bc does sqrt
echo “The Hypotenuse is $hypotenuse”

Environment Variables
There are two types of environment variables in
the bash shell
Global variables
Local variables

Variable Arrays
An array is a variable that can hold multiple values.
To set multiple values for an environment variable, just list them in
parentheses, with each value
separated by a space:
$ mytest=(one two three four five)
$
Not much excitement there. If you try to display the array as a normal
environment variable,
you’ll be disappointed:
$ echo $mytest
one
$
Only the first value in the array appears. To reference an individual array
element, you must use
a numerical index value, which represents its place in the array. The numeric
value is enclosed in
square brackets:
$ echo ${mytest[2]}
three
$

Scripting basics
$ date ; who
$ chmod u+x test1
$ ./test1
$ echo This is a test
This is a test
$ echo Let’s see if this’ll work
Lets see if thisll work
$

The backtick
One of the most useful features of shell scripts is the lowly
back quote character, usually called the
backtick (`) in the Linux world.
You must surround the entire command line command
with backtick characters:
testing=`date`
$ cat test5
#!/bin/bash
# using the backtick character
testing=`date`
echo "The date and time are: " $testing
$

Redirecting Input and Output
Output redirection
The most basic type of redirection is sending output from
a command to a file. The bash shell uses the greater-than
symbol for this:
command > outputfile
Input redirection
Input redirection is the opposite of output redirection
The input redirection symbol is the less-than symbol (<):
command < inputfile

The expr command
$ expr 1 + 5
6
The bash shell includes the expr command to stay
compatible with the Bourne shell; however, it
also provides a much easier way of performing
mathematical equations
$ var1=$[1 + 5]
$ echo $var1
6
$ var2 = $[$var1 * 2]
$ echo $var2
12
$

$ chmod u+x test7
$ ./test7
The final result is 500
$
Using bc in scripts
variable=`echo "options; expression" | bc`
$ chmod u+x test9
$ ./test9
The answer is .6880
$
$ cat test10
#!/bin/bash
var1=100

var2=45
var3=ècho "scale=4; $var1 / $var2" | bc`
echo The answer for this is $var3
$
$ cat test11
#!/bin/bash
var1=20
var2=3.14159
var3=ècho "scale=4; $var1 * $var1" | bc`
var4=ècho "scale=4; $var3 * $var2" | bc`
echo The final result is $var4
$

$ cat test12
#!/bin/bash
var1=10.46
var2=43.67
var3=33.2
var4=71
var5=`bc << EOF
scale = 4
a1 = ( $var1 * $var2)
b1 = ($var3 * $var4)
a1 + b1
EOF
`
echo The final answer for this mess is $var5
$

Checking the exit status
$ date
Sat Sep 29 10:01:30 EDT 2007
$ echo $?
0
$
$ cat test13
#!/bin/bash
# testing the exit status
var1=10
var2=30
var3=$[ $var1 + var2 ]
echo The answer is $var3
exit 5
$

$ cat test14
#!/bin/bash
# testing the exit status
var1=10
var2=30
var3=$[ $var1 + var2 ]
exit $var3
$
$ chmod u+x test14
$ ./test14
$ echo $?
40
$

Structured Commands
if-then Statement:
The if-then statement has the following format:
if command
then
commands
Fi
The if-then-else Statement
if command
then
commands
else
commands
fi

Nesting ifs
if command1
then
commands
elif command2
then
more commands
Fi
You can continue to string elif statements together, creating one huge if-then-elif conglomeration:
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

Numeric comparisons
The most common method for using the test command is to
perform a comparison of two numeric values.
#!/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

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.

String comparisons
String equality
The equal and not equal conditions are fairly self-
explanatory with strings. It’s pretty easy to know
when two string values are the same or not:
#!/bin/bash
# testing string equality
testuser=rich
if [ $USER = $testuser ]
then
echo "Welcome $testuser"
fi
$ ./test7
Welcome rich
$

The test Command String Comparisons
Comparison Description
str1 = str2 Check if str1 is the same as
string str2.
str1 != str2 Check if str1 is not the same
as str2.
str1 < str2 Check if str1 is less than str2.
str1 > str2 Check if str1 is greater than
str2.

The for Command
for var in list
do
commands
Done
Reading values in a list
#!/bin/bash
# basic for command
for test in Alabama Alaska Arizona Arkansas California Colorado
do
echo The next state is $test
done
$ ./test1

reading values from a file
file="states"
for state in `cat $file`
do
echo "Visit beautiful $state"
Done

internal field separator
A space
A tab
A newline
file="states"
IFS=$’n’
for state in `cat $file`
do
echo "Visit beautiful $state"
Done

Reading a directory using wildcards
for file in /home/tmp/*
do
if [ -d "$file" ]
then
echo "$file is a directory"
elif [ -f "$file" ]
Then
echo "$file is a file"
fi
Done

For loop
for (( i=1; i ‹= 10; i++ ))
do
echo "The next number is $i"
done

Multi.sh
#!/bin/sh
a=$1
if [ $a -lt 1 -o $a -gt 9 ]; then
echo “The number is out of range [1,9]”
exit
fi
echo "Multiplication Table for $a"
for i in 1 2 3 4 5 6 7 8 9
do
m=$[a * i]
echo "$a x $i = $m"
done

Shell Arguments
#!/bin/sh
echo "Total number of arguments = $#"
echo "Shell script name = $0"
echo "First arguemnt = $1"
echo "Second arguemnt = $2"
echo “Third argument = $3”
echo "All arguments (a word) = $*"
echo "All arguments in array = $@"

Loops
#!/bin/sh
for i in 1 2 3 4 5 6 7 8 9
do
echo “number $i”
done
#!/bin/sh
for i in `seq 1 100`
do
if [ $i -lt 5 ]; then
continue
elif [ $i -gt 10 ]; then
break
fi
echo "number $i"
done

Loops (while statement)
while
expression
do
statements
done
#!/bin/sh
i=1
sum=0
while [ $i -le 10 ]
do
sum=$[sum + i]
echo "$i sum = $sum"
i=$[i+1]
done

multiple variables
for (( a=1, b=10; a ‹= 10; a++, b-- ))
do
echo "$a - $b"
Done
Nesting Loops:
for (( a = 1; a ‹= 3; a++ ))
do
echo "Starting loop $a:"
for (( b = 1; b ‹= 3; b++ ))
do
echo " Inside loop: $b"
done
done

functions
#!/bin/sh
function tm_score () {
local pdb1=$1
local pdb2=$2
echo "`tmscore $pdb1 $pdb2 | grep ^TM | awk '{print
$3}'`"
}
a=$1
b=$2
tm_score $a $b

Breaking out of an inner loop
for (( a = 1; a ‹ 4; a++ ))
do
echo "Outer loop: $a"
for (( b = 1; b ‹ 100; b++ ))
do
if [ $b -eq 5 ]
then
break
fi
echo " Inner loop: $b"
done
done

Breaking out of an outer loop
for (( a = 1; a ‹ 4; a++ ))
do
echo "Outer loop: $a"
for (( b = 1; b ‹ 100; b++ ))
do
if [ $b -gt 4 ]
then
break 2
fi
echo " Inner loop: $b"
done
done

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

Continue
for (( a = 1; a ‹= 5; a++ ))
do
echo "Iteration $a:"
for (( b = 1; b ‹ 3; b++ ))
do
if [ $a -gt 2 ] && [ $a -lt 4 ]
then
continue 2
fi
var3=$[ $a * $b ]
echo " The result of $a * $b is $var3"
done
done

Read file into bash array
◦ exec < $1
let count=0
while read LINE; do
ARRAY[$count]=$LINE
((count++))
done
echo Number of elements: ${#ARRAY[@]}
# echo array's content
echo ${ARRAY[@]}
# restore stdin from filedescriptor 10
# and close filedescriptor 10
exec 0<&10 10<&-

Processing the Output of a
Loop
for file in /home/rich/*
do
if [ -d "$file" ]
then
echo "$file is a directory"
elif
echo "$file is a file"
fi
done > output.txt

Creating a function
function name {
commands
}
name() {
commands
}

Using functions
function func1 {
echo "This is an example of a function"
}
count=1
while [ $count -le 5 ]
do
func1
count=$[ $count + 1 ]
done

count=1
echo "This line comes before the function
definition"
function func1 {
}
while [ $count -le 5 ]
do
func1
count=$[ $count + 1 ]
done
echo "This is the end of the loop"
func2
echo "Now this is the end of the script"
function func2 {
}

Regex
$echo {a..z}
$ echo {5..-1}
if [[ $digit =~ [0-9] ]]; then echo '$digit is a digit' else echo "oops" fi

Regular expression operators
Operator
. Matches any single
character.
? The preceding item is
optional and will be
matched, at most, once.
* The preceding item will
be matched zero or more
times.
+ The preceding item will
be matched one or more
times.
{N} The preceding item is
matched exactly N times.
{N,} The preceding item is4/8/2015 LINUX BASH SHELL SCRIPT 54

Regular expressions
As with other comparison operators (e.g., -lt or ==), bash will return a zero if an
expression like $digit =~ "[[0-9]]" shows that the variable on the left matches the
expression on the right and a one otherwise. This example test asks whether the
value of $digit matches a single digit.
if [[ $digit =~ [0-9] ]]; then
echo '$digit is a digit'
else
echo "oops"
fi
You can also check whether a reply to a prompt is numeric with similar
syntax:
echo -n "Your answer> "
read REPLY
if [[ $REPLY =~ ^[0-9]+$ ]]; then
echo Numeric
else
echo Non-numeric
fi

Sample bash script to perform the unpack/compile process
#!/usr/bin/env bash
if [ -d work ]
then
# remove old work directory if it exists
rm -rf work
fi
mkdir work
cd work
tar xzf /usr/src/distfiles/sed-3.02.tar.gz
cd sed-3.02
./configure --prefix=/usr
make

Linux Shell Scripting

More Related Content

What's hot

Similar to Linux Shell Scripting

More from Raghu nath

Recently uploaded

Linux Shell Scripting