Tips on good shell programming practices

Once upon a time, Unix had only one shell, the Bourne shell, and when a
script was written, the shell read the script and executed the
commands. Then another shell appeared, and another. Each shell had its
own syntax and some, like the C shell, were very different from the
original. This meant that if a script took advantage of the features of
one shell or another, it had to be run using that shell. Instead of
typing:

doit

The user had to know to type:

/bin/ksh doit

or:

/bin/csh doit

To remedy this, a clever change was made to the Unix kernel -- now a
script can be written beginning with a hash-bang (#!) combination on
the first line, followed by a shell that executes the script. As an example, take a look at the following script, named doit:

#! /bin/ksh
#
# do some script here
#

In this example, the kernel reads in the script doit, sees the hash-bang, and continues reading the rest of the line, where it finds /bin/ksh.
The kernel then starts the Korn shell with doit as an argument and
feeds it the script, as if the following command had been issued:

/bin/ksh doit

When /bin/ksh begins reading in the script, it sees the hash-bang in the first line as a comment (because it starts with
a hash) and ignores it. To be run, the full path to the shell is required, as the
kernel does not search your PATH variable. The hash-bang handler in the
kernel does more than just run an alternate shell; it actually takes
the argument following the hash-bang and uses it as a command, then
adds the name of the file as an argument to that command.

You could start a Perl script named doperl by using the hash-bang:

#! /bin/perl

# do some perl script here

If you begin by typing doperl, the kernel spots the hash-bang,
extracts the /bin/perl command, then runs it as if you had typed:

Sign up for ITworld's Daily newsletter
Follow ITworld on Twitter @IT_world

• Email
• Print
• Share
  • Slashdot
  • Digg
  • Stumble
  • Reddit
  • Newsvine