There are a set of variables which are set for you already, and most of
these cannot have values assigned to them.
These can contain useful information, which can be used by the script
to know about the environment in which it is running.
The first set of variables we will look at are $0 .. $9
and $#
.
The variable $0
is the basename of the program as it
was called.
$1 .. $9
are the first 9 additional parameters
the script was called with.
The variable $@
is all parameters $1 .. whatever
.
The variable $*
, is similar, but does not preserve any whitespace, and
quoting, so "File with spaces" becomes "File" "with" "spaces". This is similar to
the echo
stuff we looked at in A First Script.
As a general rule, use $@
and avoid $*
.
$#
is the number of parameters
the script was called with.
Let's take an example script:
#!/bin/sh echo "I was called with $# parameters" echo "My name is $0" echo "My first parameter is $1" echo "My second parameter is $2" echo "All parameters are $@"
Let's look at running this code and see the output:
$ /home/steve/var3.sh I was called with 0 parameters My name is /home/steve/var3.sh My first parameter is My second parameter is All parameters are $ $ ./var3.sh hello world earth I was called with 3 parameters My name is ./var3.sh My first parameter is hello My second parameter is world All parameters are hello world earthNote that the value of
$0
changes depending on how the
script was called. The external utility basename
can help tidy
this up:
echo "My name is `basename $0`"
$#
and $1 .. $9
are set
automatically by the shell.
shift
command; look at the script below:
#!/bin/sh while [ "$#" -gt "0" ] do echo "\$1 is $1" shift done
shift
until $#
is down
to zero, at which point the list is empty.
Another special variable is $?
. This contains the exit value
of the last run command. So the code:
#!/bin/sh /usr/local/bin/my-command if [ "$?" -ne "0" ]; then echo "Sorry, we had a problem there!" fi
will attempt to run /usr/local/bin/my-command
which should
exit with a value of zero if all went well, or a nonzero value on failure.
We can then handle this by checking the value of $?
after
calling the command. This helps make scripts robust and more intelligent.
Well-behaved applications should return zero on success. Hence the quote:
One of the main causes of the fall of the Roman Empire was that, lacking zero, they had no way to indicate successful termination of their C Programs. (Robert Firth)
The other two main variables set for you by the environment are $$
and $!
. These are both process numbers.
The $$
variable is the PID (Process IDentifier) of the currently running shell.
This can be useful for creating temporary files, such as
/tmp/my-script.$$
which is useful if many instances of
the script could be run at the same time, and they all need their own
temporary files.
The $!
variable is the PID of the last run background process.
This is useful to keep track of the process as it gets on with its job.
Another interesting variable is IFS
. This is the Internal
Field Separator. The default value is SPACE TAB NEWLINE
,
but if you are changing it, it's easier to take a copy, as shown:
#!/bin/sh old_IFS="$IFS" IFS=: echo "Please input some data separated by colons ..." read x y z IFS=$old_IFS echo "x is $x y is $y z is $z"
This script runs like this:
$ ./ifs.sh Please input some data separated by colons ... hello:how are you:today x is hello y is how are you z is today
Note that if you enter: "hello:how are you:today:my:friend" then the output would be:
$ ./ifs.sh Please input some data separated by colons ... hello:how are you:today:my:friend x is hello y is how are you z is today:my:friend
It is important when dealing with IFS in particular (but any variable not entirely under your control) to realise
that it could contain spaces, newlines and other "uncontrollable" characters. It is therefore a very good idea
to use double-quotes around it, ie: old_IFS="$IFS"
instead of old_IFS=$IFS
.
My Shell Scripting books, available in Paperback and eBook formats. This tutorial is more of a general introduction to Shell Scripting, the longer Shell Scripting: Expert Recipes for Linux, Bash and more book covers every aspect of Bash in detail.
Shell Scripting Tutorial is this tutorial, in 88-page Paperback and eBook formats. Convenient to read on the go, and in paperback format good to keep by your desk as an ever-present companion. Also available in PDF form from Gumroad:Get this tutorial as a PDF | Shell Scripting: Expert Recipes for Linux, Bash and more is my 564-page book on Shell Scripting. The first half covers all of the features of the shell in every detail; the second half has real-world shell scripts, organised by topic, along with detailed discussion of each script. |