Defining Your Own Functions

Functions, aka subroutines are blocks of code that you can call in different places and contexts. Subroutines can take arguments, and can return results. Perl has many functions already built in. You can also define your own.

Example: Return the length of the hypotenuse of a right triangle

  
  sub hypotenuse {
     my ($a,$b) = @_;
     return sqrt($a**2 + $b**2);
  }

  sub E {
      return 2.71828182845905;
  }

  $x = hypotenuse(3,4);
  # yields 5

  $x = hypotenuse(9,12);
  # yields 15  

Unlike built-in functions, you need to use parentheses with user-defined functions, even if there are no arguments to pass:

$x = hypotenuse(3,4);
$y = E();

Anatomy of a Subroutine

The structure of a subroutine is shown here:

sub subroutine name { my ($arg1,$arg2,...) = @_; # copy args into local variables (optional) Any code you like return function result # return subroutine result (optional) }

• The subroutine name is up to you to choose. To preserve your sanity, don't reuse a name that Perl already uses (like "length").
• Any arguments that you pass to the subroutine will appear in the automatic array @_. You can index directly into it ($_[0], $_[1], etc.) but this is ugly, so most people copy @_ into a list of local variables.
• You can return a scalar or a list as the subroutine result with the return statement. You can have several return statements; the subroutine exits as soon as it executes any of them.
• If no return statement, then the subroutine returns its last expression was.

Using shift to Get Arguments

If you have only a few arguments, you can use shift to obtain the arguments, one at a time:

# same as the previous example sub hypotenuse { my $a = shift; my $b = shift; return sqrt($a**2 + $b**2); }

"my" and Local Variables

Any variables that you use in a subroutine should be made local with the my operator. This avoids accidentally overwriting similarly-named variables in the main program.

Variables made local with my only exist within a block (curly braces). The subroutine body is a block, so the local variables only exist within the body of the subroutine.

You can make scalars, arrays and hashes local. If you apply my() to a list, it makes each member of the list local.

{ # start a block my $scalar; # $scalar is local my @array; # now @array is local my %hash; # %hash is local # same thing, but in one swell foop my ($scalar,@array,%hash); }

Previous

Contents

Next