Next: About this document ... Up: perl1st Previous: File I/O

Subsections

Subroutines (functions)

Here, we'll see how to create custom subroutines.
- You have seen built-in functions (subroutines): chomp, print, etc.
- A subroutine is an independent section of code, which performs a specific task.
  Examples:
  - Find the maximum values in an array.
  - Calculate the average of an array.
  - Read in a FASTA file, and assign the sequence data to an array.
- Subroutines can be re-used within a single program, or re-use to make a new program.
- Easier to read the code (and helps debugging).

Basic form

Definition: The following is the basic form of the subroutine definition
```
sub function_name {
  statement;
   :
   :
}
```

Example

#!/usr/bin/perl -w

my $a = 2;
my $sum = &Add(10, $a);
print "10 + $a is $sum\n";

exit;

sub Add {
  my ($num1, $num2) = @_;
  my $result = $num1 + $num2;
  return $result;
}

To invoke (call) a subroutine:
```
  &function_name(argument1, argemuent2, ...);

    or

  function_name(argument1, argemuent2, ...);
```
- When a subroutine is invoked, the process jumps to the named subroutine, and execute the statements in there.
- Then the process will come back to the original place where the subroutine was invoked.
- The ampersand (&), indicating the subroutine (c.f. $ indicates scalar variable), is optional (I usually don't use it).
Arguments to a subroutine is stored in a special array variable @_.
- Arguments are the way to communicate with a subroutine.
- If a variable is used as the argument, the value is passed to the subroutine.
- Some subroutines may not need any arguments. Just keep the argument empty:
```
func1();
```
A subroutine may or may not return a value.
The returned value can be assigned to a variable.
But returning values is optional; some subroutines do not require a returning value.

More complicated Example: count base

#!/usr/bin/perl -w
my $seq = "ATGCAA";
my $numA = CntBase($seq, "A");
print "Num of Base A $numA\n";
exit;

sub CntBase {
  my $seq = $_[0];
  my $base = $_[1];
  my @baseArray = split (//, $seq);
  my $cntr = 0;
  foreach my $b (@baseArray) {
    if ($b eq $base) {
      $cntr++;
    }
  }
  return $cntr;
}

Note the alternative way to receive the arguments in a function:
```
  my $seq = $_[0];
  my $base = $_[1];
```
Another method to receive the arguments:
```
  my $seq = shift;
  my $base = shift;
```
$element = shift(@array)
The first element of @array gets assigned to $element, and the 1st element gets removed from @array.
```
my @a = 10..13;           # @a = (10, 11, 12, 13)
my $element = shift(@a);  # $element = 10
                          # @a = (11,12,13)
```
If no argument is given to shift, it operates on the default array @_. That's why my $seq = shift; works.

You can return any type of variables (scalar, array, hash etc)

sub BaseComposition {
  my $seq = shift;
  my @baseArray = split (//, $seq);
  my %cntResult = (
    "A" => 0,
    "T" => 0,
    "G" => 0,
    "C" => 0
  );

  foreach my $b (@baseArray) {
    $cntResult{$b}++;
  }
  return %cntResult;
}

You can put the subroutine definition anywhere.
Exercise:
1. Write a function which receives an array of numbers, and return the sum of all numbers.
2. Write a function which receives a scalar variable containing a DNA sequence. Then replace the lower case nucleotides (atgc) with 'N' and return a scalar variable which contains only ATGCN. Hint: $seqString = join ('', @baseArr); can be used to convert an array to a character string.

Scope of Variables revisited

Global and private (lexical) variables
- Think that a function (subroutine) is a building. Each building specialize on a certain function.
  - Researchers collect data in the university, and a manuscript is submitted to a publisher.
  - The manuscript is reivewed and edited in the publisher, and it may be returned to the university or published in a journal.
- Inside of a building (within a subroutine), people (variables) are doing their own works. From each building, you can see other buildings. But you can't see through the people inside of the other building (private variables).
- But you can see a famous person walking outside (global variables).
Scope of a variable defines where the variable is visible to other perl code.
To make private variables (equivalent to local scope of C), we use my keyword at the first time this variable is used.
```
my $var = "value";
```
- You can set several private variables by one statement:
```
my ($a, $b, $c, $d) = (1,2,3,4);
```
  Don't forget ( ). The following is wrong:
```
my $a, $b, $c, $d;   # only $a is private.
```
If you do not use my at the first time when it is used, the variable has global scope.
```
$globalVar = "Everyone knows me.";
```
Or if you want to specify global, use our
```
our $globalVar = "Everyone knows me.";
```

Example: Pay attention to the value of $x and $y.

$x = "global 1";
$y = "global 2";

&func();

print "\noutside\n";
print "x = $x, y = $y\n";

exit;

sub func {
  my $x = "local";
  print "inside\n";
  print "x = $x, y = $y\n";

  $y = "global modified";
}

Actually, my can be used in any block, not limited in a subroutine's block. A block is defined by { }.

#!/usr/bin/perl

$var1 = 1;

# just a block
{
  my $var1 = 2;
  print "IN: $var1\n";
}

print "OUT: $var1\n";

my $sum;
for(my $i=1; $i < 10; $i++) {
  # a block for for loop.
  $sum = $sum + $i;
  my $wrongSum = $wrongSum + $i;

  print "i=$i, sum=$sum, wrongSum=$wrongSum\n";
}

Note that I did not use /usr/bin/perl -w. What happens if you use -w?

As with C, it's a better practice to make variables as private (local) as possible.
There is another scope called ``local'' in Perl, which is slightly different (it's not as ``local'' as my). But you can live without knowing about it. Most of the time I use either global or my variables.

Homework:

Write a function Range(), which takes an array, and return an array with two element, (min, max), of the array.
Make a program (cntBase.pl), which reads in a FASTA file, and print out the base compositions for each sequences.
FASTA is a very simple format. There is 1 line which starts with ``>''. This line contains the name (identification) of this sequence. Then the sequence data come in several lines after the sequence name. The next sample start when you encounter the next ``>''.
```
> Camel-Prion
GCTGACACCCTCTTTATTTTGC
AGATAAATCATCATG
> Camel-immunoglobulin
GGACACGGCCGTTTATTACTGC
GCACGTCGTACTATAGTGGTGT
GTACTCGTACACC
  :
  :
```
You run the program like this:
./cntBase.pl camel.fasta
and the expected output is something like
> Camel-Prion 120 132 111 122
> Camel-immunoglobulin 24 32 11 22
The four numbers correspond to counts of bases (A, T, G, C) in each sequence.

Next: About this document ... Up: perl1st Previous: File I/O

Naoki Takebayashi 2011-10-06