#!/usr/bin/perl

# http://perlmonks.org/?node_id=1207789

use strict;
use warnings;
use Data::Dump 'pp';

$_ = 'special:1001:area_code:617|special:1001:zip_code:02205|special:1
+001:dow:0|special:1001:tod:14';

my %hash = /([^|:]+):([^|:]+)(?:\z|\|)/g;

pp \%hash;
[download]

Thanks so much for the response!

A few questions:

1. Do you alias Dumper as pp for Pretty Print, as in Python?

2. You use "=" rather than "=~" in the %hash assignment, how does it work in comparison

3. Would the regex assignment work just as well if you stuck the "big string" in between the hash assignment and the regex for example and skipped the $_ manipulation:

my %hash = $big_string = /([^|:]+):([^|:]+)(?:\z|\|)/g;
[download]

4. Can you elaborate on the Regex a little? I have questions but I'm not really sure where to start. The last clause includes an escaped "z" for example

Hi,

'Dumper' is exportwd by Data::Dumper. 'pp' is exported by Data::Dump.

I think you are missing the distinction of the implied '$_' variable via the regex. it would look like my %hash = $_ =~ /([^|:]+):([^|:]+)(?:\z|\|)/g; You can just drop the '$_' in this case like he did.

For your third question, the proper form using the '$big_string' var (instead of '$_') would be my %hash = $big_string =~ /([^|:]+):([^|:]+)(?:\z|\|)/g;

For your last question, the regex captures the 2 colon separated values that are immediately followed by the end of string, ('\z'), or by a pipe. He writes that using a non-capturing group, (?: ... ).

Here's my take on this general problem:

c:\@Work\Perl\monks>perl -wMstrict -MData::Dump -le
"my $rx_intro = qr{ special : \d{4} : }xms;
 ;;
 my $rx_key   = qr{ \w+ }xms;
 my $rx_val   = qr{ \d+ }xms;
 ;;
 my $rx_sep   = qr{  :  }xms;
 my $rx_delim = qr{ [|] }xms;
 ;;
 my $s =
   'special:1001:area_code:617|special:1001:zip_code:02205|special:100
+1:dow:0|special:1001:tod:14';
 ;;
 my $hashref = {
   $s =~ m{
     \G $rx_intro ($rx_key) $rx_sep ($rx_val) (?: $rx_delim | \z)
     }xmsg
   };
 dd $hashref;
"
{ area_code => 617, dow => 0, tod => 14, zip_code => "02205" }
[download]

Also, defining patterns separately allows one to validate the entire string before trying to extract anything from it. (Working with known-valid data is always nice.) Once a string is known to be in a particular, valid format, it is often quite simple to extract data fields from it.

Update: See also regex is not working as I intended for a recent discussion of what seems a similar problem, although you will have to drill down a way before you get to a specification of the structure of the data that fireblood is working with.

You could do a single split on either a '|' or a ':' then process the resulting stream two items (key and value) at a time filtering out the 'special' pairs. You could use the core List::Util->pairs() if on 5.20 or later, or List::MoreUtils->natatime() from CPAN if not, to process in pairs. I use groupsOf() which I wrote when when working in a restricted environment with early Perl versions and no chance of installing non-core modules.

use strict;
use warnings;

use Data::Dumper;

sub groupsOf (&$@);

my $dbStr =
   q{special:1001:area_code:617|special:1001:zip_code:02205|special:10
+01:dow:0|special:1001:tod:14};

my $rhRes = {
   groupsOf { $_[ 0 ] eq q{special} ? () : @_ } 2, split m{\||:}, $dbS
+tr
   };

print Data::Dumper->Dumpxs( [ $rhRes ], [ qw{ rhRes } ] );

sub groupsOf (&$@)
{
    my $rcToRun  = shift;
    my $groupsOf = shift;

    my $rcDoIt;
    $rcDoIt = sub
       {
           $rcToRun->(
              map shift, 1 .. ( @_ < $groupsOf ? @_ : $groupsOf )
              ),
           @_ ? &$rcDoIt : ();
       };
    &$rcDoIt;
}
[download]

The output.

$rhRes = {
           'tod' => '14',
           'zip_code' => '02205',
           'dow' => '0',
           'area_code' => '617'
         };
[download]

I hope this is of interest.

Update: Here's a version using List::Util->pairs(), the output is essentially the same.

use strict;
use warnings;

use List::Util qw{ pairs };
use Data::Dumper;

my $dbStr =
   q{special:1001:area_code:617|special:1001:zip_code:02205|special:10
+01:dow:0|special:1001:tod:14};

my $rhRes = {
   map   { @{ $_ } }
   grep  { $_->[ 0 ] ne q{special} }
   pairs split m{\||:}, $dbStr
   };

print Data::Dumper->Dumpxs( [ $rhRes ], [ qw{ rhRes } ] );
[download]

"Would a Map work here?" -> yes.

#!/usr/bin/perl

# http://perlmonks.org/?node_id=1207789

use strict;
use warnings;
use Data::Dumper;

my $big_string = 'special:1001:area_code:617|special:1001:zip_code:022
+05|special:1001:dow:0|special:1001:tod:14';

my %hash = map +(split /:/)[-2, -1], split /\|/, $big_string;

print Dumper \%hash;
[download]

Use a split to split the big string on vertical bars, then split each part by colon, and keep the last two sub-parts (which are the key and value), to pass on through the map to the hash.

Would a Map work here? I'm inexperienced with it but my thought is that it will only apply if we do a split on the initial string

I don't really see any problem with your way. I myself try to avoid using regex too much. (I know split uses regex, but still)