浅入javascript正则表达式的规则.

今天在看jQuery源码的时候,到处都是正则的用法,一气之下就狠下心来.重新回顾了一下正则.下面是做的笔记.非常浅的入门.

  1  /*

  2             i:表示不区分大小写

  3             g:表示可以全局配置

  4             m:表示可以多行配置

  5             */

  6             /*

  7             ^:表示从字符串的第一个位置开始匹配

  8             */

  9             var result = false;

 10             var str = "guoGuo";

 11             var reg = /^gu/; //匹配字符串是否已gu开头

 12             result = reg.test(str);//true                      

 13            

 14             /*

 15             $:匹配字符串的尾端

 16             */

 17             str = "guoyansi";

 18             reg = /i$/;//是否已i结尾

 19             result = reg.test(str); //true    

 20             /*

 21             *:匹配前一个字符0次或多次

 22             /a星号/:以a开头开始匹配,如果匹配到a,则返回a,否则返回null

 23             /ab星号/:以a开头开始匹配,如果匹配到了a,返回a,匹配到了abbb...返回abbb....

 24             0次:没有b的就匹配a

 25             多次:有a,后面不论多少个b,都匹配出来abbb....

 26             */

 27             str = "dadbudabbbbc";

 28             reg = /du*/g;

 29             result = str.match(reg);

 30             

 31             /*

 32             +:匹配前一个字符一次或多次

 33             /a+/:以a开头开始匹配,如果匹配到a,则返回a,否则返回null

 34             /ab+/:以a开头开始匹配,如果匹配到了a,并且在a后面匹配到了b,则返回abbb...;

 35             1次:表示a后面没有b,就不返回.如果有b则返回ab.有一个b则返回一个b

 36             多次:表示a后面没有b,就不返回.如果有b则返回ab.有多个b则返回多个b

 37             */

 38             str = "ddadbbbbc";

 39             reg = /ab+/g;

 40             result = str.match(reg);

 41             /*

 42             ?:一般是对前一个字符的0次或1次匹配;

 43             0:没有就是0次

 44             1:有就匹配一次

 45             */

 46             str = "ddabbdbbbbabbc";

 47             reg = /ab?/g;

 48             result = str.match(reg); //ab,ab

 49             /*

 50             ?在星号和+,{},?后面,表示原始匹配的最小次数

 51             星号最小次数0;

 52             +:最小次数是1

 53             */

 54             str = "ddabbdbbbbabbc";

 55             reg = /ab*?/g;

 56             result = str.match(reg); //a,a

 57 

 58             reg = /ab+?/g;

 59             result = str.match(reg); //ab,ab

 60 

 61             /*

 62             .(点号):匹配一个单独的字符

 63             */

 64             str = "guoaaaaagio";

 65             reg = /g.o/g;

 66             result = str.match(reg); //guo

 67 

 68             /*

 69             (xxx):匹配字符串

 70             */

 71             str = "guoooooaaaaagjao";

 72             reg = /g(uo*)a/g;

 73             result = str.match(reg); //guoooooa

 74 

 75             /*

 76             x(?=y):匹配x,并且只有紧跟的后面是y

 77             */

 78             str = "guoyansi";

 79             reg = /uo(?=yan)/g;

 80             result = str.match(reg); //uo

 81 

 82             /*

 83             x(?!y):匹配x,并且紧跟后面的不是y

 84             */

 85 

 86             str = "guoyansi";

 87             reg = /uo(?!yan)/g;

 88             result = str.match(reg); //null

 89             str = "guoyanuosi";

 90             result = str.match(reg); //uo(后面一个uo)

 91 

 92             reg = /\d+(?!\.)/g; /*匹配数组,*/

 93             str = "54.235"; /*从数字开始匹配,匹配到之后,紧跟着后面的不能是数组*/

 94             result = str.match(reg); //5,235

 95             /*

 96             \d:匹配数字字符

 97             */

 98             reg = /\d/g;

 99             str = "123859";

100             result = str.match(reg); //1,2,3,8,5,9

101 

102             /*

103             \D:匹配非数字字符

104             */

105             str = "abc1hfd8dsv";

106             reg = /\D/g;

107             result = str.match(reg); //a,b,c,h,f,d,d,s,v

108 

109             /*

110             x|y:匹配x或y,如果x,y都匹配上了,返回x

111             */

112 

113             reg = /uo|n/g;

114             str = "nguoyansi";

115             result = str.match(reg); //n,uo,n(在没有g的情况下,返回n)

116 

117             /*

118             {n}匹配前一个字符的n次出现

119             */

120             str = "tabbcdabbt";

121             reg = /ab{2}/g;

122             result = str.match(reg); //abb,abb

123 

124             /*

125             {n,}匹配前一个字符至少出现n次数

126             */

127             str = "tabbbbbcdabbt";

128             reg = /ab{2,}/g;

129             result = str.match(reg); //abbbbb,abb

130 

131             /*

132             {n,m}匹配前一个字符至少出现n次,至多出现m次

133             */

134             str = "tabbbbbbcabbbbbbbdabbt";

135             reg = /ab{2,4}/g;

136             result = str.match(reg); //abbbbb,abbbb,abb

137 

138             str = "tabbbbcabbbbbbbdabbt";

139             reg = /ab{2,4}c/g;

140             result = str.match(reg); //abbbbc

141 

142             /*

143             [xyz]:匹配[]的一个字符,等同于[a-z],只匹配其中的一个字符,如果匹配到多个,则返回null

144             */

145             str = "abddgacdg";

146             reg = /a[bc]d/g;

147             result = str.match(reg); //abd,acd(bc连一起,就匹配不到)

148 

149             /*

150             [^xyz]:匹配非[]中的一个字符

151             */

152             str = "abd";

153             reg = /a[^bc]d/;

154             result = str.match(reg); //null

155 

156             str = "afddgatdg";

157             reg = /a[^bc]d/g;

158             result = str.match(reg); //afd,atd

159 

160             /*

161             [\b]:匹配退格键

162             */

163 

164             /*

165             \b:匹配一个词的边界符,例如空格或换行等等,当匹配换行符是,匹配参数m

166             */

167             reg = /\bc./g;

168             str = "Beijing is ca cbeautiful city";

169             result = str.match(reg); //ca,cb,ci

170 

171             /*

172             \B:代表一个非边界

173             */

174             reg = /\Bi./g;

175             str = "Beijing is a beautiful city";

176             result = str.match(reg); //ij,in,if,it

177 

178             /*

179             \f:匹配一个换页符

180             */

181 

182             /*

183             \n:匹配一个换行符,因为是换行符,所以要加入参数m

184             */

185 

186             /*

187             \r:匹配回车符

188             */

189 

190             /*

191             \s:匹配空格符

192             */

193             str = "ab cd t";

194             reg = /b[\s]c/g;

195             result = str.match(reg); //b c

196 

197             /*

198             \S:匹配非空格

199             */

200             str = "guoy ansiguoyansi";

201             reg = /y[\S]n/g;

202             result = str.match(reg); //yan

203 

204             /*

205             \t:匹配横向的tab

206             */

207 

208             /*

209             \v:匹配竖向的tab

210             */

211 

212             /*

213             \w:匹配数字、_或字母[a-zA-Z0-9]

214             */

215             str = "g1u中5国ir人_r";

216             reg = /\w/g;

217             result = str.match(reg); //g,1,u,5,i,r,_,r

218 

219             /*

220             \W:匹配飞数字、_或字母[^a-zA-Z0-9]

221             */

222             str = "g1u中5国ir人_r";

223             reg = /\W/g;

224             result = str.match(reg); //中,国,人