Also, there are parameter checking modules, such as Params::Validate and Params::Check (Core).

use named Parameter passing concept like

build_url(account => "test",transaction => "test1", location => "India
+", fname => "Nikhil", lname => "jain"); 

build_url(account => "test", fname => "nikhil", lname => "jain"); 

build_url(account => "test" ,transaction => "test1", fname =>"nikhil",
+ lname => "jain"); 


 
sub build_url {
my (%args) = @_;
my $fname = $args{fname} || "Bob the Builder";
my $lname = $args{lname} || "none that we know";

}
[download]

This is the way to go imho. Remove the $ in the parameter names though (so account => "test" instead of $account => "test") I like this idiom:

sub build_url {
  my %param = ( fname => "default value",
                ...,
                @_
               );
  ...
  # do stuff with $param{account} etc.
}
[download]

If I follow, the syntaxcalling convention is

build_url($account, [ $transaction, [ $location, ] ] $fname, $lname);
[download]

where square brackets denote optional parameters. You could use

sub build_url {
   my $lname = pop;
   my $fname = pop;
   my ($account, $transaction, $location) = @_;
   ...
}
[download]

sub build_url {
   my $account     = shift;
   my $transaction = @_>=4 ? shift : undef;
   my $locaton     = @_>=3 ? shift : undef;
   my $fname       = shift;
   my $lname       = shift;
   ...
}
[download]

sub build_url {
   splice(@_, 1, 0, (undef)x(5-@_))
   my ($account ,$transaction, $location, $fname, $lname) = @_;
   ...
}
[download]

I like this way as you stated, but:


build_url( $account,[$fname], [$lname]);

sub build_url {
   my $lname = pop;
   my $fname = pop;
print "$lname and $fname\n";
   my ($account ,$transaction, $location) = @_;
   ...
}
[download]


If a run this I am getting this:
Lname=ARRAY(0x8967f28) and Fname=ARRAY(0x8967748)
Any suggestion? Thanks!

To put it differently, I understood that you want to support the following three calling conventions and only those three calling conventions:

build_url($account, $fname, $lname);
build_url($account, $transaction, $fname, $lname);
build_url($account, $transaction, $location, $fname, $lname);
[download]

If so, all three alternatives I provided should work.

What about this:


build_url( 

      account => $account,
      fname   => $fname, 
      lname   => $lname],
);
sub build_url {
   my (%args) = @_;
   my $account = $args{account} || '';
   my $fname   = $args{fname}   || '';
   my $lname   = $args{lname}   || '';
   my $other   = $args{other}   ||'';

   ...
}
[download]


There, it should prevent it to be out of order right?

In my opinion the answer to your question is 'yes'. At least that's what I'd do. I'd probably just pass 0 through... In the sub I would then check for the value before proceeding.

From program A:
build_url( $account ,$transaction, $location, $fname, $lname);
From program B:
build_url( $account, 0, 0, $fname, $lname);
From program C:
build_url( $account, $transaction, 0, $fname, $lname);
From program D:
build_url( $account ,$transaction, $location, $fname, $lname);

sub build_url
 {
  my ($account ,$transaction, $location, $fname, $lname) = @_;
  if ($location) { ... do what you would do ... }#example
 }
[download]

What if '0' is valid for one of the entries?!? Better to use 'undef' instead. And even better would be to just pass a hash reference in (or use named parameters).

Elda Taluta; Sarks Sark; Ark Arks

Thanks Argel!

I appreciate what you have posted and I see your point. I think using undef makes sense when used also with 'defined', but here's my reasoning behind my original suggestion...

The question was:
"Should I make sure that I always pass 5 expected values to this sub routine even if I have to pass blank values, but preserving the order that the code is expecting them?"

The answer is yes to that question if the person asking is going to continue to use a list array method. I think Undef is only safer than 0 if you use 'defined' to check it, otherwise it's the same as 0, '', '0', right? At least that's what I got out of this perldoc: http://perldoc.perl.org/functions/defined.html

Also, I thought 0 would be alright in this scenario based on what I interpreted the expected values to contain, but then again, it would be a mistake to assume data would be entered in any expected format, especially if it is coming in from a form.

If we don't use a hash this is a better solution:


build_url( $account, $transaction, undef, $fname, $lname);
[download]

sub build_url() {
 ... etc...
 if (defined($location)) {
   ... stuff ...
 }
}
[download]



Thanks!
Dawn

sub func {
    my($param1, $param2, $param3) = @_;
    my $tempparam1;
    if(ref($param1) eq "HASH") {
        $tempparam1  = $param1->{'param1'};
        $param2      = $param1->{'param2'};
        $param3      = $param1->{'param3'};
        $param1      = $tempparam1;
    }
    print "param1 is $param1 param2 is $param2 param3 is $param3 \n";
}
func( 'one', 'two', 'three');
func( {param1 => 'one', param2 => 'two', param3 => 'three'});
[download]