PERL Spliting

finnpark

Hi,

I want to split $input1 into 2 separate variables for each part of the time:

$in1 = '5.30';

I want a new var call $part1 to be equal to 5 and $part2 to be equal to 30. I want to split the time up into 2 separate variables.

Is there a way of doing this without using the split function cause the split function did not seem to work for me.

I got code like the following on here before for splitting up something else but how do I do it for the above?:


if ($inputexample =~ /(\d+):(\d+) (.*)/) {
$hour = $1;
$minute = $2;


}

cgarvey

changing your example slightly ...

  if( $inputexample =~ /(\d+)\.(\d+)/) {
    $hour = $1;
    $minute = $2;
  }

Breaking the bits between the // ..
(\d+) Match any numeric digit, or digits (i.e. 1 or more digits), and store them in $1
\. Match a full stop
(\d+) Match any numeric digit, or digits (i.e. 1 or more digits), and store them in $2

.cg

finnpark

Many thanks.

I also amnaged to get the split function going, I put in square brackets around the dot like [.] and it did the trick but thanks again anywya for your help.

daymobrew

I profiled three variations of the code here. I always believed that completeness in a regular expression was best, but the benchmark results for this don't comfirm this.

/(\d+)\.(\d+)/ - Match explicit dot (.). No ^$ anchors. Called DotNoAnchor in the code below.
/(\d+)[.](\d+)/ - Match class of chars (only a dot here). No anchors. ClassNoAnchor.
/^(\d+)\.(\d+)$/ - Match dot. Use anchors. DotWithAnchor.
I felt that the last one would be best because it tells the regex engine where to start looking for matches thus saving it some work.

The code below uses the Benchmark module (a standard module) to compare the three regular expressions.

[PHP]#!/usr/bin/perl -w

use strict;
use Benchmark 'timethese';

my $in = '5.30';
my ( $hr, $min );
# Run the 3 subroutines 10 million times.
timethese( 10_000_000,
{ 'DotNoAnchor' => sub { if( $in =~ /(\d+)\.(\d+)/) { $hr = $1; $min = $2; } },
'ClassNoAnchor' => sub { if( $in =~ /(\d+)[.](\d+)/) { $hr = $1; $min = $2; } },
'DotWithAnchor' => sub { if( $in =~ /^(\d+)\.(\d+)$/) { $hr = $1; $min = $2; } } } );[/PHP]

$ perl -w split-time.pl
Benchmark: timing 10000000 iterations of ClassNoAnchor, DotNoAnchor, DotWithAnchor...
ClassNoAnchor: 22 wallclock secs (22.04 usr +  0.01 sys = 22.05 CPU) @ 453473.61/s (n=10000000)
DotNoAnchor: 21 wallclock secs (22.04 usr +  0.00 sys = 22.04 CPU) @ 453679.34/s (n=10000000)
DotWithAnchor: 24 wallclock secs (24.80 usr +  0.00 sys = 24.80 CPU) @ 403290.85/s (n=10000000)

So, the DotNoAnchor is slighly faster than ClassNoAnchor. I was surprised that DotWithAnchor was slowest.