You can also use exists to distinguish whether hash entries exist. If you don't set a default and the caller does not provide a value, then the entry will not exist.

The following code:

#!/usr/bin/perl
use strict;
use warnings;

my %hash = ( a => 1, b => undef);

foreach my $key ('a', 'b', 'c') {
        print "$key " . (defined($hash{$key})?"is":"is not") . " defin
+ed\n";
        print "$key " . (exists($hash{$key})?"does":"does not") . " ex
+ist\n";
}
[download]

produces the following output:

a is defined
a does exist
b is not defined
b does exist
c is not defined
c does not exist
[download]

   my %defaults = ( ..., 'id' => '', ... );
[download]

my %defaults = ( bootpw => undef );

# is bootpw set to default?
if (defined $defaults{bootpw})
{
    print "Yes!\n";
}
else
{
    print "No.\n";
}
[download]

Get yourself a copy of Perl Best Practices and lookup the chapter on subroutines. It has many useful suggestions for creating better subs like how to handle named arguments, missing arguments and default argument values.

You see, I want to rewrite my current subroutines and allow for default values, or null values. I was trying the code above, but can't figure out how to get it to work. You see, the command changes based upon input.

Sometimes the command will be:
/usr/bin/passwd -n 1 -w 5 -x 30

Sometimes the command will be:
/usr/bin/passwd -n 1 -w 5 -x 60

and sometimes the command will be:
/usr/bin/passwd -x -1



I would like to set default values for n (1), w(5) and x(60), but also allow them to be null, like in the case of the last command... Just trying to figure out the best way to do this.

Current Code:

sub SUNPwdAging {

      my $loginid    = shift;
      my $pwminlife    = shift;
      my $pwmaxlife    = shift;
      my $pwdwarn    = shift;
      my $command;
      my $match_num;
      my $error;
      my $match;
      my $before;
      my $after;
      my $passwd    = "/usr/bin/passwd";
      my $options    = "-n $pwminlife -x $pwmaxlife -w $pwdwarn";

      # Define full command

      $command = "$passwd $options $loginid";

      # Set the Aging

      $Login::rsh->clear_accum();
      print $Login::rsh "$command\; echo \$?\r";
      ($match_num,$error,$match,$before,$after)=
                $Login::rsh->expect($Login::TIME_OUT,
                        '-re', '(?s).*\r\n[1-7]\r?$' 
                         ,'-re', '(?s).*\r\n0\r?$'
                         );
      if ($match_num == 1) {
         $result = "FAILED:  ".$match.": ".$after;
      }
      elsif ($match_num == 2) {
         $result = "SUCCESSFUL";
      }
      elsif (defined($error)) {
         $result = "FAILED:  ".$error;
      }
      else {
         $result = "FAILED:  Unknown error occurred.";
      }
      return $result;
   }
[download]

Would like it to be something more like this...

sub SunPwdAging {
    my %defaults = (qw(n 1 w 5 x 60))
    my %args = (%defaults, @_);
    my $result;
....
[download]

But then, how do I setup the command to even use what's passed to the subroutine?

What about something like:

use warnings;
use strict;
use Data::Dumper;

namedMunge(p1=>'aValU', foo=>undef);
sub namedMunge
{
    my %ParamHash = @_;
    my %defaults = ( foo=>0, bar=>42, baz=>'pie');
    ApplyDefaultParams(\%ParamHash, \%defaults);
    
    # Do Munge here!
    
    print Dumper \%ParamHash;
}

sub ApplyDefaultParams
{
    my $ParamHashRef = shift;
    my $DefaultsHashRef = shift;
    
    foreach my $key (keys(%$DefaultsHashRef))
    {
        if (not exists($ParamHashRef->{$key}))
        {
            $ParamHashRef->{$key} = $DefaultsHashRef->{$key};
        }
    }
    return $ParamHashRef;
}
[download]

Resulting in:

$VAR1 = {
          'foo' => undef,
          'baz' => 'pie',
          'p1' => 'aValU',
          'bar' => 42
        };
[download]

Maybe something like the following would work for you.

I note that in your example you had $loginid as first argument but didn't use the variable anywhere.

Read more... (2 kB)