$string =~ s/([^<B>])($swapString)([^<\/B>])/$1<B>$2<\/B>$3/gi;
[download]

Actually, the second one handled it exactly like I wanted. Thanks, I tried a variance of that but noticed I placed the parenthesis the wrong way that time also.

However, the first one didn't seem to work how I thought it would, not sure I think I copied it exactly how you had it, but it didn't work correctly for me. It gave me this...

string after first - bar there is a <B>foo bar</B> and a <B>bar foo</B> and also foo <B>foo</B>and bar

...but the second substitution you gave worked perfectly. Thanks for showing me the err of my ways.

You could simply have your replacing regexp do all of the replacing at once. Regexp 'or' matches try to match the leftmost string first, so you could simply combine your two lists as such:

@array = ( "foo bar", "bar foo" );
@array2 = ( "foo", "bar" );
$string = "there is a foo bar and a bar foo and also foo and bar.";

print "string before - $string\n";

$swapString = join ("|", @array, @array2);
print "swapString 1 - $swapString\n";
$string =~ s/($swapString)/<B>$1<\/B>/gi;

print "string after first - $string\n";
[download]

string before - there is a foo bar and a bar foo and also foo and bar.
swapString 1 - foo bar|bar foo|foo|bar
string after first - there is a <B>foo bar</B> and a <B>bar foo</B> an
+d also <B>foo</B> and <B>bar</B>.
[download]

$swapString = join ("|", sort { length($b) <=> length($a) } @array, @a
+rray2);
[download]

If there's some other reason for needing to do this in two passes, disregard this solution.

stephen

$string =~ s/[^<B>]($swapString)[^<\/B>]/<B>$1<\/B>/gi;
[download]

I expect I could explain this more clearly if it wasn't first thing in the morning! Basically with your $string the regex above would be as well written...

$string =~ s/[^>]($swapString)[^<]/<B>$1<\/B>/gi;
[download]

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

$_ = "<b>foo</b> foo <b>bar</b> bar <b>foo</b> foo <b>bar</b> bar\n";
print;

s/(?!<b>)(foo|bar)(?!<\/b>)/XXX/gi;
print;
[download]

That is, if you make the join in join "|", (@array, @array2), then I get the following without modifying your regex at all:

string after first - there is a <B>foo bar</B> and a <B>bar foo</B> an
+d also <B>foo</B> and <B>bar</B>.
[download]

Thanks Masem and all.

I thought of doing it that way first, but in my mind I didn't think it would work because I thought something like this would happen...



string after first - <B>bar</B> there is a <B><B>foo</B> <B>bar</B></B
+> and a <B><B>bar</B> <B>foo</B></B> and also <B>foo</B> and <B>bar</
+B>.
[download]

See how the multiple words also matches for the single words and now we have compounded <B> tags. That's what I thought would have happened. Since I was using the g modifier I would think the regex would go through and transform the multiple word matches and then go through and match the single words also, which would not be good. But now I see that it would have worked. Next time I'll try my first instinct.

Thanks to all that posted.

$string =~ s/[^<B>]($swapString)[^<\/B>]/<B>$1<\/B>/gi;
[download]

...removed the first character before the match and the last character after the match.Can somebody explain this to me?

Yes this is quite simple on the left you match

[^<B>]  <- this matches any *single* char that is not a < B  >
($swapString) <- this put the match for $swapstring into $1
[^<\/B>]  <- this matches any *single* char that is not a < / B  >
[download]

So you are substituting the characters before and after $swapString, but as you do not capture them they naturally disappear as you do not replace them in the replacement.

The suggestion that you move the capture parenths kind of works but gives this output.

$string =~ s/([^<B>]($swapString)[^<\/B>])/<B>$1<\/B>/gi;

there is a <B>foo bar</B> and a <B>bar foo</B> and also<B> foo </B>and
+<B> bar.</B>
[download]

This is a better way to do things using what are know as lookback assertions.

$string =~ s/(?<!<B>)($swapString)(?!<\/B>)/<B>$1<\/B>/gi;

# this gives:

there is a <B>foo bar</B> and a <B>bar foo</B> and also <B>foo</B> and
+ <B>bar</B>.
[download]

which I expect is what you had in mind.

The lookback assertions give you a sneak peak of what is or is not immediately around a match. They do not eat up the string so you do not need to replace the bits they match.

The assertions are:

(?=pattern)
A zero-width positive look-ahead assertion. For example, /\w+(?=\t)/ matches a word followed by a tab, without including the tab in $&.

(?!pattern)
A zero-width negative look-ahead assertion. For example /foo(?!bar)/ matches any occurrence of ``foo'' that isn't followed by ``bar''. Note however that look-ahead and look-behind are NOT the same thing. You cannot use this for look-behind.

If you are looking for a ``bar'' that isn't preceded by a ``foo'', /(?!foo)bar/ will not do what you want. That's because the (?!foo) is just saying that the next thing cannot be ``foo''--and it's not, it's a ``bar'', so ``foobar'' will match. You would have to do something like /(?!foo)...bar/ for that. We say ``like'' because there's the case of your ``bar'' not having three characters before it. You could cover that this way: /(?:(?!foo)...|^.{0,2})bar/. Sometimes it's still easier just to say: if (/bar/ && $` !~ /foo$/)

For look-behind see below.

(?<=pattern)
A zero-width positive look-behind assertion. For example, /(?<=\t)\w+/ matches a word that follows a tab, without including the tab in $&. Works only for fixed-width look-behind.

(?<!pattern)
A zero-width negative look-behind assertion. For example /(?<!bar)foo/ matches any occurrence of ``foo'' that does not follow ``bar''. Works only for fixed-width look-behind.

hope this helps

tachyon