Hello, it looks like you may need to create an array of hashes, one hash for each $line. That way you get to keep all of your records.

my @information;

open(IN,"<$file");
while(<IN>)
{
    my $line = $_;
    chomp $line;
    my($lastname, $firstname, $country, $language) = split('\|', $line
+);
    #print"$lastname, $firstname, $country, $language\n";

    push @information, {
        'lastname'  => $lastname,
        'firstname' => $firstname,
        'country'   => $country,
        'language'  => $language,
    }
}
[download]

Update: I made a typo in the code, so I fixed it.

push @{ $info{lastnames} }, $lastname;
[download]

my @records;
...
{
  my %info;
  my ... = split /\|/, $line;
  push @records, \%info;
}
[download]

more on this in perlintro, the basic datatypes, three, Arrays: A Tutorial/Reference, Lexical scoping like a fox, references quick reference

Thanks the very first one worked. I was just trying to understand how it was working. So when we do array of hash the each new indices of array will have new key and value that way we avoid overwriting of same key value right?

You are correct. If you dump the data, you will see all of your data in an array of hashes.

use Data::Dumper;
print Dumper(\@information);
[download]

Have a cookie and a very nice day!
Lady Aleena

It's a hash of arrays

%info is a hash

$info{lastnames} is an array reference

To take a page out of Basic debugging checklist tutorial

use Data::Dump;
dd { lastnames => [ qw/ ro sham bo / ] };
__END__
{ lastnames => ["ro", "sham", "bo"] }
[download]

Hmm, lets try that again

use Data::Dump;
my %info;
push @{ $info{lastnames} }, 'ro';
push @{ $info{lastnames} }, 'sham';
push @{ $info{lastnames} }, 'bo';
dd \%info;
__END__
{ lastnames => ["ro", "sham", "bo"] }
[download]

Thats better. Last demo

use Data::Dump;
my %info;
$info{lastnames}[0] = 'ro';
$info{lastnames}[1] = 'sham';
$info{lastnames}[2] = 'bo';
dd \%info;
__END__
{ lastnames => ["ro", "sham", "bo"] }
[download]

Any time you're wondering about something , write yourself a little program like these three :) hashofarrays.01.pl, hashofarrays.02.pl, hashofarrays.03.pl

Does a hash of arrays make sense for your use case, maybe :) maybe @records is a better fit, I can't tell yet

As an alternative, use Text::CSV or Text::CSV_XS and read the whole file in one go:

use Text::CSV_XS;
open my $fh, "<", $file or die "$file: $!";
my $csv = Text::CSV_XS->new ({ auto_diag => 1, binary => 1, sep_char =
+> "|" });
$csv->column_names (qw( lastname firstname country language ));
my $info = $csv->getline_hr_all ($fh);
[download]

With your data looking like

Wall|Larry|USA|English
Walker|Johnny|Scotland|Scottish
[download]

$info (an arrayref: a pointer to a list of hashes) would look like:

[
    {   country          => 'USA',
        firstname        => 'Larry',
        language         => 'English',
        lastname         => 'Wall'
        },
    {   country          => 'Scotland',
        firstname        => 'Johnny',
        language         => 'Scottish',
        lastname         => 'Walker'
        }
    ]
[download]

So how do I assign value so that each time it is different value get assigned to the same key.

my $count;
while (my $line = <IN>) {
    chomp $line;
    my($lastname, $firstname, $country, $language) = split(/\|/, $line
+);
    $info{lastname}[$count] = $lastname;
    $info{firstname}[$count] = $firstname;
    $info{country}[$count] = $country;
    $info{language}[$count] = $language;
    $count++;
}
[download]

my $LASTNAME = 0;
my $FIRSTNAME = $LASTNAME + 1;
my $COUNTRY = $FIRSTNAME + 1;
my $LANGUAGE = $COUNTRY + 1;
my @info = map {[/[^|\n]*/g]} <IN>;
[download]

You will need to define, say, an array(ref) of hash(refs), or vice-versa as you prefer.   This can be done more easily than you might suppose, thanks to Perl’s so-called “auto-vivication” features.   Consider the following two “Perl one-liner” examples:   (the command, followed by its output)

$ perl -e 'my $h; my $k="foo"; push @{$$h{k}}, "bar"; use Data::Dumper
+; print Data::Dumper->Dump([$h], ["h"]);'

$h = {
       'k' => [
                'bar'
              ]
     };
[download]

$ perl -e 'my $h; my $k="foo"; push @{$$h{k}{"name"}}, "bar"; use Data
+::Dumper; print Data::Dumper->Dump([$h], ["h"]);'

$h = {
       'k' => {
                'name' => [
                            'bar'
                          ]
              }
     };
[download]

In each case, you can see that, simply as a matter of due course while executing a push statement, the entire data structure to which I intended to push the value simply “came to life automatically” as-needed if it didn’t exist already.   Since in this simple case nothing existed, this is what happened:

• $h simply became a hashref;
• It simply acquired the key “k”, and in the second case, nested hashrefs;
• The entry simply became an empty arrayref, and a value was pushed onto it.

You don’t have to bother to consider, “well, does it exist yet?”   If you need it, and it doesn’t yet, then presto!, it does.   Not quite “let there be light, and there was light,” but pretty darned close.   This is one of the many reasons why Perl is so often called the Swiss Army® Knife of pragmatic data processing.

References is a good start, if you learn how to reference and dereference then you are well on your way.