http://www.bashguru.com/2009/11/how-to-pass-argumentsto-shell-script.

html

Sunday, November 15, 2009

How to Pass Arguments to Shell Script
Like UNIX commands, shell scripts also accept arguments from the command
line.
They can, therefore, run non interactively and be used with redirection
and
pipelines.

Positional Parameters:
Arguments are passed from the command line into a shell program using the
positional parameters $1 through to $9. Each parameter corresponds to the
position of the argument on the command line.
The first argument is read by the shell into the parameter $1, The second
argument into $2, and so on. After $9, the arguments must be enclosed in
brackets, for example, ${10}, ${11}, ${12}.Some shells doesn't support
this
method. In that case, to refer to parameters with numbers greater than 9,
use
the shift command; this shifts the parameter list to the left. $1 is
lost,while
$2 becomes $1, $3 becomes $2, and so on. The inaccessible tenth parameter
becomes $9 and can then be referred to.
Example:

#!/bin/bash
# Call this script with at least 3 parameters, for example
# sh scriptname 1 2 3
echo "first parameter is $1"
echo "Second parameter is $2"
echo "Third parameter is $3"
exit 0

Output:
[root@localhost ~]# sh parameters.sh 47 9 34
first parameter is 47
Second parameter is 9
Third parameter is 34
[root@localhost ~]# sh parameters.sh 4 8 3
first parameter is 4
Second parameter is 8
Third parameter is 3
In addition to these positional parameters, there are a few other special
parameters used by shell.Their significance is noted bellow.
$* - It stores the complete set of positional parameters as a single
string.
$@ - Same as $*, But there is subtle difference when enclosed in double
quotes.
$# - It is set to the number of arguments specified.This lets you design
scripts
that check whether the right number of arguments have been entered.
$0 - Refers to the name of the script itself.

Setting Values of Positional Parameters

You can't technically call positional parameters as shell variables
because all
variable names start with a letter. For instance you can't assign values
to $1,
$2.. etc. $1=100 or $2=venu is simply not done. There is one more way to
assign
values to the positional parameters, using the set command.
$ set Helping hands are holier than praying lips
The above command sets the value $1 with Helping , $2 with hands and
so on.
To verify, use echo statement to display their values.
$ echo $1 $2 $3 $4 $5 $6 $7
Helping hands are holier than praying lips
You can simply use $* or $@

$ echo $*
Helping hands are holier than praying lips
$ echo $@
Helping hands are holier than praying lips

Using Shift on Positional Parameters

We have used set command to set upto 9 words. But we can use it for more.
$ set A friend who helps when one is in trouble is a real friend
$ echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11
A friend who helps when one is in trouble A0 A1
Observe that last two words in the output. These occurred in the output
because
at a time we can access only 9 positional parameters. When we tried to
refer to
$10 it was interpreted by the shell as if you wanted to out put the value
of $1
and a 0. Hence we got A0 in the output.
Does that mean the words following the ninth word have been lost? No. If
not,
then where have they gone?. They are very much there, safe with the shell
But to
reach them we must do the following.
$shift 4
$ echo $1 $2 $3 $4 $5 $6 $7 $8 $9
when one is in trouble is a real friend
Now where have the first seven words gone? They have been shifted out.The
first
four words lost for ever, as we did not take the precaution to store them
elsewhere. What should we have done is:
$ set A friend who helps when one is in trouble is a real friend
$ a=$1
$ b=$2
$ c=$3

