Anda di halaman 1dari 14

Shell Scripting

Getting started with Shell Programming

How to write shell script
Variables in shell
How to define User defined variables (UDV)
Rules for Naming variable name (Both UDV and System Variable)
How to print or access value of UDV (User defined variables)
echo Command
Shell Arithmetic
More about Quotes
Exit Status
The read Statement
Wild cards (Filename Shorthand or meta Characters)

Simple Introduction to the Vi Text Editor

1 Overview
A text editor is a program that can be used to create and modify text files. One of the most
popular editors on Linux/Unix systems (it is also available on Windows and many other
platforms) is vi.

2 Introduction
As a brief introduction to vi, go through the following: First, type

vi x
at the Unix prompt. Assuming you did not already have a file named x, this command will
create one. (If you have tried this example before, x will already exist, and vi will work on it.
If you wish to start the example from scratch, simply remove x first.)

The file will of course initially be empty. To put something in it, type the letter i (it stands for
"insert-text mode"), and type the following (including hitting the Enter key at the end of each
of the three lines):

The quick
fox will return.
Then hit the Escape key, to end insert-text-mode.

This mode-oriented aspect of the vi editor differs from many other editors in this
respect. With modeless editors such as joe and emacs, for instance, to insert text at the
cursor position, one simply starts typing, and to stop inserting, one just stops typing!
However, that means that in order to perform most commands, one needs to use the
Control key (in order to distinguish a command from text to be inserted).

Now save the file and exit vi, by typing ZZ (note the capitals).

Again, the key to learning vi is to keep in mind always the difference between insert-text
mode and command mode. In the latter mode, as its name implies, one issues commands,
such as the ZZ above, which we issued to save the file and exit vi. The characters you type
will appear on the screen if you are in insert-text mode, whereas they will not appear on the
screen while you are in command mode. By far the most frequent problem new vi users have
is that they forget they are in insert-text mode, and so their commands are not obeyed.

For example, suppose a new user wants to type ZZ, to save the file and exit vi, but he has
forgotten to hit the Escape key to terminate insert-text mode. Then the ZZ will appear on the
screen, and will become part of the text of the file-and the ZZ command will not be obeyed.

