首页 > 代码库 > 常用JS正则匹配函数

常用JS正则匹配函数

2024-07-06 05:55:49   231人阅读

 

  1. //校验用户名：只能输入1-30个字母  
  2. function isTrueName(s)    
  3. {    
  4. var patrn=/^[a-zA-Z]{1,30}$/;    
  5. if (!patrn.exec(s)) return false    
  6. return true    
  7. }   
  8. //校验密码：只能输入6-20个字母、数字、下划线    
  9. function isPasswd(s)    
  10. {    
  11. var patrn=/^(/w){6,20}$/;    
  12. if (!patrn.exec(s)) return false    
  13. return true    
  14. }    
  15. //校验普通电话、传真号码：可以“+”开头，除数字外，可含有“-”    
  16. function isTel(s)    
  17. {    
  18. //var patrn=/^[+]{0,1}(/d){1,3}[ ]?([-]?(/d){1,12})+$/;    
  19. var patrn=/^[+]{0,1}(/d){1,3}[ ]?([-]?((/d)|[ ]){1,12})+$/;    
  20. if (!patrn.exec(s)) return false    
  21. return true    
  22. }    
  23. //校验手机号码：必须以数字开头，除数字外，可含有“-”    
  24. function isMobil(s)    
  25. {    
  26. var patrn=/^[+]{0,1}(/d){1,3}[ ]?([-]?((/d)|[ ]){1,12})+$/;    
  27. if (!patrn.exec(s)) return false    
  28. return true    
  29. }    
  30. //校验邮政编码    
  31. function isPostalCode(s)    
  32. {    
  33. //var patrn=/^[a-zA-Z0-9]{3,12}$/;    
  34. var patrn=/^[a-zA-Z0-9 ]{3,12}$/;    
  35. if (!patrn.exec(s)) return false    
  36. return true    
  37. }    
  38. //校验搜索关键字    
  39. function isSearch(s)    
  40. {    
  41. var patrn=/^[^`~!@#$%^&*()+=|///][/]/{/}:;‘/,.<>/?]{1}[^`~!@$%^&()+=|///]    
  42.         [/]/{/}:;‘/,.<>?]{0,19}$/;    
  43. if (!patrn.exec(s)) return false    
  44. return true    
  45. }    
  46.     
  47. function isIP(s) //by zergling    
  48. {    
  49. var patrn=/^[0-9.]{1,20}$/;    
  50. if (!patrn.exec(s)) return false    
  51. return true    
  52. }     
  53.     
  54. 其他正则表达式：    
  55. "^//d+$"　　//非负整数（正整数 + 0）    
  56. "^[0-9]*[1-9][0-9]*$"　　//正整数     
  57. "^((-//d+)|(0+))$"　　//非正整数（负整数 + 0）     
  58. "^-[0-9]*[1-9][0-9]*$"　　//负整数     
  59. "^-?//d+$"　　　　// 整数     
  60. "^(-?//d+)(//.//d+)?$"　　//浮点数     
  61. "^[A-Za-z]+$"　　// 由26个英文字母组成的字符串     
  62. "^[A-Z]+$"　　//由 26个英文字母的大写组成的字符串     
  63. "^[a-z]+$"　　//由 26个英文字母的小写组成的字符串     
  64. "^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串     
  65. "^//w+$"　　//由数字、26个英文字母或者下划线组成的字符串  
  66. "/^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(/.[a-zA-Z0-9_-])+/"   //email地址  
  67. "^[//w-]+(//.[//w-]+)*@[//w-]+(//.[//w-]+)+$"　　　　//email地址     
  68. "^[a-zA-z]+://(//w+(-//w+)*)(//.(//w+(-//w+)*))*(//?//S*)?$"　　//url  
  69. "/^/[ /t]*$/"; 匹配1个空白行。     
  70. "//d{2}-/d{5}/"; 验证1个ID号码是否由1个2位数字，1个连字符以及1个5位数字组成。     
  71. "/<(.*)>.*<///1>/" 匹配1个HTML 标记  

 

 

 