$ d=$4
$ shift 4
$ echo $a $b $c $d $1 $2 $3 $4 $5 $6 $7 $8 $9
A friend who helps when one is in trouble is a real friend
Note:In the Korn and bash shells you can refer directly to arguments
where
n is greater than 9 using braces. For example, to refer to the 57th
positional
parameter, use the notation ${57}.some shells may not support this method.
$ set A friend who helps when one is in trouble is a real friend
$ echo ${12}
real
$ echo ${13}
friend
Bracket notation for positional parameters leads to a fairly simple way
of
referencing the last argument passed to a script on the command line.
$ echo ${!#}
friend

$* and $@
Let us look at the subtle difference between $* and $@.
First create three files
cat > fileA
I LOVE INDIA
Ctrl+d

fileA, fileB, file temp

cat > fileB

HELLO WORLD
Ctrl+d
cat > temp\ file
This file name contains blank space
Ctrl+d

Example:

#!/bin/bash
# Usage: sh arguments.sh fileA fileB temp\ file
echo -e "\033[1mDisplay files content using \$* \033[0m"
cat $*
echo -e "\033[1mDisplay files content using \$@ \033[0m"
cat $@
exit 0
Run the script with file names as arguments.
Output:
[root@localhost ~]# sh arguments.sh fileA fileB temp\ file
Display files content using $*
I LOVE INDIA
HELLO WORLD
cat: temp: No such file or directory
cat: file: No such file or directory
Display files content using $@
I LOVE INDIA
HELLO WORLD
cat: temp: No such file or directory
cat: file: No such file or directory
So there is no difference between cat $* and cat $@.
Modify arguments.sh script as
#!/bin/bash
# Usage: sh arguments.sh fileA fileB temp\ file
echo -e "\033[1mDisplay files content using \"\$*\" \033[0m"
cat "$*"
echo -e "\033[1mDisplay files content

using \"\$@\" \033[0m"

cat "$@"
exit 0
Now again run the script with file names as arguments.
Output:
[root@localhost ~]# sh arguments.sh fileA fileB temp\ file
Display files content using "$*"
cat: fileA fileB temp file: No such file or directory

Display files content using "$@"

I LOVE INDIA
HELLO WORLD
This file name contain blank space
Now there is a difference, the two cat commands would become:
cat fileA fileB temp file
cat fileA fileB 'temp file'
On execution, the first of these commands would give an error since there
does
not exist a file with the name fileA fileB temp file. As against this,
the
second cat command would display the contents of the files fileA, fileB
and
temp file. So what you observed ,when not enclosed within "double
quotes"
$* and $@ behaves exactly similarly, and when enclosed in "double quotes"
there
is a subtle difference.

http://faculty.salina.k-state.edu/tim/unix_sg/bash/math.html

Kansas State University at Salina

Introduction to Unix

Math in Shell Scripts

Shell script variables are by default treated as strings, not numbers, which adds some
complexity to doing math in shell script. To keep with script programming paradigm and allow
for better math support, languages such Perl or Python would be better suited when math is
desired. However, it is possible to do math with shell script. In fact, over the years, multiple
facilities have been added to Unix to support working with numbers.
Note

As we will see, some of the commands used to facilitate math are a little picky about things like
spaces around operators.
declare

You may recall, that when the text book introduced the declare statement, it said that it is not
always needed. So what do you get by declaring a variable to be an integer? The following
example illustrates that a declared integer is not treated as a string.
$ n=6/3
$ echo $n
6/3
$ declare -i n
$ n=6/3
$ echo $n
2

When you do not need the declare statement is when you will use a program or built-in
command to evaluate a math statement.
expr

An old Unix program that can evaluate math is expr. expr became popular in the days of the
Bourne Shell, which did not support math. With Bash and Korn shell, it is generally not needed.
Since it is a command, command substitution is needed. We are still treating the variable as a
string. As you can see, it is picky about spaces.
$ z=5
$ z=`expr $z+1`
---- Need spaces around + sign.
$ echo $z
5+1
$ z=`expr $z + 1`
$ echo $z
6

let

A Bash and Korn shell built-in command for math is let. As you can see, it is also a little picky
about spaces, but it wants the opposite of what expr wanted. let also relaxes the normal rule of
needing a $ in front of variables to be read.
$ let z=5
$ echo $z
5
$ let z=$z+1
$ echo $z
6
$ let z=$z + 1
# --- Spaces around + sign are bad with let
-bash: let: +: syntax error: operand expected (error token is "+")
$let z=z+1

# --- look Mom, no $ to read a variable.

$echo $z
7

An alternate form of let is to wrap the whole statement in double parenthesis. This form is more
forgiving about spaces.
$ ((e=5))
$ echo $e
5
$ (( e = e + 3 ))
$ echo $e
8
$ (( e=e+4 )) # -- spaces or no spaces, it doesn't matter
$ echo $e
12

bc

What if you want to do math with floating point numbers or you have some fairly complicated
math to do? Neither form of let, supports floating point numbers. The bc command is needed.
But you have to treat the variables as strings.
Here is what happens when we try to do floating point math with the shell:
$let r=3.5
-bash: let: r=3.5: syntax error in expression (error token is ".5")
$(( r = 3.5 ))
-bash: ((: r = 3.5 : syntax error in expression (error token is ".5 ")
bc

An arbitrary precision calculator language. bc may either be run interactively, or as a

shell script command. In interactive mode, type cntrl-d (EOF) to exit.
SYNOPSIS
bc
bc EXPRESSION
Here are some examples:
$ bc
bc 1.06
Copyright 1991-1994, 1997, 1998, 2000 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
3 + 2
5
obase=2
12
1100
<cntrl-d>

Remember to type cntrl-d (EOF) to exit from interactive mode.

$r=3.5
$s=`echo "$r + 2.2" | bc`
$echo $s
5.7
$ z = `echo $z + 1 | bc`
-bash: z: command not found
# -- spaces around = sign are bad
(shell thing, not bc)
$
$
8
$
$
9

z=`echo "$z + 1" | bc`

echo $z
z=`echo "$z+1" | bc`
echo $z

-- spaces don't matter with bc

Numeric Boolean expressions:

Note that the arithmetic tests shown in Figure 6-27, page 223, must be used with the (( )) form of
let. Otherwise, according to the test man page, the following numeric tests are used.
INTEGER1 -eq INTEGER2
INTEGER1 is equal to INTEGER2
INTEGER1 -ge INTEGER2
INTEGER1 is greater than or equal to INTEGER2
INTEGER1 -gt INTEGER2
INTEGER1 is greater than INTEGER2
INTEGER1 -le INTEGER2
INTEGER1 is less than or equal to INTEGER2
INTEGER1 -lt INTEGER2
INTEGER1 is less than INTEGER2
INTEGER1 -ne INTEGER2
INTEGER1 is not equal to INTEGER2

That is to say, the following two if statements are identical:

if (( x < y )); then
statements
fi

if [ $x -lt $y ]; then
statements
fi

And for logical expressions using floating point math, the bc command returns 1 for logical true
expressions and 0 for false expressions, thus testing for result of 1 achieves a logical expression:
if [ $( echo "$t < 3.4" | bc ) -eq 1 ]; then
statements
fi