summaryrefslogtreecommitdiff
path: root/TWiki/RegularExpression.mdwn
blob: db340de94c06a7b1055f6e10203c6d7b0556e682 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
Regular expressions allow more specific queries then a simple query.

**Examples**

<table>
  <tr>
    <td> compan(y|ies) </td>
    <td> Search for <em>company</em> , <em>companies</em></td>
  </tr>
  <tr>
    <td> (peter|paul) </td>
    <td> Search for <em>peter</em> , <em>paul</em></td>
  </tr>
  <tr>
    <td> bug* </td>
    <td> Search for <em>bug</em> , <em>bugs</em> , <em>bugfix</em></td>
  </tr>
  <tr>
    <td> [Bb]ag </td>
    <td> Search for <em>Bag</em> , <em>bag</em></td>
  </tr>
  <tr>
    <td> b[aiueo]g </td>
    <td> Second letter is a vowel. Matches <em>bag</em> , <em>bug</em> , <em>big</em></td>
  </tr>
  <tr>
    <td> b.g </td>
    <td> Second letter is any letter. Matches also <em>b&amp;amp;g</em></td>
  </tr>
  <tr>
    <td> [a-zA-Z] </td>
    <td> Matches any one letter (not a number and a symbol) </td>
  </tr>
  <tr>
    <td> [^0-9a-zA-Z] </td>
    <td> Matches any symbol (not a number or a letter) </td>
  </tr>
  <tr>
    <td> [A-Z][A-Z]* </td>
    <td> Matches one or more uppercase letters </td>
  </tr>
  <tr>
    <td> [0-9][0-9][0-9]-[0-9][0-9]- <br /> [0-9][0-9][0-9][0-9] </td>
    <td valign="top"> US social security number, e.g. 123-45-6789 </td>
  </tr>
</table>

Here is stuff for our UNIX freaks: <br /> (copied from 'man grep')

         \c   A backslash (\) followed by any special character is  a
              one-character  regular expression that matches the spe-
              cial character itself.  The special characters are:

                   +    `.', `*', `[',  and  `\'  (period,  asterisk,
                        left  square  bracket, and backslash, respec-
                        tively), which  are  always  special,  except
                        when they appear within square brackets ([]).

                   +    `^' (caret or circumflex), which  is  special
                        at the beginning of an entire regular expres-
                        sion, or when it immediately follows the left
                        of a pair of square brackets ([]).

                   +    $ (currency symbol), which is special at  the
                        end of an entire regular expression.

         .    A `.' (period) is a  one-character  regular  expression
              that matches any character except NEWLINE.

         [string]
              A non-empty string of  characters  enclosed  in  square
              brackets  is  a  one-character  regular expression that
              matches any one character in that string.  If, however,
              the  first  character of the string is a `^' (a circum-
              flex or caret), the  one-character  regular  expression
              matches  any character except NEWLINE and the remaining
              characters in the string.  The  `^'  has  this  special
              meaning only if it occurs first in the string.  The `-'
              (minus) may be used to indicate a range of  consecutive
              ASCII  characters;  for example, [0-9] is equivalent to
              [0123456789].  The `-' loses this special meaning if it
              occurs  first (after an initial `^', if any) or last in
              the string.  The `]' (right square  bracket)  does  not
              terminate  such a string when it is the first character
              within it (after an initial  `^',  if  any);  that  is,
              []a-f]  matches either `]' (a right square bracket ) or
              one of the letters a through  f  inclusive.   The  four
              characters  `.', `*', `[', and `\' stand for themselves
              within such a string of characters.

         The following rules may be used to construct regular expres-
         sions:

         *    A one-character regular expression followed by `*'  (an
              asterisk)  is a regular expression that matches zero or
              more occurrences of the one-character  regular  expres-
              sion.   If  there  is  any choice, the longest leftmost
              string that permits a match is chosen.

         ^    A circumflex or caret (^) at the beginning of an entire
              regular  expression  constrains that regular expression
              to match an initial segment of a line.

         $    A currency symbol ($) at the end of an  entire  regular
              expression  constrains that regular expression to match
              a final segment of a line.

         *    A  regular  expression  (not  just   a   one-
              character regular expression) followed by `*'
              (an asterisk) is a  regular  expression  that
              matches  zero or more occurrences of the one-
              character regular expression.   If  there  is
              any  choice, the longest leftmost string that
              permits a match is chosen.

         +    A regular expression followed by `+' (a  plus
              sign)  is  a  regular expression that matches
              one or more occurrences of the  one-character
              regular  expression.  If there is any choice,
              the longest leftmost string  that  permits  a
              match is chosen.

         ?    A regular expression followed by `?' (a ques-
              tion  mark)  is  a  regular  expression  that
              matches zero or one occurrences of  the  one-
              character  regular  expression.   If there is
              any choice, the longest leftmost string  that
              permits a match is chosen.

         |    Alternation:    two    regular    expressions
              separated  by  `|'  or NEWLINE match either a
              match for  the  first  or  a  match  for  the
              second.

         ()   A regular expression enclosed in  parentheses
              matches a match for the regular expression.

         The order of precedence of operators at the same parenthesis
         level  is  `[ ]'  (character  classes),  then  `*'  `+'  `?'
         (closures),then  concatenation,  then  `|'  (alternation)and
         NEWLINE.