$file =
'0.000000e+000 1.502947e+000
1.162272e-012 1.508957e+001
2.324544e-012 1.508948e+000';

my $regex = {
 'first'  => qr{^(\S+)},  # anything non-blank from the beginning '^'
 'second' => qr{\s+(\S*)} # anything non-blank after the fist blank '\
+s+'
};

for(split '\n', $file){
 /$regex->{first}$regex->{second}/o # 'o' compiles the regex
 and # and upon success we take the first column and/or the second one
 print "Key: $1 and Value: $2\n";
 # So hash structure can have $hash{$1} = $2
}
[download]

Hi sh1n,

are we assigning these lines
'0.000000e+000 1.502947e+000
1.162272e-012 1.508957e+001
2.324544e-012 1.508948e+000';
to the variable $file. With '...' in the middle means some 2000 more pairs in continuity. Kindly explain your very first line of the code.
many thanks,
riz.

Hi riz,

The very first line is scalar instead of file handler for simplicity.
As fas as I understand more important is the way we match (or split) these two columns.
Do you really think that another 2000 lines matter something?
As conserns RAM or performance - it doesn't matter.

I wouldn't try to pattern match the scientific float... you could, but I think it's over-kill. If the data is tab delimited, then you can use that to distinguish the two values:

use strict;
while(<DATA>)
{
  # Get rid of trailing \n on line.
  chomp;

  # divide the line into two items based on tab
  my ($x, $y) = split("\t");    
  print "X:[$x]  Y: [$y]\n";
}

##OUTPUT:
# X:[0.000000e+000]  Y: [1.502947e+000]
# X:[1.162272e-012]  Y: [1.508957e+001]
# X:[2.324544e-012]  Y: [1.508948e+000]
# X:[0.000000e+000]  Y: [1.502947e+001]
# X:[1.162272e-012]  Y: [1.508941e+001]
# X:[2.324544e-012]  Y: [1.508940e+000]
# X:[0.000000e+000]  Y: [1.503947e+000]
# X:[1.162272e-012]  Y: [1.504947e+000]
# X:[2.324544e-012]  Y: [1.508900e+001]

##NOTE in data the two fields are tab delimited.

__DATA__
0.000000e+000    1.502947e+000
1.162272e-012    1.508957e+001
2.324544e-012    1.508948e+000
0.000000e+000    1.502947e+001
1.162272e-012    1.508941e+001
2.324544e-012    1.508940e+000
0.000000e+000    1.503947e+000
1.162272e-012    1.504947e+000
2.324544e-012    1.508900e+001
[download]

wouldn't try to pattern match the scientific float... you could, but I think it's over-kill.

Do you really have any idea what does  /^(\S+)\s+(\S*)/o do?



/^(\S+)\s+(\S*)/o and print FH "K: ", $1, "V: ", $2, "\n" while <DATA>
+;
[download]



where <DATA> contains over 22000 lines - less than a second
on my old (less than 1800 Mh cpu) home machine.

/^(\S+)\s+(\S*)/o

Matches one or more non-whitespace characters, followed by one or more whitespace characters, followed by 0 or more non-whitespace characters. The o indicates 'compile pattern only once'.

from perldoc perlop

 
If you want such a pattern to be compiled only once, add a "/o" after 
+the trailing delimiter.  This avoids expensive run-time recompilation
+s, and is useful when the value you are interpolating won’t change ov
+er the life of the script.
[download]

The parens capture those non-whitspace matches into variables $1 and $2 for use within the scope.

---

"Look, Shiny Things!" is not a better business strategy than compatibility and reuse.