You want to replace all the matches of a particular regular expression, but only within certain sections of the subject string. Another regular expression matches the text between the sections. In other words, you want to search and replace through all parts of the subject string not matched by the other regular expression.
Say you have an HTML file in which you want to replace straight
double quotes with smart (curly) double quotes, but you only want to
replace the quotes outside of HTML tags. Quotes within HTML tags must
remain plain ASCII straight quotes, or your web browser won’t be able to parse the
HTML anymore. For example, you want to turn
"text" <span class="middle">"text"</span>
"text" into “text” <span class="middle">“text”</span>
“text”.
string resultString = null;
Regex outerRegex = new Regex("<[^<>]*>");
Regex innerRegex = new Regex(""([^"]*)"");
// Find the first section
int lastIndex = 0;
Match outerMatch = outerRegex.Match(subjectString);
while (outerMatch.Success) {
// Search and replace through the text between this match,
// and the previous one
string textBetween =
subjectString.Substring(lastIndex, outerMatch.Index - lastIndex);
resultString += innerRegex.Replace(textBetween, "u201C$1u201D");
lastIndex = outerMatch.Index + outerMatch.Length;
// Copy the text in the section unchanged
resultString += outerMatch.Value;
// Find the next section
outerMatch = outerMatch.NextMatch();
}
// Search and replace through the remainder after the last regex match
string textAfter = subjectString.Substring(lastIndex,
subjectString.Length - lastIndex);
resultString += innerRegex.Replace(textAfter, "u201C$1u201D");Dim ResultString As String = Nothing
Dim OuterRegex As New Regex("<[^<>]*>")
Dim InnerRegex As New Regex("""([^""]*)""")
'Find the first section
Dim LastIndex = 0
Dim OuterMatch = OuterRegex.Match(SubjectString)
While OuterMatch.Success
'Search and replace through the text between this match,
'and the previous one
Dim TextBetween = SubjectString.Substring(LastIndex,
OuterMatch.Index - LastIndex);
ResultString += InnerRegex.Replace(TextBetween,
ChrW(&H201C) + "$1" + ChrW(&H201D))
LastIndex = OuterMatch.Index + OuterMatch.Length
'Copy the text in the section unchanged
ResultString += OuterMatch.Value
'Find the next section
OuterMatch = OuterMatch.NextMatch
End While
'Search and replace through the remainder after the last regex match
Dim TextAfter = SubjectString.Substring(LastIndex,
SubjectString.Length - LastIndex);
ResultString += InnerRegex.Replace(TextAfter,
ChrW(&H201C) + "$1" + ChrW(&H201D))StringBuffer resultString = new StringBuffer();
Pattern outerRegex = Pattern.compile("<[^<>]*>");
Pattern innerRegex = Pattern.compile(""([^"]*)"");
Matcher outerMatcher = outerRegex.matcher(subjectString);
int lastIndex = 0;
while (outerMatcher.find()) {
// Search and replace through the text between this match,
// and the previous one
String textBetween = subjectString.substring(lastIndex,
outerMatcher.start());
Matcher innerMatcher = innerRegex.matcher(textBetween);
resultString.append(innerMatcher.replaceAll("u201C$1u201D"));
lastIndex = outerMatcher.end();
// Append the regex match itself unchanged
resultString.append(outerMatcher.group());
}
// Search and replace through the remainder after the last regex match
String textAfter = subjectString.substring(lastIndex);
Matcher innerMatcher = innerRegex.matcher(textAfter);
resultString.append(innerMatcher.replaceAll("u201C$1u201D"));var result = "";
var outerRegex = /<[^<>]*>/g;
var innerRegex = /"([^"]*)"/g;
var outerMatch = null;
var lastIndex = 0;
while (outerMatch = outerRegex.exec(subject)) {
if (outerMatch.index == outerRegex.lastIndex) outerRegex.lastIndex++;
// Search and replace through the text between this match,
// and the previous one
var textBetween = subject.slice(lastIndex, outerMatch.index);
result += textBetween.replace(innerRegex, "u201C$1u201D");
lastIndex = outerMatch.index + outerMatch[0].length;
// Append the regex match itself unchanged
result += outerMatch[0];
}
// Search and replace through the remainder after the last regex match
var textAfter = subject.slice(lastIndex);
result += textAfter.replace(innerRegex, "u201C$1u201D");$result = '';
$lastindex = 0;
while (preg_match('/<[^<>]*>/', $subject, $groups, PREG_OFFSET_CAPTURE,
$lastindex)) {
$matchstart = $groups[0][1];
$matchlength = strlen($groups[0][0]);
// Search and replace through the text between this match,
// and the previous one
$textbetween = substr($subject, $lastindex, $matchstart-$lastindex);
$result .= preg_replace('/"([^"]*)"/', '“$1”', $textbetween);
// Append the regex match itself unchanged
$result .= $groups[0][0];
// Move the starting position for the next match
$lastindex = $matchstart + $matchlength;
if ($matchlength == 0) {
// Don't get stuck in an infinite loop
// if the regex allows zero-length matches
$lastindex++;
}
}
// Search and replace through the remainder after the last regex match
$textafter = substr($subject, $lastindex);
$result .= preg_replace('/"([^"]*)"/', '“$1”', $textafter);use encoding "utf-8";
$result = '';
while ($subject =~ m/<[^<>]*>/g) {
$match = $&;
$textafter = $';
($textbetween = $`) =~ s/"([^"]*)"/x{201C}$1x{201D}/g;
$result .= $textbetween . $match;
}
$textafter =~ s/"([^"]*)"/x{201C}$1x{201D}/g;
$result .= $textafter;innerre = re.compile('"([^"]*)"')
result = "";
lastindex = 0;
for outermatch in re.finditer("<[^<>]*>", subject):
# Search and replace through the text between this match,
# and the previous one
textbetween = subject[lastindex:outermatch.start()]
result += innerre.sub(u"u201C\1u201D", textbetween)
lastindex = outermatch.end()
# Append the regex match itself unchanged
result += outermatch.group()
# Search and replace through the remainder after the last regex match
textafter = subject[lastindex:]
result += innerre.sub(u"u201C\1u201D", textafter)Recipe 3.13 explains how to use two regular expressions to find matches (of the second regex) only within certain sections of the file (matches of the first regex). The solution for this recipe uses the same technique to search and replace through only certain parts of the subject string.
It is important that the regular expression you use to find the
sections continues to work on the original subject string. If you modify
the original subject string, you have to shift the starting position for
the regex that finds the section as the inner regex adds or deletes
characters. More importantly, the modifications can have unintended side
effects. For example, if your outer regex uses the anchor ‹^› to match something at the start
of a line, and your inner regex inserts a line break at the end of the
section found by the outer regex, then ‹^› will match right after the previous section
because of the newly inserted line break.
Though the solutions for this recipe are quite long, they’re very
straightforward. Two regular expressions are used. The “outer” regular
expression, ‹<[^<>]*>›, matches a pair of angle
brackets and anything between them, except angle brackets. This is a
crude way of matching any HTML tag. This regex works fine as long as the
HTML file does not contain any literal angle brackets that were
(incorrectly) not encoded as entities. We implement this regular
expression with the same code shown in Recipe 3.11. The only difference is that the
placeholder comment in that code that said where to use the match was
replaced by the code that does the actual search-and-replace.
The search-and-replace within the loop follows the code shown in Recipe 3.14. The subject string for the search-and-replace is the text between the previous match of the outer regex and the current match. We append the result of the inner search-and-replace to the overall result string. We also append the current match of the outer regular expression unchanged.
When the outer regex fails to find further matches, we run the inner search-and-replace once more, on the text after the last match of the outer regex.
The regex ‹"([^"]*)"›, used for the search-and-replace inside
the loop, matches a pair of double-quote characters and anything between
them, except double quotes. The text between the quotes is captured into
the first capturing group.
For the replacement text, we use a reference to the first
capturing group, which is placed between two smart quotes. The smart
quotes occupy Unicode code points U+201C and U+201D. Normally, you can simply paste the
smart quotes directly into your source code. Visual Studio 2008,
however, insists on being clever and automatically replaces literal
smart quotes with straight quotes.
In a regular expression, you can match a Unicode code point with
‹u201C› or ‹x{201C}›, but none of the
programming languages discussed in this book support such tokens as part
of the replacement text. If an end user wants to insert smart quotes
into the replacement text he types into an edit control, he’ll have to
paste them in literally from a character map. In your source code, you
can use Unicode escapes in the replacement text, if your language
supports such escapes as part of literal strings. For example, C# and
Java support u201C at the string
level, but VB.NET does not offer a way to escape Unicode characters in
strings. In VB.NET, you can use the ChrW function to
convert a Unicode code point into a character.
The Perl and Ruby solutions use two special variables available
in these languages that we haven’t explained yet. $`
(dollar backtick) holds the part of the text to the left of the
subject match, and $'
(dollar single quote) holds the part of the text to the right of the
subject match. Instead of iterating over the matches in the original
subject string, we start a new search on the part of the string after
the previous match. This way, we can easily retrieve the text between
the match and the previous one with $`.
This recipe uses techniques introduced by three earlier recipes. Recipe 3.11 shows code to iterate over all the matches a regex can find in a string. Recipe 3.15 shows code to find regex matches within the matches of another regex. Recipe 3.16 shows code to search and replace with replacements generated in code for each regex match instead of using a fixed replacement text for all matches.