Introduction to Perl Functions

Offer Kaye
YAPC::Israel::2005

Creating Functions

• Use the sub keyword to create a new function (subroutine):

  sub say_hi {
     print "Hello, world!\n";
  }
  

• "A subroutine (function, procedure, or subprogram) is a sequence of code which performs a specific task, as part of a larger program, and is grouped as one, or more, statement blocks." [Wikipedia]
• When given a name, the function can then be reused, just as you can reuse a piece of data by saving it as a named variable.
• Functions are used to wrap related parts of code together, to create re-usable software components and to give structure to your code.

Calling Functions

• You can call functions before you declare them by using parenthesis after, or an "&" sign before, the name of the function.
• If you call a function after it is declared, you can omit the parenthesis and the ampersand:

  # function is called
  say_hi();
  # function is called again
  &say_hi;
  # ... lots of code ...
  # function is declared
  sub say_hi {
     print "Hello, world!\n";
  }
  # function is called a third time
  say_hi;
  

---

Passing Parameters

• A function receives its parameters through the @_ special array.
• The parameters are received in the order that they were passed.
• Lists are flattened:

  my @array1 = (1 , 2 , 3);
  my @array2 = (4 , 42);
  print_sum(@array1 , @array2);
  # inside print_sum, @_ = (1 , 2 , 3 , 4 , 42)
  # This is the same thing that happens when you write:
  my @array3 = (@array1, @array2);
  

---

Passing Parameters - Cont'd

• Inside functions, shift operates by default on the @_ array.
• Note that the @_ array is an alias, not a copy, of the input parameters.
• That's why it's a good idea to create a copy of the input parameters and work on them, to avoid unintended side-effects:

  sub func1 {
     my @params = @_; # create a copy of the input parameters
  }
  sub func2 {
     my $param1 = $_[0]; # an example of copying the input 
     my $param2 = $_[1]; #   parameters one by one.
  }
  sub func3 {
     my $param1 = shift; # shift works by default on @_
     my $param2 = shift; # 
  }
  

---

Acting Directly on Passed Parameters

• Here is an exmaple of how you can directly modify the parameters passed to a function:

  sub increment_all {
     for (@_) {
        ++$_;
     }
  }
  
  my @nums = qw(3 8 -2 41);
  print "Orig numbers = @nums\n";
  increment_all(@nums);
  print "New numbers  = @nums\n";
  

---

Return Values

• A function returns the result of the last statement executed in the function.
• Or you can use the return statement:

  sub sum {
     my $sum;
     for (@_) {
        $sum += $_;
     }
     return $sum;
  }
  my $answer = sum(7,13,22);
  

---

Return Values - Cont'd

• Just as for parameters, returned lists will be flattened into one list:

  sub cool_sub {
     # function code...
     return @array1, @array2;
  }
  # silly mistake:
  my (@big_array, @empty_array) = cool_sub();
  

---

References and Functions

• You can use references to solve the problem of passing multiple arrays (or hashes):

  my @array1 = qw(a b 5);
  my @array2 = qw(a b 6);
  if (compare_arrays(\@array1,\@array2)) {
     print "Same!\n";
  } else {
     print "Different!\n";
  }
  sub compare_arrays {
     my %count;
     my @first_array  = @{$_[0]};
     my @second_array = @{$_[1]};
     for (@first_array,@second_array){++$count{$_}}
     for (values %count) {return 0 if ($_ ne 2)}
     return 1;
  }
  

---

References and Functions - Cont'd

• The syntax gets just a little messier when returning references:

  sub some_func {
     my (@array1, @array2);
     # func code...
     return \@array1, \@array2;
  }
  my ($a1ref, $a2ref) = some_func();
  my @a1 = @{$a1ref};
  my @a2 = @{$a2ref};
  

---

Passing Functions

• Functions, too, can be passed as parameters to a function.
• For example, given that "infile" holds an anonymous function:

  sub {
     my $arg = shift;
     $arg =~ s/,/_/;
     return $arg;
  };
  

• Then the following code passes the contents of "infile" as a code ref to another function:

  my $input = eval `cat infile`;
  my @input_args = ("a,a\n" , ",b\n" , "c,d\n");
  my @transformed_args = simple_transform(\@input_args,$input);
  print for @transformed_args;
  sub simple_transform {
     my @args = @{$_[0]};
     my $transform = $_[1];
     my @output;
     for my $arg (@args) {
        push @output, &$transform($arg);
     }
     return @output;
  }
  

---

Passing Functions - Cont'd

• A more common example is the use of functions to handle input arguments:

  use Getopt::Long;
  my $data    = "file.dat";
  my $length  = 24;
  my $verbose = 0;
  my $help = 0;
  my $result = GetOptions (
     "length=i" => \$length,
     "file=s"   => \$data,
     "verbose"  => \$verbose,
     "quiet"    => sub { $verbose = 0 },
     "help|man" => \&help,
  );
  sub help {die "Usage stagement...\n"}
  

---

Resources

• perldoc perlsub is the authoritative reference about Perl subroutines.
• perldoc perlfunc will help you with info about Perl's builtin functions.
• perldoc -f <function> will help you with info about a specific builtin function.
• If you're looking for a good tutorial in Hebrew about functions, read the beginning of chapter 5 of Semuel Fomberg's excellent Perl Tutorial.
• Chapter 4, "Subroutines", from "Learning Perl" 3^rd edition, is available online from O'Reilly and is a good English tutorial about functions.

---

Thank you



Offer Kaye. YAPC::Israel::2005.
Slides automatically generated by tmpl2slides.pl. Last updated on Wed Feb 9 23:11:09 2005