You now have a file named x. You can check its contents by typing (at the Unix shell

more x
which will yield

mThe quick
fox will return.
just as expected.

Now let's see how we can use vi again to modify that file. Type

vi x
again, and make the following changes.

First, suppose we wish to say the fox will not return: We need to first move the cursor to the
word "return". To do this, type /re and hit the Enter key, which instructs vi to move the
cursor to the first instance of /re relative to the current cursor position. (Note that typing only
/r' would have moved the cursor to the first instance of `r', which would be the `r' in `brown',
not what we want.)

Now use the i command again: Hit i, then type not (note the space), and then hit Escape.

Next, let's delete the word `brown'. Type b to move the cursor there, and then hit x five times,
to delete each of the five letters in `brown'. (This will still leave us with a blank line. If we
did not want this, we could have used the dd' command, which would have deleted the entire

Now type ZZ to save the file and exit vi. Use the more command again to convince yourself
that you did indeed modify the file.

3 Going Further: Other Frequently-Used Commands

You now know how to use vi to insert text, move the cursor to text, and delete text.
Technically, the bare-bones set of commands introduced above is sufficient for any use of vi.
However, if you limit yourself to these few commands, you will be doing a large amount of
unnecessary, tiresome typing.

So, you should also learn at least some of these other frequently-used vi commands:

h move cursor one character to left

j move cursor one line down
k move cursor one line up
l move cursor one character to right
w move cursor one word to right
b move cursor one word to left
0 move cursor to beginning of line
$ move cursor to end of line
nG move cursor to line n
control-f scroll forward one screen
control-b scroll backward one screen

i insert to left of current cursor position (end with ESC)

a append to right of current cursor position (end with ESC)
dw delete current word (end with ESC)
cw change current word (end with ESC)
r change current character
~ change case (upper-, lower-) of current character

dd delete current line

D delete portion of current line to right of the cursor
x delete current character
ma mark currrent position
d`a delete everything from the marked position to here
`a go back to the marked position
p dump out at current place your last deletion (``paste'')

u undo the last command

. repeat the last command

J combine (``join'') next line with this one

:w write file to disk, stay in vi

:q! quit VI, do not write file to disk,
ZZ write file to disk, quit vi

:r filename read in a copy of the specified file to the current


/string search forward for string (end with Enter)

?string search backward for string (end with Enter)
n repeat the last search (``next search'')

:s/s1/s2 replace (``substitute'') (the first) s1 in this line by s2

:lr/s/s1/s2/g replace all instances of s1 in the line range lr by s2
(lr is of form `a,b', where a and b are either explicit
line numbers, or . (current line) or $ (last line)
:map k s map the key k to a string of vi commands s (see below)
:abb s1 s2 expand the string s1 in append/insert mode to a string
s2 (see below)
% go to the "mate," if one exists, of this parenthesis
or brace or bracket (very useful for programmers!)
All of the `:' commands end with your hitting the Enter key. (By the way, these are called
"ex" commands, after the name of the simpler editor from which vi is descended.)

The a command, which puts text to the right of the cursor, does put you in insert-text mode,
just like the i command does.

By the way, if you need to insert a control character while in append/insert mode, hit control-
v first. For example, to insert control-g into the file being edited, type control-v then control-

One of vi's advantages is easy cursor movement. Since the keys h,j,k,l are adjacent and easily
accessible with the fingers of your right hand, you can quickly reach them to move the cursor,
instead of fumbling around for the arrow keys as with many other editors (though they can be
used in vi too). You will find that this use of h,j,k,l become second nature to you very
quickly, very much increasing your speed, efficiency and enjoyment of text editing.

Many of the commands can be prefixed by a number. For example, 3dd means to delete
(consecutive) three lines, starting with the current one. As an another example, 4cw will
delete the next four words.

The p command can be used for "cut-and-paste" and copy operations. For example, to move
three lines from place A to place B:

1. Move the cursor to A.

2. Type 3dd.

3. Move the cursor to B.

4. Type p.

The same steps can be used to copy text, except that p must be used twice, the first time being
immediately after Step 2 (to put back the text just deleted).

How to write shell script

Following steps are required to write shell script:

(1) Use any editor like vi or mcedit to write shell script.

(2) After writing shell script set execute permission for your script as follows
chmod permission your-script-name

$ chmod +x your-script-name
$ chmod 755 your-script-name

Note: This will set read write execute(7) permission for owner, for group and other
permission is read and execute only(5).

(3) Execute your script as

bash your-script-name
sh your-script-name

$ bash bar
$ sh bar
$ ./bar

NOTE In the last syntax ./ means current directory, But only . (dot) means execute given
command file in current shell without starting the new copy of shell, The syntax for . (dot)
command is as follows

. command-name

$ . foo

Now you are ready to write first shell script that will print "Knowledge is Power" on screen.

$ vi first
# My first shell script
echo "Knowledge is Power"

After saving the above script, you can run the script as follows:
$ ./first

This will not run script since we have not set execute permission for our script first; to do this
type command

$ chmod 755 first

$ ./first

First screen will be clear, then Knowledge is Power is printed on screen.

Script Command(s) Meaning

$ vi first Start vi editor
# followed by any text is considered as
comment. Comment gives more
information about script, logical
# My first shell script
explanation about shell script.
# comment-text
clear clear the screen
To print message or value of variables
on screen, we use echo command,
general form of echo command is as
echo "Knowledge is Power"
echo "Message"


1)Write following shell script, save it, execute it and note down the it's output.

$ vi ginfo
# Script to print user information who currently login , current date &
echo "Hello $USER"
echo "Today is \c ";date
echo "Number of user login : \c" ; who | wc -l
echo "Calendar"
exit 0

At the end why statement exit 0 is used?

Exit Status
By default in Linux if particular command/shell script is executed, it return two type of
values which is used to see whether command or shell script executed is successful or not.

(1) If return value is zero (0), command is successful.

(2) If return value is nonzero, command is not successful or some sort of error executing
command/shell script.

This value is know as Exit Status.

But how to find out exit status of command or shell script?
Simple, to determine this exit Status you can use $? special variable of shell.

For e.g. (This example assumes that unknow1file doest not exist on your hard drive)
$ rm unknow1file
It will show error as follows
rm: cannot remove `unkowm1file': No such file or directory
and after that if you give command
$ echo $?
it will print nonzero value to indicate error. Now give command
$ ls
$ echo $?
It will print 0 to indicate command is successful.

Try the following commands and not down the exit status:
$ expr 1 + 3
$ echo $?

$ echo Welcome
$ echo $?

$ wildwest canwork?
$ echo $?

$ date
$ echo $?

$ echon $?
$ echo $?

Variables in Shell
To process our data/information, data must be kept in computers RAM memory. RAM
memory is divided into small locations, and each location had unique number called memory
location/address, which is used to hold our data. Programmer can give a unique name to this
memory location/address called memory variable or variable (Its a named storage location
that may take different values, but only one at a time).

In Linux (Shell), there are two types of variable:

(1) System variables - Created and maintained by Linux itself. This type of variable defined
(2) User defined variables (UDV) - Created and maintained by user. This type of variable
defined in lower letters.

You can see system variables by giving command like $ set, some of the important System
variables are:

System Variable Meaning
BASH=/bin/bash Our shell name
BASH_VERSION=1.14.7(1) Our shell version name
COLUMNS=80 No. of columns for our screen
HOME=/home/vivek Our home directory
LINES=25 No. of columns for our screen
LOGNAME=students students Our logging name
OSTYPE=Linux Our Os type
PATH=/usr/bin:/sbin:/bin:/usr/sbin Our path settings
PS1=[\u@\h \W]\$ Our prompt settings
PWD=/home/students/Common Our current working directory
SHELL=/bin/bash Our shell name
USERNAME=vivek User name who is currently login to this PC

NOTE that Some of the above settings can be different in your PC/Linux environment. You
can print any of the above variables contains as follows:
$ echo $USERNAME
$ echo $HOME

1) If you want to print your home directory location then you give command:
a)$ echo $HOME


