When you use the /g modifier, you update a position within the string from which the next match attempt begins. This position is available by calling pos() on the string:

my $t = "cat hat bat mat";
print pos($t), "\n"; # -> (empty)
$t =~ m/at/g; print pos($t), "\n"; # -> 3
$t =~ m/at/g; print pos($t), "\n"; # -> 7
$t =~ m/at/g; print pos($t), "\n"; # -> 11
$t =~ m/hat/g; print pos($t), "\n"; # -> (empty)
$t =~ m/at/g; print pos($t), "\n"; # -> 3
[download]

(1) foreach my $update (@updateloc1){
(2)    for my $lin (@texlines){
(3)        if ($lin =~ /$update/g){
[download]

I have to admit I don't understand what you are trying to do. What is your expected output? Is the data always in order like the example? Are there multiple matches in the array?

Thanks for the responses, i realize the /g in updateloc1 should not have been added. I need to match each member of texlines exactly to the correct one in updateloc1, the problem occurs when its LakeO's turn and it should come back with the fourth member of updateloc1 (LakeO/stuf), it doesn't, (without /g or \b). What am i doing wrong?

One problem is that 'LakeO' is a substring of every string in @updateloc1. The regex /LakeO\b/ matches only with 'LakeO/stuf' because the latter string has a forward-slash ('/') in just the right position to match with the \b word-boundary metacharacter in the regex. Why it matches with the use of /g (if, indeed, it does) I will not be able to figure out without the ingestion of a lot more caffeine.

What is your definition of exact match in the context of the example you have given?

One thing strikes me about the 'reverse' regex approach you are using. If $s1 and $s2 are both 'pure' strings with no regex metacharacters (or with any metacharacters escaped), then the expression  $s1 =~ /$s2/ is true if $s2 is a substring of $s1. If this is true and the match is reversed,  $s2 =~ /$s1/ is true if $s2 equals $s1 by string comparison (i.e.,  $s2 eq $s1 is true).

So why not just use index (to find a substring) and eq (see the string Equality Operators) instead of trying to deal with the arcana of the operation of /g across multiple regexes?

Let me try to express the problem better, i did indeed confuse by including too much. Being less confused myself this morning, i have eliminated all except what i really need in the following and resolved it:

#!/usr/bin/perl -w
use strict;
my @updateloc1 = ("LakeOsouth/stuf", "LakeOeast/stuf", "LakeO2/stuf", 
+"LakeO/stuf");
my @texlines = ("LakeOsouth", "LakeOeast", "LakeO2", "LakeO");
for my $lin (@texlines){
    for my $update (@updateloc1){
        if ($update =~ /$lin/){
            print "The table column $lin matches the directory name $u
+pdate, so now do stuf in the subdir\n";
}    }    }
[download]

The above code works, except that when it gets to table column $lin = LakeO it matches all the members in updateloc1, so my struggle has been to make $lin match $update exactly to the forward slash. Well, after re-arranging the loops, the solution is simple: $update =~ /$lin\//. Should have taken a break much sooner.

Given a directory name and a path, is it true that the given directory is the first (i.e., top level) directory of the path?

# /usr/bin/perl

# for a given path and directory, determine if given directory
# is the first (i.e., top-level) directory in the path.
# accepts win32 or *nix path separators.
# accepts directory names with embedded spaces.


use warnings;
use strict;


# '\' repeated 4 times in next string to compensate for
# subsequent double-quote-like interpolation.
my $seps = '\\\\/';  # possible path separator chars: win & *nix

# regexes to recognize parts of a path.  maybe a bit crude.
my $rx_path_sep = qr{  [$seps]  }xms;  # path separator
my $rx_dir_like = qr{ [^$seps]+ }xms;  # directory name

my @weird = ('', '\\', '/');  # extra weird strings for testing

# first DATA line is possible top-level directory names for testing.
my @dirs = (@weird, split ',', do { chomp(my $d = <DATA>); $d });

# all other DATA lines are paths for testing.
my @paths = (@weird, map { chomp;  split ',' } <DATA>);

# pre-compile directory names to regexes recognizing them
# as first (i.e., top-level) directory in a path.
my %toplevel = map {
    $_ =>                       # each possible dir paired with regex
    qr{ \A (?= $rx_dir_like)    # dir-like string is first
        \Q$_\E                  # and is the given dir
        (?: $rx_path_sep | \z)  # followed by sep or end of string
      }xms
    } @dirs;

# check all permutations.
for my $path (@paths) {
    for my $dir (@dirs) {
        printf qq(%10s begins '%s' \n), qq('$dir'), $path
            if $path =~ $toplevel{ $dir };
            # if $path =~ m{ \A (?= $rx_dir_like) \Q$dir\E
            #                (?: $rx_path_sep | \z)
            #              }xms;
        }
    }


__DATA__
abc,abcd,abcde,x,ab c,ab cd,a+b,foo
abc,abc\,abc/x,abcd,abcd/,abcd\x,abcde,abcde/,abcde/x
x,x/,x/abc,abc\abcd,abcd/abc,abc\abc,abc\abcd/abcde,abcde\abcd/abc
ab c,ab c\,ab c/abc,ab cd,ab cd\,ab cd\x,ab c/abc
ab cd\ab c,a+b,a+b/,a+b\abc,bar,bar\zot,\,/,\abc,/abc,\x,/x
/\,\/,/\x,\/x
[download]

Output:

     'abc' begins 'abc'
     'abc' begins 'abc\'
     'abc' begins 'abc/x'
    'abcd' begins 'abcd'
    'abcd' begins 'abcd/'
    'abcd' begins 'abcd\x'
   'abcde' begins 'abcde'
   'abcde' begins 'abcde/'
   'abcde' begins 'abcde/x'
       'x' begins 'x'
       'x' begins 'x/'
       'x' begins 'x/abc'
     'abc' begins 'abc\abcd'
    'abcd' begins 'abcd/abc'
     'abc' begins 'abc\abc'
     'abc' begins 'abc\abcd/abcde'
   'abcde' begins 'abcde\abcd/abc'
    'ab c' begins 'ab c'
    'ab c' begins 'ab c\'
    'ab c' begins 'ab c/abc'
   'ab cd' begins 'ab cd'
   'ab cd' begins 'ab cd\'
   'ab cd' begins 'ab cd\x'
    'ab c' begins 'ab c/abc'
   'ab cd' begins 'ab cd\ab c'
     'a+b' begins 'a+b'
     'a+b' begins 'a+b/'
     'a+b' begins 'a+b\abc'
[download]