have I stumbled on the Best Solution to my problem?

No, actually your "solution" is not very good at all. Consider what will happen if $hash{'key'} is 0, undef, or an empty string. You should be using exists():

$hash{'key'} = "something" unless exists $hash{'key'};
[download]

I recall a node where BrowserUk John_M._Dlugosz suggested that exists() should return something more useful (like a reference to the element) in the case that the key did exist... but that wouldn't aid in the case where it doesn't.

-sauoq
"My two cents aren't worth a dime.";

How about this?

$var = exists( $hash{'key'} ) ? $hash{'key'} : "non-existant";
[download]

That won't trigger auto-vivification of the hash key. And it accomplishes your goal of reliably returning either the key or something else if the key doesn't exist. Always use exists to check existance of a hash key. defined (or checking for a value) doesn't do what you want.

Actually, auto-vivification of hash entries doesn't happen unless you do something like take a reference to the hash entry... for example by referring to something more deeply nested in the non-existent hash entry:

#!/usr/bin/perl -l
my %hash;

my $foo = $hash{'foo'};
print exists $hash{'foo'} ? "yes" : "no";  # prints "no"

my $bar = $hash{'bar'}->{'xxx'};
print exists $hash{'bar'} ? "yes" : "no";  # prints "yes"

my $baz = \$hash{'baz'};
print exists $hash{'baz'} ? "yes" : "no";  # prints "yes"
[download]

-- Mike

--
XML::Simpler does not require XML::Parser or a SAX parser. It does require File::Slurp.
-- grantm, perldoc XML::Simpler

However, the hash itself may be auto-vivified in spite of using exists().   In fact, the hash will be auto-vivified by the use in exists()!   This may be what davido was thinking about.   Check perlref for examples of how the end-point (the hash element) is protected from auto-vivification by the above constructs, by the leading components of the hash expression are not.

The code you posted has a problem when a hash entry exists but has a false value like 0 or undef. The straightforward way to test whether a hash entry exists is to use exists, e.g.:

my $var = exists $hash{'key'} ? $hash{'key'} : "unknown";
[download]

This is not particularly pretty, but works, and I don't know of a more succinct way to do the same thing.

You could use a tied hash where FETCH checks that the key exists before returning it. If it doesn't exist, it returns a default value (perhaps supplied when you called tie. All the other tied hash methods access the internal hash directly.

Anyway, this isn't too hard to implement with tie:

package Tie::Hash::Default;
require Tie::Hash;
our @ISA = qw/Tie::ExtraHash/;

sub TIEHASH {
    my ($class, $default) = @_;
    bless [ {}, $default ] => $class;
}

sub FETCH {
    my ($self, $key) = @_;
    exists $self->[0]->{$key}
     ? $self->[0]->{$key}
     : $self->[1];
}

#############
package main;

## -1 is the default value for nonexistant keys in %h

tie my %h, 'Tie::Hash::Default', -1;

$h{foo} = $h{bar} = 1;

print "$_ => $h{$_}\n"
    for qw/foo bar baz/;
[download]

$h{asdf}++;        ## $h{asdf} == 0
$h{jkl} .= "jlk";  ## $h{jkl} eq "-1jkl"

use strict;
$h{xyz}{blah} = 1; ## Can't use string ("-1") as a HASH ref ..
[download]