mozilla

Compare Revisions

Writing a Regular Expression Pattern

Change Revisions

Revision 118390:

Revision 118390 by Potappo on

Revision 118391:

Revision 118391 by michal.vanzelm on

Title:
Writing a Regular Expression Pattern
Writing a Regular Expression Pattern
Slug:
JavaScript/Guide/Obsolete_Pages/Writing_a_Regular_Expression_Pattern
JavaScript/Guide/Obsolete_Pages/Writing_a_Regular_Expression_Pattern
Content:

Revision 118390
Revision 118391
nn7    <h3 name="Writing_a_Regular_Expression_Pattern">
8      Writing a Regular Expression Pattern
9    </h3>
10    <p>
11      A regular expression pattern is composed of simple characte
 >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/
 >Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Using_
 >Parenthesized_Substring_Matches" title="en/Core_JavaScript_1.5_Gu
 >ide/Working_with_Regular_Expressions/Using_Parenthesized_Substrin
 >g_Matches">Using Parenthesized Substring Matches</a>.
12    </p>
13    <p>
14      &nbsp;
15    </p>
16    <h4 name="Using_Simple_Patterns">
17      Using Simple Patterns
18    </h4>
19    <p>
20      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'.
21    </p>
22    <p>
23      &nbsp;
24    </p>
25    <h4 name="Using_Special_Characters">
26      Using Special Characters
27    </h4>
28    <p>
29      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'.
30    </p>
31    <p>
32      The following table provides a complete list and descriptio
 >n of the special characters that can be used in regular expressio
 >ns.
33    </p>
34    <table class="fullwidth-table">
35      <tbody>
36        <tr>
37          <th>
38            Character
39          </th>
40          <th>
41            Meaning
42          </th>
43        </tr>
44        <tr>
45          <td>
46            \
47          </td>
48          <td>
49            Either of the following:
50            <ul>
51              <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.
52              </li>
53              <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*'.
54              </li>
55            </ul>
56          </td>
57        </tr>
58        <tr>
59          <td>
60            ^
61          </td>
62          <td>
63            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".
64          </td>
65        </tr>
66        <tr>
67          <td>
68            $
69          </td>
70          <td>
71            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".
72          </td>
73        </tr>
74        <tr>
75          <td>
76            *
77          </td>
78          <td>
79            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".
80          </td>
81        </tr>
82        <tr>
83          <td>
84            +
85          </td>
86          <td>
87            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".
88          </td>
89        </tr>
90        <tr>
91          <td>
92            ?
93          </td>
94          <td>
95            Matches the preceding character 0 or 1 time.
96            <p>
97              For example, <code>/e?le?/</code> matches the 'el' 
 >in "angel" and the 'le' in "angle."
98            </p>
99            <p>
100              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.
101            </p>Also used in lookahead assertions, described unde
 >r x(?=y) and x(?!y) in this table.
