You can print the Dumper output to an open file handle. Read back with do.

You have two errors there which needs to be corrected. You need make the hash value assignment conditional on a fresh match. As you have it, $1 will still be defined forever after the first match. That will do no great harm, but it could be a lot of lost motion. It's a good habit to get into when using regex backreferences.

while (<LOG>) {
    $alarm_details{ $1 } = $2 if /^(.*)=(.*)$/;
}
[download]

{
    open my $fh, '>', 'hash.i' or die $!;
    print $fh Dumper(\@alarm_details);
}
[download]

my $alarm_details_ref = do '/path/to/hash.i';
[download]

my @old_alarm_details = @{do '/path/to/hash.i'};
[download]

(Added) Ha! I thought you wanted a file, 'hash.i'. To simply make the hash available without persistence, either return the reference as suggested above (preferred), or make @alarm_details a global package variable.

Hi perumal, Try This,

use strict;
use warnings;
use Tie::IxHash;
use Data::Dumper;

my ($alarm_details) = &main();

print Dumper @$alarm_details;


sub main{

    my @alarm_details;
    
    my @paths = qw(c:/test/sample.xml c:/test/sample1.xml); #giving th
+e file path
    
    foreach my $path (@paths){    
        my %alarm_details;    #Declare Each time instead of setting nu
+ll    value
        tie %alarm_details, "Tie::IxHash"; #for Hash in order
        
        open(LOG,"<$path") || die "can't open log ";
        $alarm_details{$path} = $path;
        
        while (<LOG>) {
            chomp;
            /^(.*)=(.*)$/;
            $alarm_details{ $1 } = $2 if ($1);
        }
        
        push(@alarm_details,\%alarm_details);
    }
    
    return \@alarm_details;
}
[download]

Updated : Thanks Joost

One thing:

my ($alarm_details) = &main;
[download]

Do not use the &subname; to call subroutines unless you want to pass the current @_ array on to that sub. Normally, you'll want subname();, &subname(); or subname; (if the sub is already defined) instead.

See perlsub

"What should it profit a man, if he should win a flame war, yet lose his cool?"

"..does not give me the entire elements in the array..it jus gives me the last hash in the array.."

Well, that's because you clobber the %alarm_details hash on each iteration.

Personally, I think you could do away with the @alarm_details array altogether and just use a HoH. Also, I'd go for a split rather than using a regexp, and split the lines directly into named variables. Something like this (untested):

my %alarm_details;
my @files = </TELECOM_PROJ_MAIN/sas/tmp/t*>;

foreach my $file (@files) {
    open LOG, "<", $path or die "Can't open $file:$!\n";
    $alarm_details{filepath} = $file;

    while (<LOG>) {
        chomp;
        my ($key, $value) = split /=/, $_;
        $alarm_details{filepath}{$key} = $value if ($key);
    }
    close LOG;
}
[download]

Also note that I changed @paths to @files, which seems to be more appropriate. And, the 3 argument form of open is better practise, as is checking $! upon failure.

One more thing to note is that the above code would throw "uninitialised value" warnings on any lines that had no data to the right-side of the equals (=). But you could get rid of that by explictitly checking for both $key and $value on each iteration.

Hope this helps,
Darren :)