(b)$ echo HOME

Which of the above command is correct & why?

Caution: Do not modify System variable this can some time create problems.

How to define User defined variables

To define UDV use following syntax
variable name=value

'value' is assigned to given 'variable name' and Value must be on right side = sign.

$ no=10# this is ok
$ 10=no# Error, NOT Ok, Value must be on right side of = sign.
To define variable called 'vech' having value Bus
$ vech=Bus
To define variable called n having value 10
$ n=10

Rules for Naming variable name (Both

UDV and System Variable)
(1) Variable name must begin with Alphanumeric character or underscore character (_),
followed by one or more Alphanumeric character. For e.g. Valid shell variable are as follows

(2) Don't put spaces on either side of the equal sign when assigning value to variable. For e.g.
In following variable declaration there will be no error
$ no=10
But there will be problem for any of the following variable declaration:
$ no =10
$ no= 10
$ no = 10

(3) Variables are case-sensitive, just like filename in Linux. For e.g.
$ no=10
$ No=11
$ NO=20
$ nO=2
Above all are different variable name, so to print value 20 we have to use $ echo $NO and
not any of the following
$ echo $no # will print 10 but not 20
$ echo $No# will print 11 but not 20
$ echo $nO# will print 2 but not 20

(4) You can define NULL variable as follows (NULL variable is variable which has no value
at the time of definition) For e.g.
$ vech=
$ vech=""
Try to print it's value by issuing following command
$ echo $vech
Nothing will be shown because variable has no value i.e. NULL variable.

(5) Do not use ?,* etc, to name your variable names.

How to print or access value of UDV (User

defined variables)
To print or access UDV use following syntax

Define variable vech and n as follows:

$ vech=Bus
$ n=10
To print contains of variable 'vech' type
$ echo $vech
It will print 'Bus',To print contains of variable 'n' type command as follows
$ echo $n

Caution: Do not try $ echo vech, as it will print vech instead its value 'Bus' and $ echo n, as
it will print n instead its value '10', You must use $ followed by variable name.

Q.1.How to Define variable x with value 10 and print it on screen.
Q.2.How to Define variable xn with value Rani and print it on screen
Q.3.How to print sum of two numbers, let's say 6 and 3?
Q.4.How to define two variable x=20, y=5 and then to print division of x and y (i.e. x/y)
Q.5.Modify above and store division of x and y to variable called z
Q.6.Point out error if any in following script

$ vi variscript
# Script to test MY knowledge about variables!
myos = TroubleOS
echo "My name is $myname"
echo "My os is $myos"
echo "My number is myno, can you see this number"

echo Command
Use echo command to display text or value of variable.

echo [options] [string, variables...]

Displays text or variables value on screen.
-n Do not output the trailing new line.
-e Enable interpretation of the following backslash escaped characters in the strings:
\a alert (bell)
\b backspace
\c suppress trailing new line
\n new line
\r carriage return

