You can always parenthesize defensively.

$template->param( 
  some_var => ( $hash{some_possibly_undefined_key} || 10 )
)
[download]

...but it looks to me as if your example actually works as you intend.

The big problem I see is that you default to 10 even if you have a defined value of 0 (see also True or False? A Quick Reference Guide).

so that I get a default if the var isn't defined

It's late. I'm tired. I'm going to bed

...or, in the case of a hash, exists(), which doesn't, as i understand it, autovivify with a value of undef the key which had hitherto not existed in the hash.

You're partly correct. In the case of this example, where there is only a single level hash, exists will not autovivify the key. However, if this was a complex data structure containing a HoH, HoA, AoH, etc, then the intermediate references (but not the terminal reference) would be autovivified^*. To avoid autovivifying the intermediate structures you have to use exists to check each one as you go, or use something like tye's Data::Diver. See the example below.

use strict;
use warnings;

use Data::Diver qw( Dive );
use Data::Dumper;

my %h;

# The exists function will autovivify intermediate keys

print "Testing with exists\n";
printf "key1 %s exist\n", exists $h{key1} ? 'does' : 'does not';
printf "key1-key2 %s exist\n", exists $h{key1}{key2} ? 'does' : 'does 
+not';
printf "key1 %s exist\n", exists $h{key1} ? 'does' : 'does not';
print Dumper( \%h );

# Data::Diver's Dive will not autovivify intermediate keys

print "\nTesting with Data::Diver\n";
my @values = Dive ( \%h, 'key3', 'key4' );
printf "key3-key4 %s exist\n", @values ? 'does' : 'does not';
print Dumper( \%h );
[download]

Output:

Testing with exists
key1 does not exist
key1-key2 does not exist
key1 does exist
$VAR1 = {
          'key1' => {}
        };

Testing with Data::Diver
key3-key4 does not exist
$VAR1 = {
          'key1' => {}
        };
[download]

^*You may know this, but someone else reading your reply may not realize the difference in behavior for single level vs multi level structures.

perldoc perlop Operator Precedence Associativity

The || operator has a higher precedence than the comma, so your code should work as you intend. What do you mean by, it doesn't work?

As I read it, that should assign the param "some_var" to the value of supplied by the hash or 10 if that is false.

- Miller

Sorry, I've just realised that my error was elsewhere, and the code does in fact work. Thanks for the help with undefined versus false though.

---




Nobody says perl looks like line-noise any more
kids today don't know what line-noise IS ...

Still, I thought there was (arguably) a valid point made.

Given that perl -we '10' produces the "Useless use of a constant in void context" warning, couldn't it be argued (by someone that wanted to be extremely picky) that perl -we '0 || 10' should produce the same (or similar) warning ?

Cheers,
Rob

$template->param(
  some_var => 10,
  (some_var => $hash{some_possibly_undefined_key}) x!! exists($hash{so
+me_possibly_undefined_key}),
);
[download]

$template->param(
  some_var => exists $hash{some_possibly_undefined_key} ? $hash{some_p
+ossibly_undefined_key} : 10;
);
[download]

{
   package MyTemplate;

   use base Template;

   use Params::Validate qw (validate);

   sub param
   {
       my $self = shift;
       my %p = validate(@_, {
           some_var => {
               default => 12,
           }
       });
       $self->SUPER::param(%p);
   }
}
[download]

if ($a == 0) 

if (0 == $a)