Interesting... Using perl 5.6.1 on solaris:

#!/home/mhough/perl/bin/perl
use strict;
use warnings;
use Data::Dumper;

my %outhash = (abc => 1, def => undef);
my %outhash2 = %outhash1
print Dumper(\%outhash, \%outhash2);

foreach my $str (qw/abc def ghi/)
{
    $outhash{$str}? ($outhash{$str}++) : ($outhash{$str} = 1);
    $outhash2{$str}++;
}

print Dumper(\%outhash, \%outhash2);
[download]

$VAR1 = {
          'abc' => 1,
          'def' => undef
        };
$VAR2 = {
          'abc' => 1,
          'def' => undef
        };
$VAR1 = {
          'abc' => 2,
          'def' => 1,
          'ghi' => 1
        };
$VAR2 = {
          'abc' => 2,
          'def' => '1',
          'ghi' => '1'
        };

Note the subtle difference between key 'def' in the two cases. It would appear that autoincrement on an undef does the magical string autoincrement, leading to a string value of '1', while the code FatVamp offers sets a numeric value of 1.

What does it mean? I don't know, but the two forms do have ever so slightly different results whose difference probably doesn't matter.

If that matters to someone, they might consider something like:

++( $outhash{$str} ||= 0 );
[download]

- tye        

And if one were concerned, one could do

$outhash{$str} += 1;
[download]

to ensure numeric context.

---

We're not really tightening our belts, it just feels that way because we're getting fatter.

Or am I overseeing some "important" side effect?

My guess is that the keys aren't known until the script is run, and that's your colleague's way of getting rid of the warnings. A perfectly valid way too. They are making you explicitly aware of the fact that $outhash{$str} may be undefined when you try to increment it.

This would work equally well:

$outhash{$str}||=0;
$outhash{$str}++;
[download]

.02

cLive ;-)

If the the value of $outhash{$str} is undefined, you'll get a warning about using an undefined value.

Are you sure about that? Can you show code giving the warning? If you can construct code that generates a warning when ++ is applied to an undefined value, make sure to report it as a bug, because that's not supposed to happen.

This would work equally well:

$outhash {$str} ||= 0;
$outhash {$str} ++;
[download]

Yeah, but why bother? From the documentation about auto-increment and auto-decrement:

       "undef" is always treated as numeric, and in particular is
       changed to 0 before incrementing (so that a post-increment
       of an undef value will return 0 rather than "undef").
[download]

Abigail

"Are you sure about that?".

No, obviously, but my guess is that his colleague made the same assumption that I did :)

cLive ;-)

If that were a check for an undef value, it should have used the defined() test which is instructive to us when trying to understand the code.

If the the value of $outhash{$str} is undefined, you'll get a warning about using an undefined value.

This was my first thought too, but then the plain mentioning of $outhash{$str} in the ternary operator test section should do also - shouldn't it?

Bye
 PetaMem     All Perl:   MT, NLP, NLU

Try this:

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

my $x;
$x = $x+1;

print $x;
[download]

I get:

Use of uninitialized value in addition (+) at tmp.pl line 6.
[download]

Then try:

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

my $x;
$x = $x ? $x+1 : 1;

print $x;
[download]

to see the difference...

cLive ;-)

Neither methods generate a warning for me, using perl 5.8.4.

$ perl -wle '$outhash{$ARGV[0]}++; print $outhash{$ARGV[0]}' foo
1
$ perl -wle '$outhash{$ARGV[0]}
             ? ($outhash{$ARGV[0]}++)
             : ($outhash{$ARGV[0]} = 1);
             print $outhash{$ARGV[0]}' foo
1
$
[download]

Abigail