\t horizontal tab
\\ backslash

For e.g. $ echo -e "An apple a day keeps away \a\t\tdoctor\n"

Shell Arithmetic
Use to perform arithmetic operations.

expr op1 math-operator op2

$ expr 1 + 3
$ expr 2 - 1
$ expr 10 / 2
$ expr 20 % 3
$ expr 10 \* 3
$ echo `expr 6 + 3`

expr 20 %3 - Remainder read as 20 mod 3 and remainder is 2.
expr 10 \* 3 - Multiplication use \* and not * since its wild card.

For the last statement not the following points

(1) First, before expr keyword we used ` (back quote) sign not the (single quote i.e. ') sign.
Back quote is generally found on the key under tilde (~) on PC keyboard OR to the above of
TAB key.

(2) Second, expr is also end with ` i.e. back quote.

(3) Here expr 6 + 3 is evaluated to 9, then echo command prints 9 as sum

(4) Here if you use double quote or single quote, it will NOT work
For e.g.
$ echo "expr 6 + 3" # It will print expr 6 + 3
$ echo 'expr 6 + 3' # It will print expr 6 + 3

Parameter substitution.

Now consider following command

$($ echo 'expr 6 + 3')

The command ($ echo 'expr 6 + 3') is know as Parameter substitution. When a command
is enclosed in backquotes, the command get executed and we will get output. Mostly this is
used in conjunction with other commands. For e.g.

$cp /mnt/cdrom/lsoft/samba*.rmp `pwd`

More about Quotes

There are three types of quotes

Quotes Name Meaning

Double "Double Quotes" - Anything enclose in double quotes removed meaning
Quotes of that characters (except \ and $).
' 'Single quotes' - Enclosed in single quotes remains unchanged.

` Back quote
`Back quote` - To execute command

$ echo "Today is date"
Can't print message with today's date.
$ echo "Today is `date`".
It will print today's date as, Today is Tue Jan ....,Can you see that the `date` statement uses
back quote?

The read Statement

Use to get input (data from user) from keyboard and store (data) to variable.
read variable1, variable2,...variableN

Following script first ask user, name and then waits to enter name from the user via keyboard.
Then user enters name from keyboard (after giving name you have to press ENTER key) and
entered name through keyboard is stored (assigned) to variable fname.

$ vi sayH
#Script to read your name from key-board
echo "Your first name please:"
read fname
echo "Hello $fname, Lets be friend!"

Run it as follows:
$ chmod 755 sayH
$ ./sayH
Your first name please: vivek
Hello vivek, Lets be friend!

Wild cards (Filename Shorthand or meta


Wild card
Meaning Examples
$ ls * will show all files
will show all files
$ ls a* whose first name is
starting with letter 'a'
Matches any string or group of will show all files
* $ ls *.c
characters. having extension .c
will show all files
having extension .c
$ ls ut*.c
but file name must
begin with 'ut'.
will show all files
$ ls ? whose names are 1
character long
? Matches any single character. will show all files
whose names are 3
$ ls fo?
character long and file
name begin with fo
will show all files
Matches any one of the
[...] $ ls [abc]* beginning with letters
enclosed characters

[..-..] A pair of characters separated by a minus sign denotes a range.

$ ls /bin/[a-c]*

Will show all files name beginning with letter a,b or c like

/bin/arch /bin/awk /bin/bsh /bin/chmod /bin/cp
/bin/ash /bin/basename /bin/cat /bin/chown /bin/cpio
/bin/ash.static /bin/bash /bin/chgrp /bin/consolechars /bin/csh

$ ls /bin/[!a-o]
$ ls /bin/[^a-o]

If the first character following the [ is a ! or a ^ ,then any character not enclosed is matched
i.e. do not show us file name that beginning with a,b,c,e...o, like

/bin/ps /bin/rvi /bin/sleep /bin/touch /bin/view

/bin/pwd /bin/rview /bin/sort /bin/true /bin/wcomp
/bin/red /bin/sayHello /bin/stty /bin/umount /bin/xconf
/bin/remadmin /bin/sed /bin/su /bin/uname /bin/ypdomainname
/bin/rm /bin/setserial /bin/sync /bin/userconf /bin/zcat
/bin/rmdir /bin/sfxload /bin/tar /bin/usleep
/bin/rpm /bin/sh /bin/tcsh /bin/vi