Programming

My issue is that the perl script (as I have done it so far) created empty branches when I try to check some branches on existence.

I am using multydimentional hashes: found it as the best way for information that I need to handle. Saing multidimentional I means hash of hashes ... So, I have

Code:

$hsh{k1}{k2}{k3}{k4}=v1;
$hsh{k1}{k9}{k3}{k33}=v2;
....

In some point I need to check some 'set of keys' on existence in the hash. So, I check:

Code:

if ( $hsh{ch1}{ch2}{ch3} ) {  ...something... }

And, suddenly I've realized, that such check creates the intermediate branches to access the final one for checking!

So, if there is no $hsh{ch1} before the check, it will be created to access the key 'ch2', which will be created to access the 'ch3'

QUESTION: Is there a way to avoid such aromatic creation ????
Logically, I would expect the Perl to get FALSE as soon as any key is not exist in the hash, but it is not happening!

Sure I could do:

Code:

if ( $hsh{ch1} && $hsh{ch1}{ch2} && $hsh{ch1}{ch2}{ch3} ) 
{...}

but it is so annoying, especially when I have many hashes with 7- 10 keys!

I have creates some function to check a hash 'reasonably', sending hash reference and array of keys to be checked, and it works fine, but it is slows down the processing visibly.

Here is an example of what I am talking about:

Code:

  DB<4> $h{a}{b}=[1,2]; $h{a}{c}=[3,4]  #hash with two elements (arrays) and in 2 levels

  DB<5> use Data::Dumper  #good way to display 

  DB<6> p Dumper\($a,%h)
$VAR1 = \undef;
$VAR2 = {
          'a' => {
                   'c' => [
                            3,
                            4
                          ],
                   'b' => [
                            1,
                            2
                          ]
                 }
        };

  DB<7> p 'da' if !$h{p}{m}  #checking for an existent keys and element
da
  DB<8> p Dumper\($a,%h)
$VAR1 = \undef;
$VAR2 = {
          'p' => {},            # <<== created one !!!
          'a' => {
                   'c' => [
                            3,
                            4
                          ],
                   'b' => [
                            1,
                            2
                          ]
                 }
        };

  DB<9> delete $h{p}

Once again: Is there a way to avoid such behavior without creating additional function? Thanks!

I am new to Perl, but I have not found Perl to be very aromatic... ;-)

IMHO, I don't think you should check the branches for TRUE OR FALSE. Perl isn't very good at TRUE and FALSE.
Either you have data or you don't. So you should check for an empty sting and not worry about what the internal hash looks like.

That's a documented behavior in Perl and is called "autovivification".
Check the stackoverflow website for the question "How do I disable autovivification in Perl?" for a detailed discussion and workarounds.

gandolf989 has a point here. Any reason you do *not* want the intermediate branches to be created? As long as they are empty and your existence checks return the values as expected, your program should be fine.

Autovivification in Perl is by design. It's not a bug; it's a feature. And I think it stems from Perl's tendency to go out of its way to make your text processing task easy.
For an in-depth technical discussion of why it works like that, what its advantages are and what problems it solves, check this link: http://www.sysarch.com/Perl/autoviv.txt