102          </td>
103        </tr>
104        <tr>
105          <td>
106            .
107          </td>
108          <td>
109            (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'.
110          </td>
111        </tr>
112        <tr>
113          <td>
114            (x)
115          </td>
116          <td>
117            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') }}.
118          </td>
119        </tr>
120        <tr>
121          <td>
122            (?:x)
123          </td>
124          <td>
125            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') }}.
126          </td>
127        </tr>
128        <tr>
129          <td>
130            x(?=y)
131          </td>
132          <td>
133            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.
134          </td>
135        </tr>
136        <tr>
137          <td>
138            x(?!y)
139          </td>
140          <td>
141            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'.
142          </td>
143        </tr>
144        <tr>
145          <td>
146            x|y
147          </td>
148          <td>
149            Matches either 'x' or 'y'. For example, <code>/green|
 >red/</code> matches 'green' in "green apple" and 'red' in "red ap
 >ple."
150          </td>
151        </tr>
152        <tr>
153          <td>
154            {n}
155          </td>
156          <td>
157            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."
158          </td>
159        </tr>
160        <tr>
161          <td>
162            {n,}
163          </td>
164          <td>
165            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."
166          </td>
167        </tr>
168        <tr>
169          <td>
170            {n,m}
171          </td>
172          <td>
173            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.
174          </td>
175        </tr>
176        <tr>
177          <td>
178            {{ mediawiki.external('xyz') }}
179          </td>
180          <td>
181            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".
182          </td>
183        </tr>
184        <tr>
185          <td>
186            {{ mediawiki.external('^xyz') }}
187          </td>
188          <td>
189            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."
190          </td>
191        </tr>
192        <tr>
193          <td>
194            {{ mediawiki.external('\\b') }}
195          </td>
196          <td>
197            Matches a backspace. (Not to be confused with \b.)
198          </td>
199        </tr>
200        <tr>
201          <td>
202            \b
203          </td>
204          <td>
205            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
 >."
206          </td>
207        </tr>
208        <tr>
209          <td>
210            \B
211          </td>
212          <td>
213            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."
214          </td>
215        </tr>
216        <tr>
217          <td>
218            \cX
219          </td>
220          <td>
221            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.
222          </td>
223        </tr>
224        <tr>
225          <td>
226            \d
227          </td>
228          <td>
229            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."
230          </td>
231        </tr>
232        <tr>
233          <td>
234            \D
235          </td>
236          <td>
237            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."
238          </td>
239        </tr>
240        <tr>
241          <td>
242            \f
243          </td>
244          <td>
245            Matches a form-feed.
246          </td>
247        </tr>
248        <tr>
249          <td>
250            \n
251          </td>
252          <td>
253            Matches a linefeed.
254          </td>
255        </tr>
256        <tr>
257          <td>
258            \r
259          </td>
260          <td>
261            Matches a carriage return.
262          </td>
263        </tr>
264        <tr>
265          <td>
266            \s
267          </td>
268          <td>
269            Matches a single white space character, including spa
 >ce, tab, form feed, line feed. Equivalent to
270            <p>
271              {{ mediawiki.external(' \\f\\n\\r\\t\\v\\u00A0\\u20
 >28\\u2029') }}.
272            </p>For example, <code>/\s\w*/</code> matches '&nbsp;
 >bar' in "foo bar."
273          </td>
274        </tr>
275        <tr>
276          <td>
277            \S
278          </td>
279          <td>
280            Matches a single character other than white space. Eq
 >uivalent to
281            <p>
282              {{ mediawiki.external('^ \\f\\n\\r\\t\\v\\u00A0\\u2
 >028\\u2029') }}.
283            </p>For example, <code>/\S\w*/</code> matches 'foo' i
 >n "foo bar."
284          </td>
285        </tr>
286        <tr>
287          <td>
288            \t
289          </td>
290          <td>
291            Matches a tab.
292          </td>
293        </tr>
294        <tr>
295          <td>
296            \v
297          </td>
298          <td>
299            Matches a vertical tab.
300          </td>
301        </tr>
302        <tr>
303          <td>
304            \w
305          </td>
306          <td>
307            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."
308          </td>
309        </tr>
310        <tr>
311          <td>
312            \W
313          </td>
314          <td>
315            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%."
316          </td>
317        </tr>
318        <tr>
319          <td>
320            \n
321          </td>
322          <td>
323            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."
324          </td>
325        </tr>
326        <tr>
327          <td>
328            \0
329          </td>
330          <td>
331            Matches a NUL character. Do not follow this with anot
 >her digit.
332          </td>
333        </tr>
334        <tr>
335          <td>
336            \xhh
337          </td>
338          <td>
339            Matches the character with the code hh (two hexadecim
 >al digits)
340          </td>
341        </tr>
342        <tr>
343          <td>
344            \uhhhh
345          </td>
346          <td>
347            Matches the character with the code hhhh (four hexade
 >cimal digits).
348          </td>
349        </tr>
350      </tbody>
351    </table>
352    <p>
353      <small><strong>Table 4.1: Special characters in regular exp
 >ressions.</strong></small>
354    </p>
355    <h4 name="Using_Parentheses">
356      Using Parentheses
357    </h4>
358    <p>
359      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
 >/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Using
 >_Parenthesized_Substring_Matches">Using Parenthesized Substring M
 >atches</a>.
360    </p>
361    <p>
362      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.
363    </p>
364    <p>
365      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'.
366    </p>
367    <p>
368      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
 >.
369    </p>
n8      <h3 name="Writing_a_Regular_Expression_Pattern">n
9        Writing a Regular Expression Pattern
10      </h3>
n12        A regular expression pattern is composed of simple characn372        {{ PreviousNext("Core_JavaScript_1.5_Guide:Creating_a_Reg
>ters, such as <code>/abc/</code>, or a combination of simple and >ular_Expression", "Core_JavaScript_1.5_Guide:Working_with_Regular
>special characters, such as <code>/ab*c/</code> or <code>/Chapter>_Expressions") }}
> (\d+)\.\d*/</code>. The last example includes parentheses which  
>are used as a memory device. The match made with this part of the 
> pattern is remembered for later use, as described in <a href="en 
>/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Using 
>_Parenthesized_Substring_Matches">Using Parenthesized Substring M 
>atches</a>. 
n14      <p>n
15        <br>
16      </p>
17      <h4 name="Using_Simple_Patterns">
18        Using Simple Patterns
19      </h4>
20      <p>
21        Simple patterns are constructed of characters for which y
>ou want to find a direct match. For example, the pattern /abc/ ma 
>tches character combinations in strings only when exactly the cha 
>racters 'abc' occur together and in that order. Such a match woul 
>d succeed in the strings "Hi, do you know your abc's?" and "The l 
>atest airplane designs evolved from slabcraft." In both cases the 
> match is with the substring 'abc'. There is no match in the stri 
>ng "Grab crab" because it does not contain the substring 'abc'. 
22      </p>
23      <p>
24        <br>
25      </p>
26      <h4 name="Using_Special_Characters">
27        Using Special Characters
28      </h4>
29      <p>
30        When the search for a match requires something more than 
>a direct match, such as finding one or more b's, or finding white 
> space, the pattern includes special characters. For example, the 
> pattern <code>/ab*c/</code> matches any character combination in 
> which a single 'a' is followed by zero or more 'b's (* means 0 o 
>r more occurrences of the preceding item) and then immediately fo 
>llowed by 'c'. In the string "cbbabbbbcdebc," the pattern matches 
> the substring 'abbbbc'. 
31      </p>
32      <p>
33        The following table provides a complete list and descript
>ion of the special characters that can be used in regular express 
>ions. 
34      </p>
35      <table class="fullwidth-table">
36        <tbody>
37          <tr>
38            <th>
39              Character
40            </th>
41            <th>
42              Meaning
43            </th>
44          </tr>
45          <tr>
46            <td>
47              \
48            </td>
49            <td>
50              Either of the following:
51              <ul>
52                <li>For characters that are usually treated liter
>ally, indicates that the next character is special and not to be  
>interpreted literally. For example, <code>/b/</code> matches the  
>character 'b'. By placing a backslash in front of b, that is by u 
>sing <code>/\b/</code>, the character becomes special to mean mat 
>ch a word boundary. 
53                </li>
54                <li>For characters that are usually treated speci
>ally, indicates that the next character is not special and should 
> be interpreted literally. For example, * is a special character  
>that means 0 or more occurrences of the preceding item should be  
>matched; 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*'. 
55                </li>
56              </ul>
57            </td>
58          </tr>
59          <tr>
60            <td>
61              ^
62            </td>
63            <td>
64              Matches beginning of input. If the multiline flag i
>s set to true, also matches immediately after a line break charac 
>ter. For example, <code>/^A/</code> does not match the 'A' in "an 
> A", but does match the first 'A' in "An A". 
65            </td>
66          </tr>
67          <tr>
68            <td>
69              $
70            </td>
71            <td>
72              Matches end of input. If the multiline flag is set 
>to true, also matches immediately before a line break character.  
>For example, <code>/t$/</code> does not match the 't' in "eater", 
> but does match it in "eat". 
73            </td>
74          </tr>
75          <tr>
76            <td>
77              *
78            </td>
79            <td>
80              Matches the preceding character 0 or more times. Fo
>r example, <code>/bo*/</code> matches 'boooo' in "A ghost booooed 
>" and 'b' in "A bird warbled", but nothing in "A goat grunted". 
81            </td>
82          </tr>
83          <tr>
84            <td>
85              +
86            </td>
87            <td>
88              Matches the preceding character 1 or more times. Eq
>uivalent to {1,}. For example, <code>/a+/</code> matches the 'a'  
>in "candy" and all the a's in "caaaaaaandy". 
89            </td>
90          </tr>
91          <tr>
92            <td>
93              ?
94            </td>
95            <td>
96              Matches the preceding character 0 or 1 time.
97              <p>
98                For example, <code>/e?le?/</code> matches the 'el
>' in "angel" and the 'le' in "angle." 
99              </p>
100              <p>
101                If used immediately after any of the quantifiers 
>*, +,&nbsp;?, or {}, makes the quantifier non-greedy (matching th 
>e minimum number of times), as opposed to the default, which is g 
>reedy (matching the maximum number of times). For example, using  
>/\d+/ non-globle match "123abc" return "123", if using /\d+?/, on 
>ly "1" will be matched. 
102              </p>Also used in lookahead assertions, described un
>der x(?=y) and x(?!y) in this table. 
103            </td>
104          </tr>
105          <tr>
106            <td>
107              .
108            </td>
109            <td>
110              (The decimal point) matches any single character ex
>cept the newline character. For example, <code>/.n/</code> matche 
>s 'an' and 'on' in "nay, an apple is on the tree", but not 'nay'. 
111            </td>
112          </tr>
113          <tr>
114            <td>
115              (x)
116            </td>
117            <td>
118              Matches 'x' and remembers the match. These are call
>ed capturing parentheses. For example, <code>/(foo)/</code> match 
>es and remembers 'foo' in "foo bar." The matched substring can be 
> recalled from the resulting array's elements {{ mediawiki.extern 
>al("1") }}, ..., {{ mediawiki.external('n') }}. 
119            </td>
120          </tr>
121          <tr>
122            <td>
123              (?:x)
124            </td>
125            <td>
126              Matches 'x' but does not remember the match. These 
>are called non-capturing parentheses. The matched substring can n 
>ot be recalled from the resulting array's elements {{ mediawiki.e 
>xternal("1") }}, ..., {{ mediawiki.external('n') }}. 
127            </td>
128          </tr>
129          <tr>
130            <td>
131              x(?=y)
132            </td>
133            <td>
134              Matches 'x' only if 'x' is followed by 'y'. For exa
>mple, <code>/Jack(?=Sprat)/</code> matches 'Jack' only if it is f 
>ollowed by 'Sprat'. <code>/Jack(?=Sprat|Frost)/</code> matches 'J 
>ack' only if it is followed by 'Sprat' or 'Frost'. However, neith 
>er 'Sprat' nor 'Frost' is part of the match results. 
135            </td>
136          </tr>
137          <tr>
138            <td>
139              x(?!y)
140            </td>
141            <td>
142              Matches 'x' only if 'x' is not followed by 'y'. For
> example, <code>/\d+(?!\.)/</code> matches a number only if it is 
> not followed by a decimal point. The regular expression <code>/\ 
>d+(?!\.)/.exec("3.141")</code> matches '141' but not '3.141'. 
143            </td>
144          </tr>
145          <tr>
146            <td>
147              x|y
148            </td>
149            <td>
150              Matches either 'x' or 'y'. For example, <code>/gree
>n|red/</code> matches 'green' in "green apple" and 'red' in "red  
>apple." 
151            </td>
152          </tr>
153          <tr>
154            <td>
155              {n}
156            </td>
157            <td>
158              Where n is a positive integer. Matches exactly n oc
>currences of the preceding character. For example, <code>/a{2}/</ 
>code> 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." 
159            </td>
160          </tr>
161          <tr>
162            <td>
163              {n,}
164            </td>
165            <td>
166              Where n is a positive integer. Matches at least n o
>ccurrences 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." 
167            </td>
168          </tr>
169          <tr>
170            <td>
171              {n,m}
172            </td>
173            <td>
174              Where n and m are positive integers. Matches at lea
>st n and at most m occurrences of the preceding character. For ex 
>ample, <code>/a{1,3}/</code> matches nothing in "cndy", the 'a' i 
>n "candy," the first two a's in "caandy," and the first three a's 
> in "caaaaaaandy" Notice that when matching "caaaaaaandy", the ma 
>tch is "aaa", even though the original string had more a's in it. 
175            </td>
176          </tr>
177          <tr>
178            <td>
179              {{ mediawiki.external('xyz') }}
180            </td>
181            <td>
182              A character set. Matches any one of the enclosed ch
>aracters. You can specify a range of characters by using a hyphen 
>. For example, <code>{{ mediawiki.external('abcd') }}</code> is t 
>he same as <code>{{ mediawiki.external('a-d') }}</code>. They mat 
>ch the 'b' in "brisket" and the 'c' in "city". 
183            </td>
184          </tr>
185          <tr>
186            <td>
187              {{ mediawiki.external('^xyz') }}
188            </td>
189            <td>
190              A negated or complemented character set. That is, i
>t matches anything that is not enclosed in the brackets. You can  
>specify a range of characters by using a hyphen. For example, <co 
>de>{{ mediawiki.external('^abc') }}</code> is the same as <code>{ 
>{ mediawiki.external('^a-c') }}</code>. They initially match 'r'  
>in "brisket" and 'h' in "chop." 
191            </td>
192          </tr>
193          <tr>
194            <td>
195              {{ mediawiki.external('\\b') }}
196            </td>
197            <td>
198              Matches a backspace. (Not to be confused with \b.)
199            </td>
200          </tr>
201          <tr>
202            <td>
203              \b
204            </td>
205            <td>
206              Matches a word boundary, such as a space or a newli
>ne character. (Not to be confused with {{ mediawiki.external('\\b 
>') }}.) For example, <code>/\bn\w/</code> matches the 'no' in "no 
>onday";<code>/\wy\b/</code> matches the 'ly' in "possibly yesterd 
>ay." 
207            </td>
208          </tr>
209          <tr>
210            <td>
211              \B
212            </td>
213            <td>
214              Matches a non-word boundary. For example, <code>/\w
>\Bn/</code> matches 'on' in "noonday", and <code>/y\B\w/</code> m 
>atches 'ye' in "possibly yesterday." 
215            </td>
216          </tr>
217          <tr>
218            <td>
219              \cX
220            </td>
221            <td>
222              Where X is a control character. Matches a control c
>haracter in a string. For example, <code>/\cM/</code> matches con 
>trol-M in a string. 
223            </td>
224          </tr>
225          <tr>
226            <td>
227              \d
228            </td>
229            <td>
230              Matches a digit character. Equivalent to {{ mediawi
>ki.external('0-9') }}. For example, <code>/\d/</code> or <code>/{ 
>{ mediawiki.external('0-9') }}/</code> matches '2' in "B2 is the  
>suite number." 
231            </td>
232          </tr>
233          <tr>
234            <td>
235              \D
236            </td>
237            <td>
238              Matches any non-digit character. Equivalent to {{ m
>ediawiki.external('^0-9') }}. For example, <code>/\D/</code> or < 
>code>/{{ mediawiki.external('^0-9') }}/</code> matches 'B' in "B2 
> is the suite number." 
239            </td>
240          </tr>
241          <tr>
242            <td>
243              \f
244            </td>
245            <td>
246              Matches a form-feed.
247            </td>
248          </tr>
249          <tr>
250            <td>
251              \n
252            </td>
253            <td>
254              Matches a linefeed.
255            </td>
256          </tr>
257          <tr>
258            <td>
259              \r
260            </td>
261            <td>
262              Matches a carriage return.
263            </td>
264          </tr>
265          <tr>
266            <td>
267              \s
268            </td>
269            <td>
270              Matches a single white space character, including s
>pace, tab, form feed, line feed. Equivalent to 
271              <p>
272                {{ mediawiki.external(' \\f\\n\\r\\t\\v\\u00A0\\u
>2028\\u2029') }}. 
273              </p>For example, <code>/\s\w*/</code> matches '&nbs
>p;bar' in "foo bar." 
274            </td>
275          </tr>
276          <tr>
277            <td>
278              \S
279            </td>
280            <td>
281              Matches a single character other than white space. 
>Equivalent to 
282              <p>
283                {{ mediawiki.external('^ \\f\\n\\r\\t\\v\\u00A0\\
>u2028\\u2029') }}. 
284              </p>For example, <code>/\S\w*/</code> matches 'foo'
> in "foo bar." 
285            </td>
286          </tr>
287          <tr>
288            <td>
289              \t
290            </td>
291            <td>
292              Matches a tab.
293            </td>
294          </tr>
295          <tr>
296            <td>
297              \v
298            </td>
299            <td>
300              Matches a vertical tab.
301            </td>
302          </tr>
303          <tr>
304            <td>
305              \w
306            </td>
307            <td>
308              Matches any alphanumeric character including the un
>derscore. Equivalent to {{ mediawiki.external('A-Za-z0-9_') }}. F 
>or example, <code>/\w/</code> matches 'a' in "apple," '5' in "$5. 
>28," and '3' in "3D." 
309            </td>
310          </tr>
311          <tr>
312            <td>
313              \W
314            </td>
315            <td>
316              Matches any non-word character. Equivalent to {{ me
>diawiki.external('^A-Za-z0-9_') }}. For example, <code>/\W/</code 
>> or <code>/{{ mediawiki.external('^A-Za-z0-9_') }}/</code> match 
>es '%' in "50%." 
317            </td>
318          </tr>
319          <tr>
320            <td>
321              \n
322            </td>
323            <td>
324              Where n is a positive integer. A back reference to 
>the last substring matching the n parenthetical in the regular ex 
>pression (counting left parentheses). For example, <code>/apple(, 
>)\sorange\1/</code> matches 'apple, orange,' in "apple, orange, c 
>herry, peach." 
325            </td>
326          </tr>
327          <tr>
328            <td>
329              \0
330            </td>
331            <td>
332              Matches a NUL character. Do not follow this with an
>other digit. 
333            </td>
334          </tr>
335          <tr>
336            <td>
337              \xhh
338            </td>
339            <td>
340              Matches the character with the code hh (two hexadec
>imal digits) 
341            </td>
342          </tr>
343          <tr>
344            <td>
345              \uhhhh
346            </td>
347            <td>
348              Matches the character with the code hhhh (four hexa
>decimal digits). 
349            </td>
350          </tr>
351        </tbody>
352      </table>
353      <p>
354        <small><b>Table 4.1: Special characters in regular expres
>sions.</b></small> 
355      </p>
356      <h4 name="Using_Parentheses">
357        Using Parentheses
358      </h4>
359      <p>
360        Parentheses around any part of the regular expression pat
>tern cause that part of the matched substring to be remembered. O 
>nce remembered, the substring can be recalled for other use, as d 
>escribed in <a href="en/Core_JavaScript_1.5_Guide/Working_with_Re 
>gular_Expressions/Using_Parenthesized_Substring_Matches">Using Pa 
>renthesized Substring Matches</a>. 
361      </p>
362      <p>
363        For example, the pattern <code>/Chapter (\d+)\.\d*/</code
>> illustrates additional escaped and special characters and indic 
>ates that part of the pattern should be remembered. It matches pr 
>ecisely the characters 'Chapter ' followed by one or more numeric 
> characters (\d means any numeric character and + means 1 or more 
> times), followed by a decimal point (which in itself is a specia 
>l character; preceding the decimal point with \ means the pattern 
> must look for the literal character '.'), followed by any numeri 
>c character 0 or more times (\d means numeric character, * means  
>0 or more times). In addition, parentheses are used to remember t 
>he first matched numeric characters. 
364      </p>
365      <p>
366        This pattern is found in "Open Chapter 4.3, paragraph 6" 
>and '4' is remembered. The pattern is not found in "Chapter 3 and 
> 4", because that string does not have a period after the '3'. 
367      </p>
368      <p>
369        To match a substring without causing the matched part to 
>be remembered, within the parentheses preface the pattern with <c 
>ode>?:</code>. For example, <code>(?:\d+)</code> matches one or m 
>ore numeric characters but does not remember the matched characte 
>rs. 
370      </p>
371      <div class="noinclude">
372        <p>
373          {{ PreviousNext("Core_JavaScript_1.5_Guide:Creating_a_R
>egular_Expression", "Core_JavaScript_1.5_Guide:Working_with_Regul 
>ar_Expressions") }} 
374        </p>
375      </div>{{ languages( { "es": "es/Gu\u00eda_JavaScript_1.5/Es
>cribir_un_patr\u00f3n_de_expresi\u00f3n_regular", "fr": "fr/Guide 
>_JavaScript_1.5/\u00c9criture_d\'un_masque_d\'expression_rationne 
>lle", "ja": "ja/Core_JavaScript_1.5_Guide/Writing_a_Regular_Expre 
>ssion_Pattern", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1. 
>5/Zapisywanie_wzorca_wyra\u017cenia_regularnego" } ) }} 
tt375    <p>
376      {{ languages( { "es": "es/Gu\u00eda_JavaScript_1.5/Escribir
 >_un_patr\u00f3n_de_expresi\u00f3n_regular", "fr": "fr/Guide_JavaS
 >cript_1.5/\u00c9criture_d\'un_masque_d\'expression_rationnelle", 
 >"ja": "ja/Core_JavaScript_1.5_Guide/Writing_a_Regular_Expression_
 >Pattern", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Zapi
 >sywanie_wzorca_wyra\u017cenia_regularnego" } ) }}
377    </p>

Back to History