eval works for me.

use strict;

my $hash = {'MONTH' => 'January'};
print $hash->{MONTH} . "\n";

my $hashInitStr = "{'MONTH' => 'January'}"; # This would come from a f
+ile
my $hash1 = eval $hashInitStr;
print $hash1->{MONTH} . "\n"
[download]

returns

Z:\Data\Perl>962633.pl
January
January

Z:\Data\Perl>
[download]

Regards,

John Davies

Update: Be aware that this has hideous security implications. Also, as Moritz explained to me in reply to Testing error handling that calls "die", there are two forms of eval. But the code given above does what I think you say you want.

Thanks for your help and for introducing me to eval. I will do some reading.

Unless the file is very locked down in terms of who is able to edit it, avoid using eval for this task like you'd avoid the plague.

An untrusted user could just put, say:

... into the file, and when you eval the file, that line will be executed, deleting your home directory and all its contents.

The same incidentally goes for do and require. Unless you trust the file you're loading, don't do it.

Much better would be to store your hash in a file format specifically designed for storing that sort of data. Namely, JSON or YAML.

{
  "MONTH": "January"
}
[download]

use JSON qw(from_json);
use File::Slurp qw(slurp);

my $hash = from_json( ~~slurp('test.json') );
print $hash->{MONTH};
[download]

#!/usr/bin/perl -w
use strict;

my $hash = {'MONTH' => 'January'};

print $hash->{MONTH} . "\n";

my $string =  q('MONTH' => 'January'); #from file
# I split your original string, but there probably is a cleaner
# way from your file read

my @split = split / => /, $string;
s/'//g for @split;
print "@split\n";

my $hash1->{ $split[0] } = $split[1];
print $hash1->{MONTH} . "\n";
[download]

$ ./962633.pl
January
MONTH January
January
[download]

I was being lazy. The data file at the moment is quite safe. But that can change. I guess I could write small function to parse the string and create the hash and return it.

!/usr/bin/perl -l

use strictures 1;
use Devel::SimpleTrace;

BEGIN {
    use strict 'refs';
    use warnings;
    
    eval {
        do {
            my $hash = {MONTH => 'January'};
            print $$hash{'MONTH'};
        }
    }
}

BEGIN {
    use strict 'refs';
    use warnings;
    
    eval {
        do {
            my $hashInitStr = {'MONTH' => 'January'};
            my $hash1 = $hashInitStr;
            print $$hash1{'MONTH'};
        }
    }
}
[download]

I tested it using eval as suggested by davies and Anonymous Monk's do:

Nope

#!/usr/bin/perl -w 
use strict;
use Config::Tiny;
use Data::Dumper;

my $Config = Config::Tiny->read( 'configfile.txt') or die " $!";

# $Months here is a ref to a hash
# 
my $Months = $Config->{Months};

print Dumper \$Months;

=prints

$VAR1 = \{
            'Month1' => 'January',
            'Month2' => 'February'
          };
=cut

__END__
#file configfile.txt contains this comment and this data
#Sample Configuration File

[Months]
Month1 = January
Month2 = February

[Another_Section]
[download]

Thanks to everyone for the wisdom. I have enough material now to make relatively wise choice of implementation for what I am trying to do.

In my situation, I need to read strings from a file as I moved some of this initialization to a data file. This is the only time I need to build a hash from the string. Rest of the data are just strings.