The "/g" modifier specifies global pattern matching--that is, matching as many times as possible within the string. How it behaves depends on the context. In list context, it returns a list of the substrings matched by any capturing parentheses in the regular expression. If there are no parentheses, it returns a list of all the matched strings, as if there were parentheses around the whole pattern.

In scalar context, each execution of "m//g" finds the next match, returning true if it matches, and false if there is no further match. The position after the last match can be read or set using the pos() function; see "pos" in perlfunc. A failed match normally resets the search position to the beginning of the string, but you can avoid that by adding the "/c" modifier (e.g. "m//gc"). Modifying the target string also resets the search position.

use strict;
use warnings;

my $regexp = 'Perl Monks';

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound..";
} else {
    print "\nNot Found..";
}

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound.1.";
} else {
    print "\nNot Found.1.";
}

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound.2.";
} else {
    print "\nNot Found.2.";
}
print "\n";
__END__
Found..
Not Found.1.
Found.2.
[download]

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Thanks for the above replies..

Hi shmem

I added modifier /c also in the match. Please check the below code. But, still the pos() for regexp is not reset. Could you please help me how to reset the position for regexp variable using modifier

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

my $regexp = 'Perl Monks';

print "\nPos...", pos($regexp);

if($regexp =~ m/^Perl Monks/gci) {
    print "\nFound..";
} else {
    print "\nNot Found..";
}

print "\nPos..1.", pos($regexp);

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound.1.";
} else {
    print "\nNot Found.1.";
}
[download]

I added modifier /c also in the match. Please check the below code. But, still the pos() for regexp is not reset.

which is the expected behaviour, since (perlop again):

Options are:

c  Do not reset search position on a failed match when /g is in effect.
g  Match globally, i.e., find all occurrences.

The pos() is retained in all cases until the next match is attempted, so you have to remove the /g modifier on the second match, as casiano correctly noted, which will reset pos() just before the regep engine tries to match the second time.

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

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

my $regexp = 'Perl Monks';

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound..";
} else {
    print "\nNot Found..";
}
print "\npos = ".pos($regexp)."\n";

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound.1.";
} else {
    print "\nNot Found.1.";
}
[download]

when you run the code you obtain:

$ perl /tmp/prueba.pl

Found..
pos = 10
[download]

That means the first time you are looking for the first match, second time for the second match - but there is no second match (and never will, because your regexp is anchored).

See perlre and perlop for details.

Do gube's original question and the fine answers above not point also to some optomization (a single instance in the symbol table of the two identical if...} clauses? Note that adding the third time thru, but using a variant if... (no 'g') produces a match there but then repeating the variant if...} finds no match in 4.

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

my $regexp = 'Perl Monks';
my $regexp2 = 'Perl Monks is a wonderful place to visit'; # even if No
+de Reaper is sometimes a bit loud


if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound.0.";
} else {
    print "\nNot Found.0.";
}

if($regexp =~ m/^Perl Monks/gi) {
    print "\nFound.1.";
} else {
    print "\nNot Found.1.";
}

if($regexp =~ m/^Perl Monks/i) {    # No 'g' 
    print "\nFound.2.";
} else {
    print "\nNot Found.2.";
}


if($regexp2 =~ m/^Perl Monks/gi) {  # 'g' is back, but different $var 
+being tested
    print "\nFound.3.";
} else {
    print "\nNot Found.3.";
}


if($regexp2 =~ m/^Perl Monks/gi) {  # second identical use of $regex2 
+and match
    print "\nFound.4.";
} else {
    print "\nNot Found.4.";
}
[download]

perl gube_g.pl

Found.0.
Not Found.1.
Found.2.
Found.3.
Not Found.4.
[download]

Do gube's original question and the fine answers above not point also to some optomization (a single instance in the symbol table of the two identical if...} clauses?

No^*. It all has to do with match positions not being reset until a match failed, if /g is in effect.

Without /g, those internal state variables are reset before each match; with /g, they are reset after a match failed.

*) which doesn't mean there isn't such optimization, merely that the behaviour gives no evidence about that.

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

That statement needs to be qualified. It is far from always true. The /g modifier is part of Perl for a reason and there are many things one can do with it that are much more difficult without it.

$foo = (join ', ', 'abacadaeafagahaiaj' =~ m/a/g );
print $foo . "\n";
[download]

/g can be useful. But if you just want to know if something matches (which for me is most of the time), you don't need it.

The cases where m///g is useful are where:

• you need to save the position of the last match, or
• you're counting or saving the matches for later use (assigning the result of m/// to a variable)

In practice, I find myself using /g only in substitutions.