Chapter 6
Working with Dollar Amounts
Because the $ metacharacter in a regular expression pattern indicates the end-of-line (or end-of-string) position, you cannot use that metacharacter to match the dollar currency symbol in a document. To match the dollar sign in a string, you must use the \$ escape sequence.
The sample file, DollarUsage.txt, is used to explore how to use the \$ escape sequence:
The pound, £, and US dollar, $, are major global currencies.
$99.00
99,00$
$1,000,000
$1000
$1,000
$1,000.00
$0.50
$2 # A Perl variable
$ 0.99
$myVariable
$2.25
As you can see, the $ sign may occur in situations other than simply being at the beginning of a sequence of numeric digits. For example, the first line indicates how the dollar sign might appear in a piece of narrative text. The third line, 99,00$, indicates how a dollar amount might be written in a non-English locale or, perhaps, how it might be written by someone who is not a native speaker of English.
Matching a literal $ sign is straightforward; you can simply use the following regular expression pattern, which will match all occurrences of the dollar sign in text:
\$
Figure 6-12 shows the application of that simple pattern in PowerGrep.
Suppose that you want to detect a dollar sign only when the dollar sign is followed by numeric digits. Even something seemingly this simple may not be entirely straightforward. For example, the third-to- last line has a space character following the $ sign, which you need to take into account if you want to match all relevant occurrences of the $ sign:
$ 0.99
158
String, Line, and Word Boundaries
Figure 6-12
Notice in the fourth-to-last line that a dollar sign may be followed by a numeric digit in a way that is acceptable as a dollar amount, yet has quite a different meaning:
$2 # A Perl variable
To know whether a problem like that is relevant to the data you are working on, you need to know your data and what is in it. For simplicity at the moment, assume that you want to match all occurrences of the $ sign that are followed by numeric digits with or without intervening whitespace.
Depending on the regular expression implementation, you can express a pattern for numeric digits in several ways: \d, [0-9], and [:digit:].
First, try to match situations where a dollar sign is followed by one or more numeric digits, followed by a period, followed by zero or more numeric digits. The following pattern expresses that:
\$[0-9]+\.[0-9]*
The \$ matches a literal dollar sign. The character class [0-9] matches a numeric digit, and the + quantifier indicates that there is at least one numeric digit. Following that is a literal period character indicated by the escape sequence \.. Finally, the pattern [0-9]* indicates that zero or more numeric digits can occur after the period.
Figure 6-13 shows this pattern applied against DollarUsage.txt when using OpenOffice.org Writer. Notice that only three of the examples in DollarUsage.txt are matched. Can you see, for example, why the examples $1,000,000 and $1000 have not been matched?
159
Chapter 6
Figure 6-13
Let’s deal with $1000 first. This doesn’t match because the pattern \. (which matches a period) does not have a match in the text. So to allow for dollar values that do not include a decimal point, you must add a ? quantifier to indicate that the decimal point is optional. The amended pattern, \.?, matches zero or one decimal points.
So if you run the amended pattern against DollarUsage.txt, you will see the result shown in Figure 6-14.
\$[0-9]+\.?[0-9]*
Notice that for dollar values that include commas as thousand separators or million separators, the comma prevents the pattern from matching all of the dollar value. Adding the following pattern allows for one or more space characters to give a final pattern for this chapter:
\$ *[0-9]+\.?[0-9]*
By using the * quantifier after the space character in the preceding pattern, you can allow for situations where there is more than a single space character after the dollar sign.
160
String, Line, and Word Boundaries
Figure 6-14
Revisiting the IP Address Example
In Chapter 5, we spent some time looking at how you could use character classes to match IP addresses, using the following sample file, IPLike.txt:
12.12.12.12
255.255.256.255
12.255.12.255
256.123.256.123
8.234.88.55
196.83.83.191
8.234.88,55
88.173.71.66
241.92.88.103
161
Chapter 6
Now that you have looked at the meaning and use of the ^ and $ metacharacters, you are in a position to take that example to a successful conclusion.
Try It Out |
Matching IP Addresses |
These instructions assume that you have closed OpenOffice.org Writer.
1.Open OpenOffice.org Writer, and open the test file IPLike.txt.
2.Open the Find & Replace dialog box using the Ctrl+F keyboard shortcut, and check the Regular Expressions and Match Case check boxes.
3.Enter the regular expression pattern ^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.) {3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$ in the Search For text box.
4.Click the Find All button, and inspect the results, as shown in Figure 6-15. Notice that the lines containing a value of 256 are not matched, which is what you wanted.
The regular expression pattern that works is shown here:
^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-
9][0-9]|[1-9][0-9]|[0-9])$
Figure 6-15
162
String, Line, and Word Boundaries
How It Works
First, let’s break the regular expression down into its component parts.
The initial ^ metacharacter indicates that there is a match only when matching is being attempted from a position at the beginning of a line.
The following component indicates several options for numeric values, each of which is followed by a literal period in the test text:
((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}
Remember that the escape sequence that matches a literal period is \.. If you had used a period in the pattern, the test text would have matched, but so would any alphanumeric character. This would have led to undesired matches such as the following, which is clearly not an IP address:
12G255F12H255
Using the . metacharacter would have lost much of the specificity that you obtain by using the \. metacharacter.
The first time the following pattern is processed, it immediately follows the position that indicates the start of a line:
((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}
That means a match succeeds if any of the options inside the nested parentheses are found between the start-of-line position and a literal period character. Given the way the options are constructed, only numeric values from 0 to 255 are matched.
The second time the following pattern is matched, you know that it is preceded by a literal period character (because the second attempt at matching follows the first attempt, which you know ends with a literal period):
((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}
In other words, you are looking for a numeric value from 0 to 255 that is preceded by a literal period character and followed by a literal period character.
Similarly, the third time an attempt is made to match, it is preceded by a literal period character (which matches the \. metacharacter from the second time of matching) and is followed by a period character.
If all preceding components of the pattern match, the regular expression engine attempts to match the pattern:
(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$
Because the pattern ends in a $ metacharacter, you know that it matches only a numeric value from 0 to 255 only when it follows a literal period character (which was the final character to match the third attempt to use the earlier component of the pattern) and when it is followed by a Unicode newline character.
163