#!/usr/bin/perl
use warnings;
use strict;

#Header
printf "%-12s %-10s %s\n", qw(Number User Comments);

my $result =`cmd to get the result`;

my %users;
while ($result =~ /number (\d+).*user:\s*(\S+)\s*#\s*(.*)/g) {
    my ($number, $user, $comment) = ($1, $2, $3);
    printf "%-12s %-10s %s\n", $number, $user, $comment;
    $users{$number} = [ $user, $comment ];
}

print 'Select a number: ';
my $input = <STDIN>;
chomp $input;
if (exists $users{$input}) {
    print "@{ $users{$input} }\n";
} else {
    print "Unknown number.\n";
}
[download]

Update: Fixed typos in the code after testing it.

It worked great. But how can I access the respective $user and $comments independetly?

print 'Select a number: ';
my $input = <STDIN>;
chomp $input;
if (exists $users{$input}) {
   print "Number entered is : $users{$input} \n";
   print "User for the number $users{$input} is :  \n";
   print "Comments for the number $users{input} is : \n";
} else {
    print "Unknown number.\n";
}
[download]

Something like this in the output

  Number entered is : 12345678
  User for number 123456789 is : Sam  
  Comments for the number 123456789 is : Changed "abc" in the file
[download]

See perlreftut - Mark's very short tutorial about references for details.

print "Number entered is : $input\n";
print "User for the number $input is: $users{$input}[0]\n";
print "Comments for the number $input is: $users{input}[1]\n";
[download]

لսႽ† ᥲᥒ⚪⟊Ⴙᘓᖇ Ꮅᘓᖇ⎱ Ⴙᥲ𝇋ƙᘓᖇ

I'd suggest using a hash of hashes for your data:

#!/usr/bin/perl

use strict;
use warnings;
use feature qw/say/;

my $result = q/
        number 1234567 user: sam  # changed abc in the file.
        number 5646542 user: john # deleted asds in the file.
/;

my %parsed_results = ();

while($result =~ /number (\d+).*user:\s*(\S+)\s*#\s*(.*)/g) {
    $parsed_results{$1} = {
        'user'    => $2,
        'comment' => $3,
    }
}

print "Enter a number: ";
chomp(my $number = <STDIN>);

if(exists $parsed_results{$number}) {
    say "User   : ", $parsed_results{$number}->{'user'};
    say "Comment: ", $parsed_results{$number}->{'comment'};
} else {
    say "Not found: $number";
}
[download]

Can numbers be repeated? Is a single user always associated with a single number (UID), or can multiple (users|numbers) be associated with a single (number|user)?

The numbers are unique.They wont be duplicated. An a number will have only ONE user and comment associated to it

Hi,

This should give you a starting point:

#!/usr/bin/perl
use strict;
use warnings;
use 5.010;

use Carp;
use Data::Dumper;

use strict;
use Data::Dumper;

my %hash;

while(my $line = <DATA>) {
    chomp $line;
    next if $line =~ m/^\s*#/;
    next if $line =~ m/^\s*$/;
    my ($number, $user, $comment) = split /\s+/, $line, 3;

    $hash{$number} = {
        number => $number,
        user => $user,
        comment => $comment,
    }
}

say Dumper(\%hash), "\n";

__DATA__
#Number    User    Comments
1234567   sam    changed abc in the file.
5646542   john   deleted asds in the file.

45656     me     what a use name
535353    McA    Supermonk *grin*
[download]

UPDATE: MidLifeXis had a very good question at Re: Hash of Array references. If you want to allow more than one entry per number you can collect them in an array. So change the lines

    $hash{$number} = {
        number => $number,
        user => $user,
        comment => $comment,
    }
[download]

to

    push @{$hash{$number}}, {
        number => $number,
        user => $user,
        comment => $comment,
    };
[download]

Regards
McA

I prefer to think of data-structures like this as complex ”records” that might be “indexed” in a number of different ways.   For example, define a single (anonymous) hashref to be your “record,” with a key for each “field” and a value that consists, as the case may be, either of a scalar or an array of values.   Your basic data store is an array of those hashrefs.

Then, for all of the ways that I need to locate those records ... well, here you have a pragmatic choice.

One way is to use additional hashes as indexes:   the keys are values being sought, and the values are either a single scalars (references are scalars), or an array of references.   You look up the key, then you have a reference to the record(s) that match that key.

But, pragmatically, you can also often just-as-well use the grep function to loop through the entire array, brute-force.   It is memory, after all, albeit virtual, but if you have “gobs of RAM,” it’s usually fast-enough just to search for whatever you want each time.

Still, when it comes down to locating “a record,” I do eventually want to come to that:   a single data-structure (a hashref), which, by itself and self-contained, contains all of whatever I need to know about that Thing.