Compare Revisions

Writing a Regular Expression Pattern

Change Revisions

Revision 118394:

Revision 118394 by user01 on

Revision 118395:

Revision 118395 by user01 on

Writing a Regular Expression Pattern
Writing a Regular Expression Pattern

Revision 118394
Revision 118395
t11      A regular expression pattern is composed of simple charactet
>rs, such as <code>/abc/</code>, or a combination of simple and sp 
>ecial characters, such as <code>/ab*c/</code> or <code>/Chapter ( 
>\d+)\.\d*/</code>. The last example includes parentheses which ar 
>e used as a memory device. The match made with this part of the p 
>attern is remembered for later use, as described in <a href="/en/ 
>Parenthesized_Substring_Matches" title="en/Core_JavaScript_1.5_Gu 
>g_Matches">Using Parenthesized Substring Matches</a>. 
12    </p>
13    <h2>
14      Using Simple Patterns
15    </h2>
16    <p>
17      Simple patterns are constructed of characters for which you
> want to find a direct match. For example, the pattern /abc/ matc 
>hes character combinations in strings only when exactly the chara 
>cters 'abc' occur together and in that order. Such a match would  
>succeed in the strings "Hi, do you know your abc's?" and "The lat 
>est airplane designs evolved from slabcraft." In both cases the m 
>atch is with the substring 'abc'. There is no match in the string 
> "Grab crab" because it does not contain the substring 'abc'. 
18    </p>
19    <h2>
20      Using Special Characters
21    </h2>
22    <p>
23      When the search for a match requires something more than a 
>direct match, such as finding one or more b's, or finding white s 
>pace, the pattern includes special characters. For example, the p 
>attern <code>/ab*c/</code> matches any character combination in w 
>hich a single 'a' is followed by zero or more 'b's (* means 0 or  
>more occurrences of the preceding item) and then immediately foll 
>owed by 'c'. In the string "cbbabbbbcdebc," the pattern matches t 
>he substring 'abbbbc'. 
24    </p>
25    <p>
26      The following table provides a complete list and descriptio
>n of the special characters that can be used in regular expressio 
27    </p>
28    <table class="fullwidth-table">
29      <tbody>
30        <tr>
31          <th>
32            Character
33          </th>
34          <th>
35            Meaning
36          </th>
37        </tr>
38        <tr>
39          <td>
40            \
41          </td>
42          <td>
43            Either of the following:
44            <ul>
45              <li>For characters that are usually treated literal
>ly, indicates that the next character is special and not to be in 
>terpreted literally. For example, <code>/b/</code> matches the ch 
>aracter 'b'. By placing a backslash in front of b, that is by usi 
>ng <code>/\b/</code>, the character becomes special to mean match 
> a word boundary. 
46              </li>
47              <li>For characters that are usually treated special
>ly, indicates that the next character is not special and should b 
>e interpreted literally. For example, * is a special character th 
>at means 0 or more occurrences of the preceding item should be ma 
>tched; for example, <code>/a*/</code> means match 0 or more a's.  
>To match * literally, precede it with a backslash; for example, < 
>code>/a\*/</code> matches 'a*'. 
48              </li>
49            </ul>
50          </td>
51        </tr>
52        <tr>
53          <td>
54            ^
55          </td>
56          <td>
57            Matches beginning of input. If the multiline flag is 
>set to true, also matches immediately after a line break characte 
>r. For example, <code>/^A/</code> does not match the 'A' in "an A 
>", but does match the first 'A' in "An A". 
58          </td>
59        </tr>
60        <tr>
61          <td>
62            $
63          </td>
64          <td>
65            Matches end of input. If the multiline flag is set to
> true, also matches immediately before a line break character. Fo 
>r example, <code>/t$/</code> does not match the 't' in "eater", b 
>ut does match it in "eat". 
66          </td>
67        </tr>
68        <tr>
69          <td>
70            *
71          </td>
72          <td>
73            Matches the preceding character 0 or more times. For 
>example, <code>/bo*/</code> matches 'boooo' in "A ghost booooed"  
>and 'b' in "A bird warbled", but nothing in "A goat grunted". 
74          </td>
75        </tr>
76        <tr>
77          <td>
78            +
79          </td>
80          <td>
81            Matches the preceding character 1 or more times. Equi
>valent to {1,}. For example, <code>/a+/</code> matches the 'a' in 
> "candy" and all the a's in "caaaaaaandy". 
82          </td>
83        </tr>
84        <tr>
85          <td>
86            ?
87          </td>
88          <td>
89            Matches the preceding character 0 or 1 time.
90            <p>
91              For example, <code>/e?le?/</code> matches the 'el' 
>in "angel" and the 'le' in "angle." 
92            </p>
93            <p>
94              If used immediately after any of the quantifiers *,
> +,&nbsp;?, or {}, makes the quantifier non-greedy (matching the  
>minimum number of times), as opposed to the default, which is gre 
>edy (matching the maximum number of times). For example, using /\ 
>d+/ non-global match "123abc" return "123", if using /\d+?/, only 
> "1" will be matched. 
95            </p>Also used in lookahead assertions, described unde
>r x(?=y) and x(?!y) in this table. 
96          </td>
97        </tr>
98        <tr>
99          <td>
100            .
101          </td>
102          <td>
103            (The decimal point) matches any single character exce
>pt the newline character. For example, <code>/.n/</code> matches  
>'an' and 'on' in "nay, an apple is on the tree", but not 'nay'. 
104          </td>
105        </tr>
106        <tr>
107          <td>
108            (x)
109          </td>
110          <td>
111            Matches 'x' and remembers the match. These are called
> capturing parentheses. For example, <code>/(foo)/</code> matches 
> and remembers 'foo' in "foo bar." The matched substring can be r 
>ecalled from the resulting array's elements {{ mediawiki.external 
>("1") }}, ..., {{ mediawiki.external('n') }}. 
112          </td>
113        </tr>
114        <tr>
115          <td>
116            (?:x)
117          </td>
118          <td>
119            Matches 'x' but does not remember the match. These ar
>e called non-capturing parentheses. The matched substring can not 
> be recalled from the resulting array's elements {{ mediawiki.ext 
>ernal("1") }}, ..., {{ mediawiki.external('n') }}. 
120          </td>
121        </tr>
122        <tr>
123          <td>
124            x(?=y)
125          </td>
126          <td>
127            Matches 'x' only if 'x' is followed by 'y'. For examp
>le, <code>/Jack(?=Sprat)/</code> matches 'Jack' only if it is fol 
>lowed by 'Sprat'. <code>/Jack(?=Sprat|Frost)/</code> matches 'Jac 
>k' only if it is followed by 'Sprat' or 'Frost'. However, neither 
> 'Sprat' nor 'Frost' is part of the match results. 
128          </td>
129        </tr>
130        <tr>
131          <td>
132            x(?!y)
133          </td>
134          <td>
135            Matches 'x' only if 'x' is not followed by 'y'. For e
>xample, <code>/\d+(?!\.)/</code> matches a number only if it is n 
>ot followed by a decimal point. The regular expression <code>/\d+ 
>(?!\.)/.exec("3.141")</code> matches '141' but not '3.141'. 
136          </td>
137        </tr>
138        <tr>
139          <td>
140            x|y
141          </td>
142          <td>
143            Matches either 'x' or 'y'. For example, <code>/green|
>red/</code> matches 'green' in "green apple" and 'red' in "red ap 
144          </td>
145        </tr>
146        <tr>
147          <td>
148            {n}
149          </td>
150          <td>
151            Where n is a positive integer. Matches exactly n occu
>rrences of the preceding character. For example, <code>/a{2}/</co 
>de> doesn't match the 'a' in "candy," but it matches all of the a 
>'s in "caandy," and the first two a's in "caaandy." 
152          </td>
153        </tr>
154        <tr>
155          <td>
156            {n,}
157          </td>
158          <td>
159            Where n is a positive integer. Matches at least n occ
>urrences of the preceding character. For example, <code>/a{2,}/</ 
>code> doesn't match the 'a' in "candy", but matches all of the a' 
>s in "caandy" and in "caaaaaaandy." 
160          </td>
161        </tr>
162        <tr>
163          <td>
164            {n,m}
165          </td>
166          <td>
167            Where n and m are positive integers. Matches at least
> n and at most m occurrences of the preceding character. For exam 
>ple, <code>/a{1,3}/</code> matches nothing in "cndy", the 'a' in  
>"candy," the first two a's in "caandy," and the first three a's i 
>n "caaaaaaandy" Notice that when matching "caaaaaaandy", the matc 
>h is "aaa", even though the original string had more a's in it. 
168          </td>
169        </tr>
170        <tr>
171          <td>
172            {{ mediawiki.external('xyz') }}
173          </td>
174          <td>
175            A character set. Matches any one of the enclosed char
>acters. You can specify a range of characters by using a hyphen.  
>For example, <code>{{ mediawiki.external('abcd') }}</code> is the 
> same as <code>{{ mediawiki.external('a-d') }}</code>. They match 
> the 'b' in "brisket" and the 'c' in "city". 
176          </td>
177        </tr>
178        <tr>
179          <td>
180            {{ mediawiki.external('^xyz') }}
181          </td>
182          <td>
183            A negated or complemented character set. That is, it 
>matches anything that is not enclosed in the brackets. You can sp 
>ecify a range of characters by using a hyphen. For example, <code 
>>{{ mediawiki.external('^abc') }}</code> is the same as <code>{{  
>mediawiki.external('^a-c') }}</code>. They initially match 'r' in 
> "brisket" and 'h' in "chop." 
184          </td>
185        </tr>
186        <tr>
187          <td>
188            {{ mediawiki.external('\\b') }}
189          </td>
190          <td>
191            Matches a backspace. (Not to be confused with \b.)
192          </td>
193        </tr>
194        <tr>
195          <td>
196            \b
197          </td>
198          <td>
199            Matches a word boundary, such as a space or a newline
> character. (Not to be confused with {{ mediawiki.external('\\b') 
> }}.) For example, <code>/\bn\w/</code> matches the 'no' in "noon 
>day";<code>/\wy\b/</code> matches the 'ly' in "possibly yesterday 
200          </td>
201        </tr>
202        <tr>
203          <td>
204            \B
205          </td>
206          <td>
207            Matches a non-word boundary. For example, <code>/\w\B
>n/</code> matches 'on' in "noonday", and <code>/y\B\w/</code> mat 
>ches 'ye' in "possibly yesterday." 
208          </td>
209        </tr>
210        <tr>
211          <td>
212            \cX
213          </td>
214          <td>
215            Where X is a control character. Matches a control cha
>racter in a string. For example, <code>/\cM/</code> matches contr 
>ol-M in a string. 
216          </td>
217        </tr>
218        <tr>
219          <td>
220            \d
221          </td>
222          <td>
223            Matches a digit character. Equivalent to {{ mediawiki
>.external('0-9') }}. For example, <code>/\d/</code> or <code>/{{  
>mediawiki.external('0-9') }}/</code> matches '2' in "B2 is the su 
>ite number." 
224          </td>
225        </tr>
226        <tr>
227          <td>
228            \D
229          </td>
230          <td>
231            Matches any non-digit character. Equivalent to {{ med
>iawiki.external('^0-9') }}. For example, <code>/\D/</code> or <co 
>de>/{{ mediawiki.external('^0-9') }}/</code> matches 'B' in "B2 i 
>s the suite number." 
232          </td>
233        </tr>
234        <tr>
235          <td>
236            \f
237          </td>
238          <td>
239            Matches a form-feed.
240          </td>
241        </tr>
242        <tr>
243          <td>
244            \n
245          </td>
246          <td>
247            Matches a linefeed.
248          </td>
249        </tr>
250        <tr>
251          <td>
252            \r
253          </td>
254          <td>
255            Matches a carriage return.
256          </td>
257        </tr>
258        <tr>
259          <td>
260            \s
261          </td>
262          <td>
263            Matches a single white space character, including spa
>ce, tab, form feed, line feed. Equivalent to 
264            <p>
265              {{ mediawiki.external(' \\f\\n\\r\\t\\v\\u00A0\\u20
>28\\u2029') }}. 
266            </p>For example, <code>/\s\w*/</code> matches '&nbsp;
>bar' in "foo bar." 
267          </td>
268        </tr>
269        <tr>
270          <td>
271            \S
272          </td>
273          <td>
274            Matches a single character other than white space. Eq
>uivalent to 
275            <p>
276              {{ mediawiki.external('^ \\f\\n\\r\\t\\v\\u00A0\\u2
>028\\u2029') }}. 
277            </p>For example, <code>/\S\w*/</code> matches 'foo' i
>n "foo bar." 
278          </td>
279        </tr>
280        <tr>
281          <td>
282            \t
283          </td>
284          <td>
285            Matches a tab.
286          </td>
287        </tr>
288        <tr>
289          <td>
290            \v
291          </td>
292          <td>
293            Matches a vertical tab.
294          </td>
295        </tr>
296        <tr>
297          <td>
298            \w
299          </td>
300          <td>
301            Matches any alphanumeric character including the unde
>rscore. Equivalent to {{ mediawiki.external('A-Za-z0-9_') }}. For 
> example, <code>/\w/</code> matches 'a' in "apple," '5' in "$5.28 
>," and '3' in "3D." 
302          </td>
303        </tr>
304        <tr>
305          <td>
306            \W
307          </td>
308          <td>
309            Matches any non-word character. Equivalent to {{ medi
>awiki.external('^A-Za-z0-9_') }}. For example, <code>/\W/</code>  
>or <code>/{{ mediawiki.external('^A-Za-z0-9_') }}/</code> matches 
> '%' in "50%." 
310          </td>
311        </tr>
312        <tr>
313          <td>
314            \n
315          </td>
316          <td>
317            Where n is a positive integer. A back reference to th
>e last substring matching the n parenthetical in the regular expr 
>ession (counting left parentheses). For example, <code>/apple(,)\ 
>sorange\1/</code> matches 'apple, orange,' in "apple, orange, che 
>rry, peach." 
318          </td>
319        </tr>
320        <tr>
321          <td>
322            \0
323          </td>
324          <td>
325            Matches a NUL character. Do not follow this with anot
>her digit. 
326          </td>
327        </tr>
328        <tr>
329          <td>
330            \xhh
331          </td>
332          <td>
333            Matches the character with the code hh (two hexadecim
>al digits) 
334          </td>
335        </tr>
336        <tr>
337          <td>
338            \uhhhh
339          </td>
340          <td>
341            Matches the character with the code hhhh (four hexade
>cimal digits). 
342          </td>
343        </tr>
344      </tbody>
345    </table>
346    <p>
347      <small><strong>Table 4.1: Special characters in regular exp
348    </p>
349    <h2>
350      Using Parentheses
351    </h2>
352    <p>
353      Parentheses around any part of the regular expression patte
>rn cause that part of the matched substring to be remembered. Onc 
>e remembered, the substring can be recalled for other use, as des 
>cribed in <a href="/en/Core_JavaScript_1.5_Guide/Working_with_Reg 
>ular_Expressions/Using_Parenthesized_Substring_Matches" title="en 
>_Parenthesized_Substring_Matches">Using Parenthesized Substring M 
354    </p>
355    <p>
356      For example, the pattern <code>/Chapter (\d+)\.\d*/</code> 
>illustrates additional escaped and special characters and indicat 
>es that part of the pattern should be remembered. It matches prec 
>isely the characters 'Chapter ' followed by one or more numeric c 
>haracters (\d means any numeric character and + means 1 or more t 
>imes), followed by a decimal point (which in itself is a special  
>character; preceding the decimal point with \ means the pattern m 
>ust look for the literal character '.'), followed by any numeric  
>character 0 or more times (\d means numeric character, * means 0  
>or more times). In addition, parentheses are used to remember the 
> first matched numeric characters. 
357    </p>
358    <p>
359      This pattern is found in "Open Chapter 4.3, paragraph 6" an
>d '4' is remembered. The pattern is not found in "Chapter 3 and 4 
>", because that string does not have a period after the '3'. 
360    </p>
361    <p>
362      To match a substring without causing the matched part to be
> remembered, within the parentheses preface the pattern with <cod 
>e>?:</code>. For example, <code>(?:\d+)</code> matches one or mor 
>e numeric characters but does not remember the matched characters 
363    </p>
364    <div class="noinclude">
365      <p>
366        {{ PreviousNext("Core_JavaScript_1.5_Guide:Creating_a_Reg
>ular_Expression", "Core_JavaScript_1.5_Guide:Working_with_Regular 
>_Expressions") }} 
367      </p>
368    </div>
369    <p>

Back to History