COP 3013 (Perl) Lecture 16

Subroutine Arguments and Parameters

• The passing of arguments is critical to the useful functioning of subroutines.

• Arguments are passed to a subroutine upon invocation by placing them within the parentheses following the subroutine call.

• In the context of the called subroutine, the arguments are stored within the function in the special array variable @_

• Individual arguments can be picked out of the @_ array by the subroutine itself.

• Example:

  $a="hello";
  test_args($a, "world");
  
  sub test_args{
    my ($arg1, $arg2) = @_;
    print "The first two args are $arg1 and $ar2\n";
  }
  

• Note the return value of the function is not used, but that's ok. Perl doesn't mind.

• If you try to get at an argument that is not given, just as with any other array reference, you get undef. And if you give more arguments to a subroutine than it needs, the extra arguments are ignored.
  

• The @_ array is statically or lexically scoped meaning that
  1. The variable binding is only available from within the code that is lexically in the block in which it was declared.

  2. Each invocation of a subroutine gets its own new binding for the lexically scoped variable. (Two different simultaneous invocations will have different versions of the variable.

  3. The binding disappears when the code from the function can no longer be executed. (For the extremely pedantic this is not when the subroutine returns. You can look at an example if you dare.)

• As we discussed before, other lexically scoped variables are created with the use of the my keyword. By the way, be careful becasue my is an executable statement!

  $value = "hello";
  
  my_value();
  print " global value = $value \n";
  
  sub my_value{
    print "global value from in function = $value\n";
    my $value = 2;
    print "my value is $value";
  }
  

• output:

  global value from in function = hello
  my value is 2
  global value = hello
  
  
  

• Dynamically scoped variables (don't ever create these unless you really know you need to) can be created with the local keyword. Dynamically scoped variables are implemented as follows:
  1. The binding of the current package variable of the same name is stored in the scratchpad for the current subroutine.

  2. When the subroutine exits, the package variable's binding is restored from the scratchpad.

• Dynamic variables are visible to subroutines called from within a subroutine
  

  $value = "original"';
         
  tellme();
  spoof();
  tellme();
  
  sub spoof{
    local $value = "temporary";
    tellme();
  }
  
  sub tellme(){
    print "Current value is $value\n";
  }
  

  output:

  Current value is original
  Current value is temporary
  Current value is original
  

• I've already told you never to use local. If you try to mix local and my, you can get yourself in trouble. I have an example that shows that you cannot shadow (hide) a my variable with a local binding. I have a second example that shows you can hide a local binding with a my variable.