return 0 unless @_;
return $var1 if @_ == 1;
[download]

This may seem like a lot of work to you, but at least it makes explicit the behavior of your code with, um, nonstandard arguments.

And in regard to ||=, personally I think it's a pretty elegant operator, but perhaps you might like this better:

my $var1 = shift || 0;
my $var2 = shift || 0;
[download]

Thanks, gaal!

Those are good enough. I wasn't sure whether other solutions existed that were "better" than what I knew of.

You could also do this:

use warnings;
no warnings 'uninitialized';
[download]

It's handy, especially in CGI, for situations like if ( $param_this =~ /that/ ) {}, which otherwise has to be if ( $param_this and $param_this =~ /that/ ) {} to avoid the warnings. It's sort of a DWIW kludge but since you're doing comparisons without explicitly checking what sort of thing you're comarping ("e" > 6, for example), it might be fine for what you're doing.

Thanks, Your Mother!

Ah, I see. I suppose we can place "no warnings 'uninitalised'" at the point where it should take effect. Am I right?

That's right. It scopes the effect. But you will have to use the proper US spelling. :)

You've gotten good advice on the uninitialized value warnings.

I'd just like to note an alternative way to write this. Your max function can be written in terms of the trinary operator,

sub meth3 {
    my ($first, $second) = map {$_ || 0} @_;
    $first > $second ? $first : $second;
}
[download]

Thanks, Zaxo!

I like both your map and trinary solutions :) The map is particularly enlightening, because I was using a couple of shift's to achieve that effect.

sub meth1 {
   return 0 if $#_ == -1;
   return $_[0] if $#_ == 0 || $_[0] > $_[1];
   return $_[1];
}
[download]