Creating a script
Creating a script
There are a lot of different shells available for Linux but
usually the bash (bourne again shell) is used for shell programming
as it is available for free and is easy to use. So all the scripts
we will write in this article use the bash (but will most of the
time also run with its older sister, the bourne shell).For writing
our shell programs we use any kind of text editor, e.g. nedit,
kedit, emacs, vi...as with other programming languages.The program
must start with the following line (it must be the first line in
the file):
#!/bin/sh
The #! characters tell the system that the first argument that
follows on the line is the program to be used to execute this file.
In this case /bin/sh is shell we use.When you have written your
script and saved it you have to make it executable to be able to
use it.To make a script executable typechmod +x filename Then you
can start your script by typing: ./filename
Comments
Comments in shell programming start with # and go until the end
of the line. We really recommend you to use comments. If you have
comments and you don't use a certain script for some time you will
still know immediately what it is doing and how it works.
Variables
As in other programming languages you can't live without
variables. In shell programming all variables have the datatype
string and you do not need to declare them. To assign a value to a
variable you write:
varname=value
To get the value back you just put a dollar sign in front of the
variable:
#!/bin/sh
# assign a value:
a="hello world"
# now print the content of "a":
echo "A is:"
echo $a
Type this lines into your text editor and save it e.g. as first.
Then make the script executable by typing chmod +x first in the
shell and then start it by typing ./firstThe script will just
print:
A is:
hello world
Sometimes it is possible to confuse variable names with the rest
of the text:
num=2
echo "this is the $numnd"
This will not print "this is the 2nd" but "this is the " because
the shell searches for a variable called numnd which has no value.
To tell the shell that we mean the variable num we have to use
curly braces:
num=2
echo "this is the ${num}nd"
This prints what you want: this is the 2nd
There are a number of variables that are always automatically
set. We will discuss them further down when we use them the first
time.
If you need to handle mathematical expressions then you need to
use programs such as expr (see table below).Besides the normal
shell variables that are only valid within the shell program there
are also environment variables. A variable preceeded by the keyword
export is an environment variable. We will not talk about them here
any further since they are normally only used in login scripts.
Shell commands and control structures
There are three categories of commands which can be used in
shell scripts:
1)Unix commands:Although a shell script can make use of any unix
commands here are a number of commands which are more often used
than others. These commands can generally be described as commands
for file and text manipulation.
Command syntaxPurpose
echo "some text"write some text on your screen
lslist files
wc -l filewc -w filewc -c filecount lines in file orcount words
in file orcount number of characters
cp sourcefile destfilecopy sourcefile to destfile
mv oldname newnamerename or move file
rm filedelete a file
grep 'pattern' filesearch for strings in a fileExample: grep
'searchstring' file.txt
cut -b colnum fileget data out of fixed width columns of
textExample: get character positions 5 to 9cut -b5-9 file.txtDo not
confuse this command with "cat" which is something totally
different
cat file.txtwrite file.txt to stdout (your screen)
file somefiledescribe what type of file somefile is
read varprompt the user for input and write it into a variable
(var)
sort file.txtsort lines in file.txt
uniqremove duplicate lines, used in combination with sort since
uniq removes only duplicated consecutive linesExample: sort
file.txt | uniq
exprdo math in the shellExample: add 2 and 3expr 2 "+" 3
findsearch for filesExample: search by name:find . -name
filename -printThis command has many different possibilities and
options. It is unfortunately too much to explain it all in this
article.
teewrite data to stdout (your screen) and to a fileNormally used
like this:somecommand | tee outfileIt writes the output of
somecommand to the screen and to the file outfile
basename filereturn just the file name of a given name and strip
the directory pathExample: basename /bin/tuxreturns just tux
dirname filereturn just the directory name of a given name and
strip the actual file nameExample: dirname /bin/tuxreturns just
/bin
head fileprint some lines from the beginning of a file
tail fileprint some lines from the end of a file
sedsed is basically a find and replace program. It reads text
from standard input (e.g from a pipe) and writes the result to
stdout (normally the screen). The search pattern is a regular
expression (see references). This search pattern should not be
confused with shell wildcard syntax. To replace the string
linuxfocus with LinuxFocus in a text file use:cat text.file | sed
's/linuxfocus/LinuxFocus/' > newtext.fileThis replaces the first
occurance of the string linuxfocus in each line with LinuxFocus. If
there are lines where linuxfocus appears several times and you want
to replace all use:cat text.file | sed 's/linuxfocus/LinuxFocus/g'
> newtext.file
awkMost of the time awk is used to extract fields from a text
line. The default field separator is space. To specify a different
one use the option -F.
cat file.txt | awk -F, '{print $1 "," $3 }'
Here we use the comma (,) as field separator and print the first
and third ($1 $3) columns. If file.txt has lines like:
Adam Bor, 34, India
Kerry Miller, 22, USA
then this will produce:
Adam Bor, India
Kerry Miller, USA
There is much more you can do with awk but this is a very common
use.
2) Concepts: Pipes, redirection and backtickThey are not really
commands but they are very important concepts.
pipes (|) send the output (stdout) of one program to the input
(stdin) of another program. grep "hello" file.txt | wc -l
finds the lines with the string hello in file.txt and then
counts the lines.The output of the grep command is used as input
for the wc command. You can concatinate as many commands as you
like in that way (within reasonable limits).
redirection: writes the output of a command to a file or appends
data to a file> writes output to a file and overwrites the old
file in case it exists>> appends data to a file (or creates a
new one if it doesn't exist already but it never overwrites
anything).
BacktickThe output of a command can be used as command line
arguments (not stdin as above, command line arguments are any
strings that you specify behind the command such as file names and
options) for another command. You can as well use it to assign the
output of a command to a variable. The command
find . -mtime -1 -type f -print
finds all files that have been modified within the last 24 hours
(-mtime -2 would be 48 hours). If you want to pack all these files
into a tar archive (file.tar) the syntax for tar would be:
tar xvf file.tar infile1 infile2 ...
Instead of typing it all in you can combine the two commands
(find and tar) using backticks. Tar will then pack all the files
that find has printed:
#!/bin/sh
# The ticks are backticks (`) not normal quotes ('):
tar -zcvf lastmod.tar.gz `find . -mtime -1 -type f -print`
3) Control structuresThe "if" statement tests if the condition
is true (exit status is 0, success). If it is the "then" part gets
executed:
if ....; then
....
elif ....; then
....
else
....
fi
Most of the time a very special command called test is used
inside if-statements. It can be used to compare strings or test if
a file exists, is readable etc... The "test" command is written as
square brackets " [ ] ". Note that space is significant here: Make
sure that you always have space around the brackets. Examples:
[ -f "somefile" ] : Test if somefile is a file.
[ -x "/bin/ls" ] : Test if /bin/ls exists and is executable.
[ -n "$var" ] : Test if the variable $var contains something
[ "$a" = "$b" ] : Test if the variables "$a" and "$b" are
equal
Run the command "man test" and you get a long list of all kinds
of test operators for comparisons and files. Using this in a shell
script is straight forward:
#!/bin/sh
if [ "$SHELL" = "/bin/bash" ]; then
echo "your login shell is the bash (bourne again shell)"
else
echo "your login shell is not bash but $SHELL"
fi
The variable $SHELL contains the name of the login shell and
this is what we are testing here by comparing it against the string
"/bin/bash"
Shortcut operatorsPeople familiar with C will welcome the
following expression:
[ -f "/etc/shadow" ] && echo "This computer uses shadow
passwors"
The && can be used as a short if-statement. The right
side gets executed if the left is true. You can read this as AND.
Thus the example is: "The file /etc/shadow exists AND the command
echo is executed". The OR operator (||) is available as well. Here
is an example:
#!/bin/sh
mailfolder=/var/spool/mail/james
[ -r "$mailfolder" ] || { echo "Can not read $mailfolder" ; exit
1; }
echo "$mailfolder has mail from:"
grep "^From " $mailfolder
The script tests first if it can read a given mailfolder. If yes
then it prints the "From" lines in the folder. If it cannot read
the file $mailfolder then the OR operator takes effect. In plain
English you read this code as "Mailfolder readable or exit
program". The problem here is that you must have exactly one
command behind the OR but we need two: -print an error message
-exit the program To handle them as one command we can group them
together in an anonymous function using curly braces. Functions in
general are explained further down. You can do everything without
the ANDs and ORs using just if-statements but sometimes the
shortcuts AND and OR are just more convenient.
The case statement can be used to match (using shell wildcards
such as * and ?) a given string against a number of
possibilities.
case ... in
...) do something here;;
esac
Let's look at an example. The command file can test what kind of
filetype a given file is:
file lf.gz
returns:
lf.gz: gzip compressed data, deflated, original filename,
last modified: Mon Aug 27 23:09:18 2001, os: Unix
We use this now to write a script called smartzip that can
uncompress bzip2, gzip and zip compressed files automatically :
#!/bin/sh
ftype=`file "$1"`
case "$ftype" in
"$1: Zip archive"*)
unzip "$1" ;;
"$1: gzip compressed"*)
gunzip "$1" ;;
"$1: bzip2 compressed"*)
bunzip2 "$1" ;;
*) error "File $1 can not be uncompressed with smartzip";;
esac
Here you notice that we use a new special variable called $1.
This variable contains the first argument given to a program. Say
we run smartzip articles.zip then $1 will contain the string
articles.zip
The select statement is a bash specific extension and is very
good for interactive use. The user can select a choice from a list
of different values:
select var in ... ; do
break
done
.... now $var can be used ....
Here is an example:
#!/bin/sh
echo "What is your favourite OS?"
select var in "Linux" "Gnu Hurd" "Free BSD" "Other"; do
break
done
echo "You have selected $var"
Here is what the script does:
What is your favourite OS?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#? 1
You have selected Linux
In the shell you have the following loop statements
available:
while ...; do
....
done
The while-loop will run while the expression that we test for is
true. The keyword "break" can be used to leave the loop at any
point in time. With the keyword "continue" the loop continues with
the next iteration and skips the rest of the loop body.
The for-loop takes a list of strings (strings separated by
space) and assigns them to a variable:
for var in ....; do
....
done
The following will e.g. print the letters A to C on the
screen:
#!/bin/sh
for var in A B C ; do
echo "var is $var"
done
A more useful example script, called showrpm, prints a summary
of the content of a number of RPM-packages:
#!/bin/sh
# list a content summary of a number of RPM packages
# USAGE: showrpm rpmfile1 rpmfile2 ...
# EXAMPLE: showrpm /cdrom/RedHat/RPMS/*.rpm
for rpmpackage in $*; do
if [ -r "$rpmpackage" ];then
echo "=============== $rpmpackage =============="
rpm -qi -p $rpmpackage
else
echo "ERROR: cannot read file $rpmpackage"
fi
done
Above you can see the next special variable, $* which contains
all the command line arguments. If you run showrpm openssh.rpm
w3m.rpm webgrep.rpm then $* contains the 3 strings openssh.rpm,
w3m.rpm and webgrep.rpm.
The GNU bash knows until-loops as well but generally while and
for loops are sufficient.
QuotingBefore passing any arguments to a program the shell tries
to expand wildcards and variables. To expand means that the
wildcard (e.g. *) is replaced by the appropriate file names or that
a variable is replaced by its value. To change this behaviour you
can use quotes: Let's say we have a number of files in the current
directory. Two of them are jpg-files, mail.jpg and tux.jpg.
#!/bin/sh
echo *.jpg
This will print "mail.jpg tux.jpg".Quotes (single and double)
will prevent this wildcard expansion:
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
This will print "*.jpg" twice. Single quotes are most strict.
They prevent even variable expansion. Double quotes prevent
wildcard expansion but allow variable expansion:
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'
This will print:
/bin/bash
/bin/bash
$SHELL
Finally there is the possibility to take the special meaning of
any single character away by preceeding it with a backslash:
echo \*.jpg
echo \$SHELL
This will print:
*.jpg
$SHELL
Here documentsHere documents are a nice way to send several
lines of text to a command. It is quite useful to write a help text
in a script without having to put echo in front of each line. A
"Here document" starts with
