How to know if perl subroutine takes parameters

Question

I'm quite new to perl and I can't seem to find any information on how one would know if a subroutine takes a parameter.

In other languages (e.g python, java, etc), it is very clear, a method/function usually looks like this:

    def my_func(arg1, arg2):
        # do something

But in perl, it's simply:

    sub my_func {
        my params = @_;
        # do something
    }

But I've seen examples where my params = @_ isn't even included, but the subroutine is called and passed an argument.

e.g

    sub my_func {
        my $self = shift;
        my $fieldstr = 'tbl'.$self->db_func.'*,';
        my $sql = "SELECT $fieldstr FROM tbl".$self->db_func.'WHERE'.$self->...;

        my $sth = $self->other_func->my_func($sql) or return undef;
    }

So I was wondering if there is some sort of guideline to know if a subroutine takes a parameter(s)?

Answer 1

Please take a look at my answer to a similar question.

Perl is hyper-flexible, in that a subroutine can simply ignore excess parameters, provide defaults for missing ones, or die if the parameters aren't exactly what is expected.

Perl's author, Larry Wall, is a linguist, and the rationale behind this is that subroutines behave like imperative verbs; so just as you could say "fetch the wood", "fetch the wood from behind the shed", or "fetch the wood from behind the shed using the tractor", you can equally say

fetch($wood)
fetch($wood, $shed)
fetch($wood, $shed, $tractor)

or even

fetch($wood, {from => 'shed', using => 'tractor'})

and it is up to the subroutine to work out what is required.

Subroutine prototypes should be avoided, as they have side-effects that change the behaviour of the code in ways that aren't obvious. They are intended only for writing additional language constructs; a good example is Try::Tiny.

Answer 2

Arguments are passed in @_, so you'd need to look for uses of @_. For example,

• my ($x, $y) = @_;
• shift in a sub is the same as shift(@_)
• $_[$i]
• &f (but not &f()), as in sub log_warn { unshift @_, 'warn'; &log }

As a sub writer, you should use these as near the top of the sub as possible to make them obvious. The last two are usually used as optimizations or to have by-reference parameters.

Answer 3

The parameters for a subroutine call are contained in the array @_.

Two important functions for array manipulation are shift and pop. Suppose you have a list (1, 2, 3, 4). shift removes a value from the left side of the list and returns it.

my @list = ( 1, 2, 3, 4 );

my $value = shift @list;

print "$value\n";    # will print "1"
print "@list\n";     # will print "2 3 4"

pop does the same thing from the right side instead of the left:

my @list = ( 1, 2, 3, 4 );

my $value = pop @list;

print "$value\n";    # will print "4"
print "@list\n";     # will print "1 2 3"

When used inside a subroutine, pop and shift will use the @_ array by default:

some_function( 'James', 99 );    #these 2 arguments will be passed to the function in "@_"

sub some_function {
    my $name = shift;             #remove 'James' from list @_ and store it in $name
    my $age  = shift;             #remove 99 from list @_ and store it in $age
    print "Your name is $name and your age is $age\n";
}