sub myFunction
{
     my ($arg) = @_;
     #blah blah blah, do some stuff.....
}
myFunction($myArg);
[download]

For my own work, I usually use

sub myFunction
{
     my ($arg1, $arg2, ..., $argN) = @_;
     #blah blah blah, do some stuff.....
}
myFunction($myArg);
[download]

sub myFunction
{
     my $self = shift;
     my ($arg1, $arg2, ..., $argN) = @_;
     #blah blah blah, do some stuff.....
}
myFunction($myArg);
[download]

sub myFunction
{
     for (@_) {
          ... # lvalue; Note this impacts the passed values!!
     }
}
myFunction($myArg);
[download]

Method 2 should have parens: my ($arg) = @_;

As for which style to use, it really doesn't matter, it is all a matter of personal taste and I have used all three (though typically one of the first two).

Update: Better phrasing, thanks kennethk

You may want to update your phrasing; the choice of method doesn't really matter, but your comment sounds like the parentheses don't matter. The missing parentheses are a bug.

---

#11929 First ask yourself `How would I do this without a computer?' Then have the computer do it the same way.

I tend to use list assignment for most arguments:

my ($foo, $bar, @baz) = @_;
[download]

But if there are one or two arguments that are conceptually special, I'll use shift for them. (Or pop if it's the final argument, though that's less often the case.) For example, in OO code, the invocant:

sub some_method {
   my $self = shift;
   my ($foo, $bar, @baz) = @_;
  ...;
}
[download]

Or for an around modifier, then the original coderef and the invocant would both be special:

around some_method => sub {
   my ($orig, $self) = (shift, shift);
   my ($foo, $bar, @baz) = @_;
  ...;
};
[download]

Or if I was writing my own implementation of grep, then the coderef would be special enough:

sub mygrep {
   my $code = shift;
   my (@items) = @_;
  ...;
}
[download]

My reason for this is that it's often nice to have all the "normal" arguments remaining in @_ in case you need to pass them all through to another function that you're calling.

For single argument subroutines, I apply the same logic. If it's conceptually something like an invocant, I'll use shift; otherwise I'll use list assignment. After all, a single argument subroutine might end up taking more arguments as the project grows in complexity.

Hey Toby, thanks for the reply...

Gotcha, thanks for some more example, much appreciated!

Yea, normally when I have more then one argument passed to a Sub I'll use the the 1st method you
showed in your reply.



sub myFunction
{
    my ($first, $second, $third) = @_;
    .....code.....
}
[download]


I know its a slightly different topic, but when I pass more then one Argument to the script itself,
like from the CLI, I like to use the Getopt::Long Module, it works great and does most of the work for you...


use Getopt::Long;
my $HELP;
my $HOSTNAME;

if (@ARGV > 0)
{
        GetOptions('help|?' => \$HELP,
                   'host|hostname|H=s' => \$HOSTNAME
        );
}
[download]


Thanks again for the examples!


Thanks,
Matt