$foo =~ s/ab/cd/i for 1..5;
[download]

____________________________________________________
** The Third rule of perl club is a statement of fact: pod is sexy.

$foo =~ s/ab/cd/i for 1..5;

The above seems to work very well. I'm not sure I see the advantages to the more complex phrasings below. Please correct me if I'm wrong.

Thanks Podmaster.

The main problem is that it doesn't deal with overlapping regexes very well, (i.e. your regex matches parts of your replacement string).

Suppose you have the string:

"The wodchuck at the zo stod on the stoop";
[download]

You realize that it will only make sense after replacing the first three 'o's with 'oo's

my $str = "The wodchuck at the zo stod on the stoop";
$str =~ s/o/oo/i for 1..3;
print "$str\n";
[download]

Oops, that yields:

The woooodchuck at the zo stod on the stoop
[download]

The other solutions would have produced:

The woodchuck at the zoo stood on the stoop
[download]

-Blake

Now the current (perl5) syntax for a regex assertion is very awkward. This will do it:

/(?(?{NOTCOND})(?!))/
[download]

So, you can try this:

my $i = 0;
s/ab(?(?{++$i>5})(?!))/cd/g;
[download]

This will indeed stop matching after the fifth match, producing the desired result; but it will not stop trying: it will go through the whole string, and if your string contains 50 substrings "ab", then the assertion code will be called 50 times. So for long strings, it won't be too efficient.

How about a modified version of japhy's code.

#!/usr/bin/perl -wT
use strict;

my $string  = 'abc ' x 10;
my $search  = 'ab';
my $replace = 'CD';

print "$string\n";

my $i = 0;
while ($string =~ /$search/gi) {
  substr($string, $-[0], $+[0]-$-[0], $replace);
  last if ++$i == 4;
  pos($string) = $-[0] + 1;
}

print "$string\n";

__END__
abc abc abc abc abc abc abc abc abc abc
CDc CDc CDc CDc abc abc abc abc abc abc
[download]

Update: Doh! I didn't see your very similar solution before I posted....

-Blake

Doh! I didn't see your very similar solution before I posted....

It is very similar, isn't it? And I hadn't seen yaphy's solution before I posted mine. Now, it left me wondering: is setting pos() necessary, or will Perl DWIM, and continue matching at the same point in the (original) string without help? That's what s///g does.

Well, it turns out that it appears to be using an offset in the string to keep track of where it was. So it is necessary.

$_ = 'abxy' x 12;
for(my $i = 0; m/ab/g and $i++<5;) {
    substr($_, $-[0], $+[0]-$-[0]) = 'abXab';
}
print;
[download]

Result: abXabXabXabXabXabxyabxyabxyabxyabxyabxyabxyabxyabxyabxyabxyabxy

Not good.

$_ = 'abxy' x 12;
for(my $i = 0; m/ab/g and $i++<5;) {
    substr($_, $-[0], $+[0]-$-[0]) = 'abXab';
    pos = $-[0]+5;
}
print;
[download]

Result: abXabxyabXabxyabXabxyabXabxyabXabxyabxyabxyabxyabxyabxyabxyabxy

Good.

p.s. I noticed this, which is also very awkward:

my $length = length(substr($_, 2, 2) = 'abXab');
print $length;
[download]

prints 2, not 5. What happened to the rule: the value of an assignment as an expression, is what you assign?

$_ = 'abxy' x 15;
for(my $i = 0; m/ab/g and $i++<5;) {
    substr($_, $-[0], $+[0]-$-[0]) = 'ABC';
}
print;
[download]

That looks about right to me.

Update: See my follow-up in another subthread, that in general, you need to set pos() whenever you change the original string before continueing searching.