[c-sharp] view plaincopy
 
  1. 第一种方法：  
  2.   
  3. var reg = /pattern/;第二种方法：  
  4.   
  5. var reg = new  RegExp(‘pattern‘);正则表达式的exec方法简介  
  6. 语法：  
  7.   
  8. reg.exec(str);其中str为要执行正则表达式的目标字符串。  
  9.   
  10. 例如：  
  11.   
  12. <mce:script  type="text/javascript"><!--  
  13. var reg = /test/;  
  14. var str = ‘testString‘;  
  15. var result =  reg.exec(str);  
  16. alert(result);  
  17. // --></mce:script>将会输出test，因为正则表达式reg会匹配str(‘testString’)中的’test’子字符串，并且将其返回。  
  18.   
  19.   
  20. 我们使用下面的函数来做匹配正则的练习：  
  21.   
  22. function  execReg(reg,str){  
  23. var result =  reg.exec(str);  
  24. alert(result);  
  25. }函数接受一个正则表达式参数reg和一个目标字符串参数str，执行之后会alert出正则表达式与字符串的匹配结果。  
  26.   
  27. 用这个函数测试上面的例子就是：  
  28.   
  29. <mce:script  type="text/javascript"><!--  
  30. function  execReg(reg,str){  
  31. var result =  reg.exec(str);  
  32. alert(result);  
  33. }  
  34. var reg = /test/;  
  35. var str = ‘testString‘;  
  36. execReg(reg,str);  
  37. // --></mce:script>上面的例子用正则里的test去匹配字符串里的test，实在是很无聊，同样的任务用indexOf方法就可以完成了。用正则，自然是要完成更强大的功能：  
  38.   
  39. 一片两片三四片，落尽正则全不见  
  40. 上面的小标题翻译成正则就是{1},{2},{3,4},{1,}。  
  41.   
  42. c{n}  
  43. {1}表示一个的意思。  
  44.   
  45. /c{1}/只能匹配一个c。  
  46.   
  47. /c{2}/则会匹配两个连续的c。  
  48.   
  49. 以此类推,  
  50.   
  51. /c{n}/则会匹配n个连续的c。  
  52.   
  53. 看下面的例子：  
  54.   
  55. reg = /c{1}/;  
  56. str=‘cainiao‘;  
  57. execReg(reg,str);返回结果c  
  58.   
  59.   
  60. reg = /c{2}/;  
  61. str=‘cainiao‘;  
  62. execReg(reg,str);返回结果null，表示没有匹配成功。  
  63.   
  64.   
  65. reg = /c{2}/;  
  66. str=‘ccVC果冻爽‘;  
  67. execReg(reg,str);返回结果cc。  
  68.   
  69. c{m,n}  
  70. c{3,4}的意思是，连续的3个c或者4个c。  
  71.   
  72. 例如  
  73.   
  74. reg = /c{3,4}/;  
  75. str=‘ccVC果冻爽‘;  
  76. execReg(reg,str);返回结果null，表示没有匹配成功。  
  77.   
  78.   
  79. reg = /c{3,4}/;  
  80. str=‘cccTest‘;  
  81. execReg(reg,str);结果返回ccc。  
  82.   
  83.   
  84. reg = /c{3,4}/;  
  85. str=‘ccccTest‘;  
  86. execReg(reg,str);结果返回cccc，这表明正则会尽量多品牌，可3可4的时候它会选择多匹配一个。  
  87.   
  88.   
  89. reg = /c{3,4}/;  
  90. str=‘cccccTest‘;  
  91. execReg(reg,str);仍然只匹配4个c。  
  92.   
  93.   
  94. 由以上例子可以推断出，c{m,n}表示m个到n个c，且m小于等于n。  
  95.   
  96. c{n,}  
  97. c{1,}表示1个以上的c。例如：  
  98.   
  99.   
  100. reg = /c{1,}/;  
  101. str=‘cainiao‘;  
  102. execReg(reg,str);结果返回c。  
  103.   
  104.   
  105. reg = /c{1,}/;  
  106. str=‘cccccTest‘;  
  107. execReg(reg,str);返回ccccc，再次说明了正则表达式会尽量多地匹配。  
  108.   
  109.   
  110. reg = /c{2,}/;  
  111. str=‘cainiao‘;  
  112. execReg(reg,str);结果返回null，c{2,}表示2个以上的c，而cainiao中只有1个c。  
  113.   
  114.   
  115. 由以上例子可知，c{n,}表示最少n个c，最多则不限个数。  
  116.   
  117.   
  118. *,+,?  
  119. *表示0次或者多次，等同于{0,}，即  
  120.   
  121. c* 和 c{0,} 是一个意思。  
  122.   
  123.   
  124. +表示一次或者多次，等同于{1,}，即  
  125.   
  126. c+ 和 c{1,} 是一个意思。  
  127.   
  128.   
  129. 最后，?表示0次或者1次，等同于{0,1}，即  
  130.   
  131. c? 和 c{0,1} 是一个意思。  
  132.   
  133.   
  134. 贪心与非贪心  
  135. 人都是贪婪的，正则也是如此。我们在例子reg = /c{3,4}/;str=‘ccccTest‘;的例子中已经看到了，能匹配四个的时候，正则绝对不会去匹配三个。上面所介绍的所有的正则都是这样，只要在合法的情况下，它们会尽量多去匹配字符，这就叫做贪心模式。  
  136.   
  137. 如果我们希望正则尽量少地匹配字符，那么就可以在表示数字的符号后面加上一个?。组成如下的形式：  
  138.   
  139. {n,}?, *?, +?, ??, {m,n}?  
  140.   
  141. 同样来看一个例子：  
  142.   
  143. reg = /c{1,}?/;  
  144. str=‘ccccc‘;  
  145. execReg(reg,str);返回的结果只有1个c，尽管有5个c可以匹配，但是由于正则表达式是非贪心模式，所以只会匹配一个。  
  146.   
  147. /^开头,结尾$/  
  148. ^表示只匹配字符串的开头。看下面的例子：  
  149.   
  150.   
  151. reg = /^c/;  
  152. str=‘维生素c‘;  
  153. execReg(reg,str);结果为null，因为字符串‘维生素c’的开头并不是c，所以匹配失败。  
  154.   
  155.   
  156. reg = /^c/;  
  157. str=‘cainiao‘;  
  158. execReg(reg,str);这次则返回c，匹配成功，因为cainiao恰恰是以c开头的。  
  159.   
  160.   
  161. 与^相反，$则只匹配字符串结尾的字符，同样，看例子：  
  162.   
  163.   
  164. reg = /c$/;  
  165. str=‘cainiao‘;  
  166. execReg(reg,str);返回null，表示正则表达式没能在字符串的结尾找到c这个字符。  
  167.   
  168.   
  169. reg = /c$/;  
  170. str=‘维生素c‘;  
  171. execReg(reg,str);这次返回的结果是c，表明匹配成功。  
  172.   
  173.   
  174. 点’.’  
  175. ‘.’会匹配字符串中除了换行符/n之外的所有字符，例如  
  176.   
  177. reg = /./;  
  178. str=‘cainiao‘;  
  179. execReg(reg,str);结果显示，正则匹配到了字符c。  
  180.   
  181.   
  182. reg = /./;  
  183. str=‘blueidea‘;  
  184. execReg(reg,str);这次是b。  
  185.   
  186.   
  187. reg = /.+/;  
  188. str=‘blueidea——经典论坛  好_。‘;  
  189. execReg(reg,str);结果是“blueidea——经典论坛 好_。“也就是说所有的字符都被匹配掉了，包括一个空格，一个下滑线，和一个破折号。  
  190.   
  191.   
  192. reg = /.+/;  
  193. reg = /.+/;  
  194. str=‘bbs.blueidea.com‘;  
  195. execReg(reg,str);同样，直接返回整个字符串——bbs.blueidea.com，可见”.”也匹配”.”本身。  
  196.   
  197.   
  198. reg = /^./;  
  199. str=‘/ncainiao‘;  
  200. execReg(reg,str);结果是null，终于失败了，正则要求字符串的第一个字符不是换行，但是恰恰字符是以/n开始的。  
  201.   
  202.   
  203. 二选一，正则表达式中的或，“|“  
  204. b|c表示，匹配b或者c。  
  205.   
  206. 例如：  
  207.   
  208. reg = /b|c/;  
  209. str=‘blueidea‘;  
  210. execReg(reg,str);结果是b。  
  211.   
  212.   
  213. reg = /b|c/;  
  214. str=‘cainiao‘;  
  215. execReg(reg,str);结果是c。  
  216.   
  217.   
  218. reg = /^b|c.+/;  
  219. str=‘cainiao‘;  
  220. execReg(reg,str);匹配掉整个cainiao。  
  221.   
  222.   
  223. reg = /^b|c.+/;  
  224. str=‘bbs.blueidea.com‘;  
  225. execReg(reg,str);结果只有一个b，而不是整个字符串。因为上面正则表达式的意思是，匹配开头的b或者是c.+。  
  226.   
  227. 括号  
  228. reg = /^(b|c).+/;  
  229. str=‘bbs.blueidea.com‘;  
  230. execReg(reg,str);这次的结果是整个串bbs.blueidea.com，机上上面的括号这后，这个正则的意思是，如果字符串的开头是b或者c，那么匹配开头的b或者c以及其后的所有的非换行字符。  
  231.   
  232. 如果你也实验了的话，会发现返回的结果后面多出来一个“,b“，这是()内的b|c所匹配的内容。我们在正则表达式内括号里写的内容会被认为是子正则表达式，所匹配的结果也会被记录下来供后面使用。我们暂且不去理会这个特性。  
  233.   
  234.   
  235. 字符集合[abc]  
  236. [abc]表示a或者b或者c中的任意一个字符。例如：  
  237.   
  238. reg = /^[abc]/;  
  239. str=‘bbs.blueidea.com‘;  
  240. execReg(reg,str);返回结果是b。  
  241.   
  242.   
  243. reg = /^[abc]/;  
  244. str=‘test‘;  
  245. execReg(reg,str);这次的结果就是null了。  
  246.   
  247.   
  248. 我们在字字符集合中使用如下的表示方式:[a-z],[A-Z],[0-9]，分别表示小写字母，大写字母，数字。例如：  
  249.   
  250.   
  251. reg =  /^[a-zA-Z][a-zA-Z0-9_]+/;  
  252. str=‘test‘;  
  253. execReg(reg,str);结果是整个test，正则的意思是开头必须是英文字母，后面可以是英文字母或者数字以及下划线。  
  254.   
  255.   
  256. 反字符集合[^abc]  
  257. ^在正则表达式开始部分的时候表示开头的意思，例如/^c/表示开头是c；但是在字符集和中，它表示的是类似“非“的意思，例如[^abc]就表示不能是a，b或者c中的任何一个。例如：  
  258.   
  259. reg = /[^abc]/;  
  260. str=‘blueidea‘;  
  261. execReg(reg,str);返回的结果是l，因为它是第一个非abc的字符（即第一个b没有匹配）。同样：  
  262.   
  263. reg = /[^abc]/;  
  264. str=‘cainiao‘;  
  265. execReg(reg,str);则返回i，前两个字符都是[abc]集合中的。  
  266.   
  267. 由此我们可知：[^0-9]表示非数字，[^a-z]表示非小写字母，一次类推。  
  268.   
  269.   
  270. 边界与非边界  
  271. /b表示的边界的意思，也就是说，只有字符串的开头和结尾才算数。例如//bc/就表示字符串开始的c或者是结尾的c。看下面的例子：  
  272.   
  273.   
  274. reg = //bc/;  
  275. str=‘cainiao‘;  
  276. execReg(reg,str);返回结果c。匹配到了左边界的c字符。  
  277.   
  278.   
  279. reg = //bc/;  
  280. str=‘维生素c‘;  
  281. execReg(reg,str);仍然返回c，不过这次返回的是右侧边界的c。  
  282.   
  283.   
  284. reg = //bc/;  
  285. str=‘bcb‘;  
  286. execReg(reg,str);这次匹配失败，因为bcb字符串中的c被夹在中间，既不在左边界也不再右边界。  
  287.   
  288.   
  289. 与/b对应/B表示非边界。例如：  
  290.   
  291.   
  292. reg = //Bc/;  
  293. str=‘bcb‘;  
  294. execReg(reg,str);这次会成功地匹配到bcb中的c，。然而  
  295.   
  296.   
  297. reg = //Bc/;  
  298. str=‘cainiao‘;  
  299. execReg(reg,str);则会返回null。因为/B告诉正则，只匹配非边界的c。  
  300.   
  301.   
  302. 数字与非数字  
  303. /d表示数字的意思，相反，/D表示非数字。例如：  
  304.   
  305. reg = //d/;  
  306. str=‘cainiao8‘;  
  307. execReg(reg,str);返回的匹配结果为8，因为它是第一个数字字符。  
  308.   
  309.   
  310. reg = //D/;  
  311. str=‘cainiao8‘;  
  312. execReg(reg,str);返回c，第一个非数字字符。  
  313.   
  314.   
  315. 空白  
  316. /f匹配换页符，/n匹配换行符，/r匹配回车，/t匹配制表符，/v匹配垂直制表符。  
  317.   
  318. /s匹配单个空格，等同于[/f/n/r/t/v]。例如：  
  319.   
  320.   
  321. reg = //s.+/;  
  322. str=‘This is a test  String.‘;  
  323. execReg(reg,str);返回“is a test String.”，正则的意思是匹配第一个空格以及其后的所有非换行字符。  
  324.   
  325.   
  326. 同样，/S表示非空格字符。  
  327.   
  328. reg = //S+/;  
  329. str=‘This is a test  String.‘;  
  330. execReg(reg,str);匹配结果为This，当遇到第一个空格之后，正则就停止匹配了。  
  331.   
  332.   
  333. 单词字符  
  334. /w表示单词字符，等同于字符集合[a-zA-Z0-9_]。例如：  
  335.   
  336. reg = //w+/;  
  337. str=‘blueidea‘;  
  338. execReg(reg,str);返回完整的blueidea字符串，因为所有字符都是单词字符。  
  339.   
  340.   
  341. reg = //w+/;  
  342. str=‘.className‘;  
  343. execReg(reg,str);结果显示匹配了字符串中的className，只有第一个“.”——唯一的非单词字符没有匹配。  
  344.   
  345.   
  346. reg = //w+/;  
  347. str=‘中文如何？‘;  
  348. execReg(reg,str);试图用单词字符去匹配中文自然行不通了，返回null。  
  349.   
  350.   
  351. /W表示非单词字符，等效于[^a-zA-Z0-9_]  
  352.   
  353. reg = //W+/;  
  354. str=‘中文如何？‘;  
  355. execReg(reg,str);返回完整的字符串，因为，无论是中文和“？”都算作是非单词字符。  
  356.   
  357.   
  358. 反向引用  
  359. 形式如下：/(子正则表达式)/1/  
  360.   
  361. 依旧用例子来说明：  
  362.   
  363. 1.  
  364.   
  365. reg = //w/;  
  366. str=‘blueidea‘;  
  367. execReg(reg,str);返回b。  
  368.   
  369. 2.  
  370.   
  371. reg = /(/w)(/w)/;  
  372. str=‘blueidea‘;  
  373. execReg(reg,str);返回bl,b,l  
  374.   
  375. bl是整个正则匹配的内容，b是第一个括号里的子正则表达式匹配的内容，l是第二个括号匹配的内容。  
  376.   
  377. 3.  
  378.   
  379. reg = /(/w)/1/;  
  380. str=‘blueidea‘;  
  381. execReg(reg,str);则会返回null。这里的“/1”就叫做反向引用，它表示的是第一个括号内的字正则表达式匹配的内容。在上面的例子中，第一个括号里的(/w)匹配了b，因此“/1”就同样表示b了，在余下的字符串里自然找不到b了。  
  382.   
  383. 与第二个例子对比就可以发现，“/1”是等同于“第1个括号匹配的内容”，而不是“第一个括号的内容”。  
  384.   
  385.   
  386. reg = /(/w)/1/;  
  387. str=‘bbs.blueidea.com‘;  
  388. execReg(reg,str);这个正则则会匹配到bb。  
  389.   
  390.   
  391. 同样，前面有几个子正则表达式我们就可以使用几个反向引用。例如：  
  392.   
  393. reg = /(/w)(/w)/2/1/;  
  394. str=‘woow‘;  
  395. execReg(reg,str);会匹配成功，因为第一个括号匹配到w，第二个括号匹配到o，而/2/1则表示ow，恰好匹配了字符串的最后两个字符。  
  396.   
  397.   
  398. 括号（2）  
  399. 前面我们曾经讨论过一次括号的问题，见下面这个例子：  
  400.   
  401. reg = /^(b|c).+/;  
  402. str=‘bbs.blueidea.com‘;  
  403. execReg(reg,str);这个正则是为了实现只匹配以b或者c开头的字符串，一直匹配到换行字符，但是。上面我们已经看到了，可以使用“/1”来反向引用这个括号里的子正则表达式所匹配的内容。而且exec方法也会将这个字正则表达式的匹配结果保存到返回的结果中。  
  404.   
  405. 不记录子正则表达式的匹配结果  
  406. 使用形如(?:pattern)的正则就可以避免保存括号内的匹配结果。例如：  
  407.   
  408. reg = /^(?:b|c).+/;  
  409. str=‘bbs.blueidea.com‘;  
  410. execReg(reg,str);可以看到返回的结果不再包括那个括号内的字正则表达式多匹配的内容。  
  411.   
  412. 同理，反向引用也不好使了：  
  413.   
  414. reg = /^(b|c)/1/;  
  415. str=‘bbs.blueidea.com‘;  
  416. execReg(reg,str);返回bb,b。bb是整个正则表达式匹配的内容，而b是第一个子正则表达式匹配的内容。  
  417.   
  418. reg = /^(?:b|c)/1/;  
  419. str=‘bbs.blueidea.com‘;  
  420. execReg(reg,str);返回null。由于根本就没有记录括号内匹配的内容，自然没有办法反向引用了。  
  421.   
  422.   
  423. 正向预查  
  424. 形式：(?=pattern)  
  425.   
  426. 所谓正向预查，意思就是：要匹配的字符串，后面必须紧跟着pattern！  
  427.   
  428. 我们知道正则表达式/cainiao/会匹配cainiao。同样，也会匹配cainiao9中的cainiao。但是我们可能希望，cainiao只能匹配cainiao8中的菜鸟。这时候就可以像下面这样写：/cainiao(?=8)/，看两个实例：  
  429.   
  430. reg = /cainiao(?=8)/;  
  431. str=‘cainiao9‘;  
  432. execReg(reg,str);返回null。  
  433.   
  434.   
  435. reg = /cainiao(?=8)/;  
  436. str=‘cainiao8‘;  
  437. execReg(reg,str);匹配cainiao。  
  438.   
  439. 需要注意的是，括号里的内容并不参与真正的匹配，只是检查一下后面的字符是否符合要求而已，例如上面的正则，返回的是cainiao，而不是cainiao8。  
  440.   
  441.   
  442. 再来看两个例子：  
  443.   
  444. reg = /blue(?=idea)/;  
  445. str=‘blueidea‘;  
  446. execReg(reg,str);匹配到blue，而不是blueidea。  
  447.   
  448.   
  449. reg = /blue(?=idea)/;  
  450. str=‘bluetooth‘;  
  451. execReg(reg,str);返回null，因为blue后面不是idea。  
  452.   
  453.   
  454. reg = /blue(?=idea)/;  
  455. str=‘bluetoothidea‘;  
  456. execReg(reg,str);同样返回null。  
  457.   
  458.   
  459. ?!  
  460. 形式(?!pattern)和?=恰好相反，要求字符串的后面不能紧跟着某个pattern，还拿上面的例子：  
  461.   
  462. reg = /blue(?!idea)/;  
  463. str=‘blueidea‘;  
  464. execReg(reg,str);返回null，因为正则要求，blue的后面不能是idea。  
  465.   
  466.   
  467. reg = /blue(?!idea)/;  
  468. str=‘bluetooth‘;  
  469. execReg(reg,str);则成功返回blue。  
  470.   
  471.   
  472. 匹配元字符  
  473. 首先要搞清楚什么是元字符呢？我们之前用过*,+,?之类的符号，它们在正则表达式中都有一定的特殊含义，类似这些有特殊功能的字符都叫做元字符。例如  
  474.   
  475. reg = /c*/;表示有任意个c，但是如果我们真的想匹配’c*’这个字符串的时候怎么办呢？只要将*转义了就可以了，如下：  
  476.   
  477. reg = /c/*/;  
  478. str=‘c*‘;  
  479. execReg(reg,str);返回匹配的字符串：c*。  
  480.   
  481.   
  482. 同理，要匹配其他元字符，只要在前面加上一个“/”就可以了。  
  483.   
  484.   
  485. 正则表达式的修饰符  
  486. 全局匹配，修饰符g  
  487. 形式：/pattern/g  
  488.   
  489. 例子：reg = /b/g;  
  490.   
  491. 后面再说这个g的作用。先看后面的两个修饰符。  
  492.   
  493. 不区分大小写，修饰符i  
  494. 形式：/pattern/i  
  495.   
  496. 例子：  
  497.   
  498. var reg = /b/;  
  499. var str = ‘BBS‘;  
  500. execReg(reg,str);返回null，因为大小写不符合。  
  501.   
  502.   
  503. var reg = /b/i;  
  504. var str = ‘BBS‘;  
  505. execReg(reg,str);匹配到B，这个就是i修饰符的作用了。  
  506.   
  507. 行首行尾，修饰符m  
  508. 形式：/pattern/m  
  509.   
  510. m修饰符的作用是修改^和$在正则表达式中的作用，让它们分别表示行首和行尾。例如：  
  511.   
  512. var reg = /^b/;  
  513. var str = ‘test/nbbs‘;  
  514. execReg(reg,str);匹配失败，因为字符串的开头没有b字符。但是加上m修饰符之后：  
  515.   
  516. var reg = /^b/m;  
  517. var str = ‘test/nbbs‘;  
  518. execReg(reg,str);匹配到b，因为加了m修饰符之后，^已经表示行首，由于bbs在字符串第二行的行首，所以可以成功地匹配。  
  519.   
  520. exec方法详解  
  521. exec方法的返回值  
  522. exec方法返回的其实并不是匹配结果字符串，而是一个对象，简单地修改一下execReg函数，来做一个实验就可以印证这一点：  
  523.   
  524. function  execReg(reg,str){  
  525. var result =  reg.exec(str);  
  526. alert(typeof result);  
  527. }  
  528. var reg = /b/;  
  529. var  str=‘bbs.bblueidea.com‘;  
  530. execReg(reg,str);结果显示result的类型是object。而且是一个类似数组的对象。使用for in可以知道它的属性: index input 0。其中index是表示匹配在原字符串中的索引；而input则是表示输入的字符串；  
  531.   
  532. 至于0则是表示只有一个匹配结果，可以用下标0来引用这个匹配结果，这个数量可能改变。我们可以通过返回值的length属性来得知匹配结果的总数量。  
  533.   
  534. 根据以上对返回值的分析，修改execReg函数如下：  
  535.   
  536. function  execReg(reg,str){  
  537. var result =  reg.exec(str);  
  538. document.write(‘index:‘+result.index+‘<br  />‘  
  539. +‘input:‘+result.input+‘<br  />‘  
  540. );  
  541. for(i=0;i<result.length;i++){  
  542. document.write(‘result[‘+i+‘]:‘+result[i]+‘<br  />‘)  
  543. }  
  544. }马上来实验一下：  
  545.   
  546. var reg = //w/;  
  547. var  str=‘bbs.bblueidea.com‘;  
  548. execReg(reg,str);结果如下：  
  549.   
  550. index:0   
  551. input:bbs.bblueidea.com   
  552. result[0]:b   
  553. 输入字符串为bbs.bblueidea.com；  
  554.   
  555. 匹配的b在原字符串的索引是0。  
  556.   
  557. 正则的匹配结果为一个，b；  
  558.   
  559.   
  560. var reg =  /(/w)(/w)(.+)/;  
  561. var  str=‘bbs.bblueidea.com‘;  
  562. execReg(reg,str);结果为：  
  563.   
  564. index:0  
  565. input:bbs.bblueidea.com  
  566. result[0]:bbs.bblueidea.com  
  567. result[1]:b  
  568. result[2]:b  
  569. result[3]:s.bblueidea.com  
  570.   
  571.   
  572. 由上面两个例子可见，返回对象[0]就是整个正则表达式所匹配的内容。后续的元素则是各个子正则表达式的匹配内容。  
  573.   
  574.   
  575. exec方法对正则表达式的更新  
  576. exec方法在返回结果对象的同时，还可能会更新原来的正则表达式，这就要看正则表达式是否设置了g修饰符。先来看两个例子吧：  
  577.   
  578. var reg = /b/;  
  579. var str =  ‘bbs.blueidea.com‘;  
  580. execReg(reg,str);  
  581. execReg(reg,str);结果如下：  
  582.   
  583. index:0  
  584. input:bbs.blueidea.com  
  585. result[0]:b  
  586. index:0  
  587. input:bbs.blueidea.com  
  588. result[0]:b  
  589.   
  590. 也就是说，两次匹配的结果完全一样，从索引可以看出来，匹配的都是字符串首的b字符。  
  591.   
  592. 下面看看设置了g的正则表达式表现如何：  
  593.   
  594. var reg = /b/g;  
  595. var str =  ‘bbs.blueidea.com‘;  
  596. execReg(reg,str);  
  597. execReg(reg,str);结果如下：  
  598.   
  599. index:0  
  600. input:bbs.blueidea.com  
  601. result[0]:b  
  602. index:1  
  603. input:bbs.blueidea.com  
  604. result[0]:b  
  605.   
  606. 可以看得出来，第二次匹配的是字符串的字符串的第二个b。这也就是g修饰符的作用了，下面来看exec是如何区别对待g和非g正则表达式的。  
  607.   
  608.   
  609. 如果正则表达式没有设置g，那么exec方法不会对正则表达式有任何的影响，如果设置了g，那么exec执行之后会更新正则表达式的lastIndex属性，表示本次匹配后，所匹配字符串的下一个字符的索引，下一次再用这个正则表达式匹配字符串的时候就会从上次的lastIndex属性开始匹配，也就是上面两个例子结果不同的原因了。  
  610.   
  611.   
  612. test方法  
  613. test方法仅仅检查是否能够匹配str，并且返回布尔值以表示是否成功。同样建立一个简单的测试函数：  
  614.   
  615. function  testReg(reg,str){  
  616. alert(reg.test(str));  
  617. }实例1  
  618.   
  619. var reg = /b/;  
  620. var str =  ‘bbs.blueidea.com‘;  
  621. testReg(reg,str);成功，输出true。  
  622.   
  623. 实例2  
  624.   
  625. var reg = /9/;  
  626. var str =  ‘bbs.blueidea.com‘;  
  627. testReg(reg,str);失败，返回false。  
  628.   
  629. 使用字符串的方法执行正则表达式  
  630. match方法  
  631. 形式：str.match(reg);  
  632.   
  633. 与正则表达式的exec方法类似，该方法同样返回一个类似数组的对象，也有input和index属性。我们定义如下一个函数用来测试：  
  634.   
  635. function  matchReg(reg,str){  
  636. var result =  str.match(reg);  
  637. if(result ){  
  638. document.write(‘index:‘+result.index+‘<br  />‘  
  639. +‘input:‘+result.input+‘<br  />‘  
  640. );  
  641. for(i=0;i<result.length;i++){  
  642. document.write(‘result[‘+i+‘]:‘+result[i]+‘<br  />‘)  
  643. }  
  644. }else{  
  645. alert(‘null：匹配失败！‘)  
  646. }  
  647. }例如：  
  648.   
  649. var reg = /b/;  
  650. var str =  ‘bbs.blueidea.com‘;  
  651. matchReg(reg,str);结果如下：  
  652.   
  653. index:0  
  654. input:bbs.blueidea.com  
  655. result[0]:b  
  656.   
  657. 可见，和exec的结果一样。  
  658.   
  659. 但是如果正则表达式设置了g修饰符，exec和match的行为可就不一样了，见下例：  
  660.   
  661. index:undefined  
  662. input:undefined  
  663. result[0]:b  
  664. result[1]:b  
  665. result[2]:b  
  666.   
  667. 设置了g修饰符的正则表达式在完成一次成功匹配后不会停止，而是继续找到所有可以匹配到的字符。返回的结果包括了三个b。不过没有提供input和index这些信息。  
  668.   
  669.   
  670. replace方法  
  671. 形式：str. replace (reg,’new str’);  
  672.   
  673. 它的作用是将str字符串中匹配reg的部分用’’new str”部分代码，值得注意的是原字符串并不会被修改，而是作为返回值被返回。例子：  
  674.   
  675. var reg = /b/;  
  676. var str =  ‘bbs.blueidea.com‘;  
  677. var newStr =  str.replace(reg,‘c‘);  
  678. document.write(newStr);结果为cbs.blueidea.com，只有第一个b被替换为c。  
  679.   
  680.   
  681. var reg = /b/g;  
  682. var str =  ‘bbs.blueidea.com‘;  
  683. var newStr =  str.replace(reg,‘c‘);  
  684. document.write(newStr);输出ccs.clueidea.com  
  685.   
  686. 由于，设置了g修饰符，所以会替换掉所有的b。  
  687.   
  688.   
  689. var reg = //w+/g;  
  690. var str =  ‘bbs.blueidea.com‘;  
  691. var newStr =  str.replace(reg,‘word‘);  
  692. document.write(newStr);输出：  
  693.   
  694. word.word.word。  
  695.   
  696. 在replace函数中使用$引用子正则表达式匹配内容  
  697. 就像在正则里我们可以使用/1来引用第一个子正则表达式所匹配的内容一样，我们在replace函数的替换字符里也可以使用$1来引用相同的内容。  
  698.   
  699. 还是来看一个例子吧：  
  700.   
  701. var reg =  /(/w+).(/w+).(/w+)/;  
  702. var str =  ‘bbs.blueidea.com‘;  
  703. var newStr =  str.replace(reg,‘$1.$1.$1‘);  
  704. document.write(newStr);输出的结果为：  
  705.   
  706. bbs.bbs.bbs  
  707.   
  708. 首先，我们知道第一个子正则表达式匹配到了bbs，那么$1也就代表bbs了。其后我们把替换字符串设置为‘$1.$1.$1‘,其实也就是“bbs.bbs.bbs”。同理，$2就是blueidea，$3就是com。  
  709.   
  710.   
  711. 在来看一个例子，颠倒空格前后两个单词的顺序。  
  712.   
  713. var reg =  /(/w+)/s(/w+)/;  
  714. var str = ‘cainiao  gaoshou‘;  
  715. var newStr =  str.replace(reg,‘$2 $1‘);  
  716. document.write(newStr);结果为：gaoshou cainiao，也就是空格前后的单词被调换顺序了。  
  717.   
  718.   
  719. 由于在替换文本里$有了特殊的含义，所以我们如果想要是用$这个字符的话，需要写成$$，例如：  
  720.   
  721. var reg =  /(/w+)/s(/w+)/;  
  722. var str = ‘cainiao  gaoshou‘;  
  723. var newStr =  str.replace(reg,‘$$ $$‘);  
  724. document.write(newStr);结果为：$ $。  
  725.   
  726.   
  727. search方法和split方法  
  728. 同样，字符串的search方法和split方法中也可以使用正则表达式，形式如下：  
  729.   
  730. str.search(reg);  
  731.   
  732. search返回正则表达式第一次匹配的位置。例子：  
  733.   
  734. var reg = /idea/;  
  735. var str = ‘blueidea‘;  
  736. var pos =  str.search(reg);  
  737. document.write(pos);结果为4。  
  738.   
  739. 下面的例子找出第一个非单词字符：  
  740.   
  741. var reg = //W/;  
  742. var str =  ‘bbs.blueidea.com‘;  
  743. var pos =  str.search(reg);  
  744. document.write(pos);结果为3，也就是那个点“.”的位置。  
  745.   
  746.   
  747. str.split(reg,’seprator’);  
  748. split返回分割后的数组，例如：  
  749. var reg = //W/;  
  750. var str =  ‘bbs.blueidea.com‘;  
  751. var arr =  str.split(reg);  
  752. document.write(arr);结果为：bbs,blueidea,com，可见数组被非单词字符分为了有三个元素的数组。  
  753.   
  754.   
  755. var  reg = //W/;  
  756. var  str = ‘http://www.baidu.com/‘;  
  757. var  arr = str.split(reg);  
  758. document.write(arr.length+‘<br  />‘);  
  759. document.write(arr);结果为：  
  760.   
  761. 7  
  762. http,,,www,baidu,com,  
  763.   
  764. 可见字符串被分为了有7个元素的数组，其中包括了三个为空字符串的元素。  
  765.   
  766. JavaScript正则表达式  
  767. JavaScript正则表达式   

 

[c-sharp] view plaincopy
 
  1. 今天突然遇到了这个功能，百度一下找到了很多，不外乎两种方式：正则表达式和逐个字符判断，都挺麻烦。正则表达式试了半天都没成功。自己琢磨了一个比较简单的方法：取整后判断是否和原值相等!  
  2.   
  3. javascript的取整函数是：parseInt  
  4.   
  5. if(parseInt(value)==value)  
  6. {  
  7.   
  8. //整数！  
  9. }  
  10.   
  11.   
  12. 正则方式  
  13.   
  14. 1） "^//d+$"　　//非负整数（正整数 + 0）   
  15. "^[0-9]*[1-9][0-9]*$"　　//正整数   
  16. "^((-//d+)|(0+))$"　　//非正整数（负整数 + 0）   
  17. "^-[0-9]*[1-9][0-9]*$"　　//负整数   
  18. "^-?//d+$"　　　　//整数   
  19. "^//d+(//.//d+)?$"　　//非负浮点数（正浮点数 + 0）   
  20. "^(([0-9]+//.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*//.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数   
  21. "^((-//d+(//.//d+)?)|(0+(//.0+)?))$"　　//非正浮点数（负浮点数 + 0）   
  22. "^(-(([0-9]+//.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*//.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数   
  23. "^(-?//d+)(//.//d+)?$"　　//浮点数  
  24. 2） var r = /^/+?[1-9][0-9]*$/;　　//正整数   
  25.       r.test(str);  

 


联系
我们