Mastering JavaScript

Chapter 3
An example could be /^([XYZ])a\1/, which matches a string that starts with any
of the X, Y, or Z characters followed by an a and followed by whatever character
matched the first capture. This is very different from /[XYZ] a[XYZ]/. The character
following a can't be any of X, or Y, or Z, but must be whichever one of those that
triggered the match for the first character. Backreferences are used with String's
replace() method using the special character sequences, $1, $2, and so on. Suppose
that you want to change the 1234 5678 string to 5678 1234. The following code
accomplishes this:
var orig = "1234 5678";
var re = /(\d{4}) (\d{4})/;
var modifiedStr = orig.replace(re, "$2 $1");
console.log(modifiedStr); //outputs "5678 1234"
In this example, the regular expression has two groups each with four digits. In the
second argument of the replace() method, $2 is equal to 5678 and $1 is equal to
1234, corresponding to the order in which they appear in the expression.
Greedy and lazy quantifiers
All the quantifiers that we discussed so far are greedy. A greedy quantifier starts
looking at the entire string for a match. If there are no matches, it removes the last
character in the string and reattempts the match. If a match is not found again, the
last character is again removed and the process is repeated until a match is found or
the string is left with no characters.
The \d+ pattern, for example, will match one or more digits. For example, if your
string is 123, a greedy match would match 1, 12, and 123. Greedy pattern h.+l would
match hell in a string hello—which is the longest possible string match. As \d+ is
greedy, it will match as many digits as possible and hence the match would be 123.
In contrast to greedy quantifiers, a lazy quantifier matches as few of the quantified
tokens as possible. You can add a question mark (?) to the regular expression to
make it lazy. A lazy pattern h.?l would match hel in the string hello—which is the
shortest possible string.
The \w*?X pattern will match zero or more words and then match an X. However, a
question mark after * indicates that as few characters as possible should be matched.
For an abcXXX string, the match can be abcX, abcXX, or abcXXX. Which one should
be matched? As *? is lazy, as few characters as possible are matched and hence the
match is abcX.
With this necessary information, let's try to solve some common problems using
regular expressions.
[ 85 ]
www.it-ebooks.info