Here's one way to do it:
sub total { my $sum; # private variable foreach (@_) { $sum += $_; } $sum; }
This subroutine uses $sum to keep a running total. At the start of the subroutine, $sum is undef since it's a new variable. Then, the foreach loop steps through the parameter list (from @_) using $_ as the control variable. (There's no automatic connection among @_, the parameter array, and $_, the default variable for the foreach loop.)
The first time through the foreach loop, the first number (in $_) is added to $sum. $sum is undef since nothing has been stored there. Since we're using it as a number, which Perl sees because of the numeric operator +=, Perl acts as if it's already initialized to 0. Perl thus adds the first parameter to 0, and puts the total back into $sum.
Next time through the loop, the next parameter is added to $sum, which is no longer undef. The sum is placed back into $sum and on through the rest of the parameters. Finally, the last line returns $sum to the caller.
There's a potential bug in this subroutine depending on how you think of things. Suppose this subroutine was called with an empty parameter list as we considered with the rewritten subroutine &max in the chapter text. In that case, $sum would be undef which would be the return value. But in this subroutine, it would probably be more correct to return 0 as the sum of the empty list rather than undef. (If you wished to distinguish the sum of an empty list from the sum of, say, (3, -5, 2), returning undef would be the right thing to do.)
If you don't want a possibly undefined return value, though, it's easy to remedy: simply initialize $sum to zero rather than using the default of undef:
my $sum = 0;
Now the subroutine will always return a number even if the parameter list were empty.
Here's one way to do it:
# Remember to include &total from previous exercise! print "The numbers from 1 to 1000 add up to ", &total(1..1000), ".\n";
We can't call the subroutine from inside the double-quoted string,[*] so the subroutine call is another separate item being passed to print. The total should be 500500, a nice round number. And it shouldn't take any noticeable time at all to run this program; passing a parameter list of 1,000 values is an everyday task for Perl.
[*] We can't do this without advanced trickiness. It's rare to find anything that you absolutely can't do in Perl.
Here's one way to do it:
sub average { if (@_ = = 0) { return } my $count = @_; my $sum = &total(@_); # from earlier exercise $sum/$count; } sub above_average { my $average = &average(@_); my @list; foreach $element (@_) { if ($element > $average) { push @list, $element; } } @list; }
In average, we return without giving an explicit return value if the parameter list is empty. That gives the caller undef[*] to report that no average comes from an empty list. If the list wasn't empty, using &total makes it simple to calculate the average. We didn't need to use temporary variables for $sum and $count, but doing so makes the code easier to read.
[*] Or an empty list, if &average is used in a list context.
The second sub, above_average, builds and returns a list of the desired items. (Why is the control variable named $element instead of using Perl's favorite default, $_?) Note that this second sub uses a different technique for dealing with an empty parameter list.