

<ul><h2><a name=41> * SUBROUTINES * </a></h2></ul>


   Like any good programming langauge Perl allows the user to define
   their own functions, called subroutines. They may be placed anywhere
   in your program but it's probably best to put them all at the
   beginning or all at the end. A subroutine has the form

sub mysubroutine
{
        print "Not a very interesting routine\n";
        print "This does the same thing every time\n";
}

   regardless of any parameters that we may want to pass to it. All of
   the following will work to call this subroutine. Notice that a
   subroutine is called with an & character in front of the name:

&mysubroutine;          # Call the subroutine
&mysubroutine($_);      # Call it with a parameter
&mysubroutine(1+2, $_); # Call it with two parameters


<ul><h2><a name=42>Parameters</a></h2></ul>

   In the above case the parameters are acceptable but ignored. When the
   subroutine is called any parameters are passed as a list in the
   special @_ list array variable. This variable has absolutely nothing
   to do with the $_ scalar variable. The following subroutine merely
   prints out the list that it was called with. It is followed by a
   couple of examples of its use.

sub printargs
{
        print "@_\n";
}

&printargs("perly", "king");    # Example prints "perly king"
&printargs("frog", "and", "toad"); # Prints "frog and toad"

   Just like any other list array the individual elements of @_ can be
   accessed with the square bracket notation:

sub printfirsttwo
{
        print "Your first argument was $_[0]\n";
        print "and $_[1] was your second\n";
}

   Again it should be stressed that the indexed scalars $_[0] and $_[1]
   and so on have nothing to with the scalar $_ which can also be used
   without fear of a clash.


<ul><h2><a name=43>Returning values</a></h2></ul>

   Result of a subroutine is always the last thing evaluated. This
   subroutine returns the maximum of two input parameters. An example of
   its use follows.

sub maximum
{
        if ($_[0] > $_[1])
        {
                $_[0];
        }
        else
        {
                $_[1];
        }
}

$biggest = &maximise(37, 24);   # Now $biggest is 37

   The &printfirsttwo subroutine above also returns a value, in this case
   1. This is because the last thing that subroutine did was a print
   statement and the result of a successful print statement is always 1.


<ul><h2><a name=44>Local variables</a></h2></ul>

   The @_ variable is local to the current subroutine, and so of course
   are $_[0], $_[1], $_[2], and so on. Other variables can be made local
   too, and this is useful if we want to start altering the input
   parameters. The following subroutine tests to see if one string is
   inside another, spaces not withstanding. An example follows.

sub inside
{
        local($a, $b);                  # Make local variables
        ($a, $b) = ($_[0], $_[1]);      # Assign values
        $a =~ s/ //g;                   # Strip spaces from
        $b =~ s/ //g;                   #   local variables
        ($a =~ /$b/ || $b =~ /$a/);     # Is $b inside $a
                                        #   or $a inside $b?
}

&inside("lemon", "dole money");         # true

   In fact, it can even be tidied up by replacing the first two lines
   with

local($a, $b) = ($_[0], $_[1]);

<hr noshade><center>Last-modified: Wed, 26-Mar-97 00:11:17 GMT
</center>