LOFTER for ipad —— 让兴趣,更有趣

点击下载 关闭

LOFTER-网易轻博

正则

597浏览    91参与
软件交流

正则表达式 IP地址

匹配IP地址的正则表达式:

  1. IP地址字符串形式的正则表达式:IP地址分为4段,每段0-255

精确写法

0‐99:[1‐9]?\d    #a

100‐199: 1\d{2}   #b

200‐249: 2[0‐4]\d  #c

250‐255: 25[0‐5]   #d

先表示前三组,每组后面加点:每组都是从a b c d选择,并加点
最后一组从a b c d选择,不加点

(([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5]).){3}([1‐9]?\d...

匹配IP地址的正则表达式:

  1. IP地址字符串形式的正则表达式:IP地址分为4段,每段0-255

精确写法

0‐99:[1‐9]?\d    #a

100‐199: 1\d{2}   #b

200‐249: 2[0‐4]\d  #c

250‐255: 25[0‐5]   #d

先表示前三组,每组后面加点:每组都是从a b c d选择,并加点
最后一组从a b c d选择,不加点

(([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5]).){3}([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5])


simazx
IComac

python 正则表达式使用

.    表示任意字符

*, +, ?    '*'表示匹配前一个字符重复 0 次到无限次,'+'表示匹配前一个字符重复 1次到无限次,'?'表示匹配前一个字符重复 0 次到1次

*?, +?, ??     前面的*,+,?等都是贪婪匹配,也就是尽可能多匹配,后面加?号使其变成惰性匹配即非贪婪匹配

re.S   将“\n”当做一个普通的字符加入到这个字符串中

|   ...

.    表示任意字符

*, +, ?    '*'表示匹配前一个字符重复 0 次到无限次,'+'表示匹配前一个字符重复 1次到无限次,'?'表示匹配前一个字符重复 0 次到1次

*?, +?, ??     前面的*,+,?等都是贪婪匹配,也就是尽可能多匹配,后面加?号使其变成惰性匹配即非贪婪匹配

re.S   将“\n”当做一个普通的字符加入到这个字符串中

|    表示或者

\    对特殊字符进行转义

\\   将特殊字符转为普通字符

[]    表示一个字符集

(...)    作为一个分组. findall 在有组的情况下只显示组的内容

^    表示字符串开头

$    表示字符串结尾

\s    匹配任意空白字符,相当于 [ \t\n\r\f\v]

\s+$  匹配空行

\d    匹配任意十进制数,相当于 [0-9]

\w    匹配任意数字和字母,相当于 [a-zA-Z0-9_]

re.findall(r'<p>(.*?)</p>', content, re.S | re.M)    能够以列表的形式返回能匹配的子串, 即能抓取网页中段落内容

re.match(r'\s', line)    匹配以空格开头的字符串, 没有则返回None

re.sub(r'<a(.*?)>|</a>|<strong>|</strong>','',line)    替换函数,把<a ...>、</a>、<strong>、</strong>都替换为空,即删除

参考教程:

https://www.cnblogs.com/yyyg/p/5498803.html

http://www.runoob.com/python/python-reg-expressions.html

马化腾

正则表达式

/^0*(13|14|15|18|17)\d{9}$/ 手机号检查

/^0*(13|14|15|18|17)\d{9}$/ 手机号检查

锋镝

javascript正则表达式-司徒正美

javascript正则表达式


网上正则表达式的教程够多了,但由于javascript的历史比较悠久,也比较古老,因此有许多特性是不支持的。我们先从最简单地说起,文章所演示的正则基本都是perl方式。


元字符


( [ { \ ^ $ | ) ? * + .


预定义的特殊字符


字符正则描述

\t/\t/制表符

\n/\n/制表符

\r/\r/回车符

\f/\f/换页符

\a/\a/alert字符

\e/\e/escape字符

\cX/\cX/与...

javascript正则表达式


网上正则表达式的教程够多了,但由于javascript的历史比较悠久,也比较古老,因此有许多特性是不支持的。我们先从最简单地说起,文章所演示的正则基本都是perl方式。


元字符


( [ { \ ^ $ | ) ? * + .


预定义的特殊字符


字符正则描述

\t/\t/制表符

\n/\n/制表符

\r/\r/回车符

\f/\f/换页符

\a/\a/alert字符

\e/\e/escape字符

\cX/\cX/与X相对应的控制字符

\b/\b/与回退字符

\v/\v/垂直制表符

\0/\0/空字符

字符类


简单类


原则上正则的一个字符对应一个字符,我们可以用[]把它们括起来,让[]这个整体对应一个字符。如


alert(/ruby/.test("ruby"));//true

alert(/[abc]/.test("a"));//true

alert(/[abc]/.test("b"));//true

alert(/[abc]/.test("c"));//true

alert("a bat ,a Cat,a fAt bat ,a faT cat".match(/[bcf]at/gi));//bat,Cat,fAt,bat,faT,cat

负向类


也是在那个括号里做文章,前面加个元字符进行取反,表示匹配不能为括号里面的字符。


alert(/[^abc]/.test("a"));//false

alert(/[^abc]/.test("b"));//false

alert(/[^abc]/.test("6"));//true

alert(/[^abc]/.test("gg"));//true

范围类


还是在那个中括号里面做文章。有时匹配的东西过多,而且类型又相同,全部输入太麻烦,我们可以用它。特征就是在中间加了个横线。


组合类


还是在那个中括号里面做文章。允许用中括号匹配不同类型的单个字符。


alert(/[a-f]/.test("b"));//true

alert(/[a-f]/.test("k"));//false

alert(/[a-z]/.test("h"));//true

alert(/[A-Z]/.test("gg"));//false

alert(/[^H-Y]/.test("G"));//true

alert(/[0-9]/.test("8"));//true

alert(/[^7-9]/.test("6"));//true

alert(/[a-m1-5\n]/.test("a"))//true

alert(/[a-m1-5\n]/.test("3"))//true

var a = "\n\

        "

alert(/[a-m1-5\n]/.test(a))//true

alert(/[a-m1-5\n]/.test("r"))//false

预定义类


还是在那个中括号里面做文章,不过它好像已经走到尽头了。由于是中括号的马甲,因此它们还是对应一个字符。


字符等同于描述

.[^\n\r]除了换行和回车之外的任意字符

\d[0-9]数字字符

\D[^0-9]非数字字符

\s[ \t\n\x0B\f\r]空白字符

\S[^ \t\n\x0B\f\r]非空白字符

\w[a-zA-Z_0-9]单词字符(所有的字母)

\W[^a-zA-Z_0-9]非单词字符

alert(/\d/.test("3"))//true

alert(/\d/.test("w"))//false

alert(/\D/.test("w"))//true

alert(/\w/.test("w"))//true

alert(/\w/.test("司"))//false

alert(/\W/.test("徒"))//true

alert(/\s/.test(" "))//true

alert(/\S/.test(" "))//false

alert(/\S/.test("正"))//true

alert(/./.test("美"))//true

alert(/./.test("  "))//true

var a = "\n\

      "

alert(/./.test(a))//true

量词


由于元字符与特殊字符或字符类或者它们的组合(中括号)甚至它们的马甲(预定义类)都是一对一进行匹配。我们要匹配“司徒正美这个词”,最简单都要/..../,如果长到50多个字符岂不是要死人。因此我们逼切需要一个简单的操作,来处理这数量关系。


简单量词


代码类型描述

?软性量词出现零次或一次

*软性量词出现零次或多次(任意次)

+软性量词出现一次或多次(至道一次)

{n}硬性量词对应零次或者n次

{n,m}软性量词至少出现n次但不超过m次

{n,}软性量词至少出现n次(+的升级版)

alert(/..../.test("司徒正美"))//true

alert(/司徒正美/.test("司徒正美"))//true

alert(/[\u4e00-\u9fa5]{4}/.test("司徒正美"))//true

alert(/[\u4e00-\u9fa5]{4}/.test("司徒正美55"))//true

alert(/^[\u4e00-\u9fa5]+$/.test("正则表达式"))//true

alert(/^[\u4e00-\u9fa5]+$/.test("正则表达式&*@@"))//false

alert(/\d{6}/.test("123456"))//true

alert(/[ruby]{2}/.test("rr"))//true

alert(/[ruby]{2}/.test("ru"))//true

alert(/[ruby]{2}/.test("ry"))//true

/[\u4e00-\u9fa5]/用于匹配单个汉字。


贪婪量词,惰性量词与支配性量词


贪婪量词,上面提到的所有简单量词。就像成语中说的巴蛇吞象那样,一口吞下整个字符串,发现吞不下(匹配不了),再从后面一点点吐出来(去掉最后一个字符,再看这时这个整个字符串是否匹配,不断这样重复直到长度为零)


隋性量词,在简单量词后加问号。由于太懒了,先吃了前面第一个字符,如果不饱再捏起多添加一个(发现不匹配,就读下第二个,与最初的组成一个有两个字符串的字符串再尝试匹配,如果再不匹配,再吃一个组成拥有三个字符的字符串……)。其工作方式与贪婪量词相反。


支配性量词,在简单量词后加加号。上面两种都有个不断尝试的过程,而支配性量词却只尝试一次,不合口味就算了。就像一个出身高贵居支配地位的公主。但你也可以说它是最懒量词。由于javascript不支持,所以它连出场的机会也没有了。


var re1 = /.*bbb/g;//贪婪

var re2 = /.*?bbb/g;//惰性

//  var re3 = /.*+bbb/g;//支配性,javascript不支持,IE与所有最新的标准浏览器都报错

alert(re1.test("abbbaabbbaaabbbb1234")+"");//true

alert(re1.exec("abbbaabbbaaabbbb1234")+"");//null

alert("abbbaabbbaaabbbb1234".match(re1)+"");//abbbaabbbaaabbbb

 

alert(re2.test("abbbaabbbaaabbbb1234")+"");//true

alert(re2.exec("abbbaabbbaaabbbb1234")+"");//aabbb

alert("abbbaabbbaaabbbb1234".match(re2)+"");//abbb,aabbb,aaabbb

分组


到目前为止,我们只能一个字符到匹配,虽然量词的出现,能帮助我们处理一排密紧密相连的同类型字符。但这是不够的,下面该轮到小括号出场了,中括号表示范围内选择,大括号表示重复次数。小括号允许我们重复多个字符。


//分组+量词

alert(/(dog){2}/.test("dogdog"))//true

//分组+范围

alert("baddad".match(/([bd]ad?)*/))//baddad,dad

//分组+分组

alert("mon and dad".match(/(mon( and dad)?)/))//mon and dad,mon and dad, and dad

反向引用


反向引用标识由正则表达式中的匹配组捕获的子字符串。每个反向引用都由一个编号或名称来标识,并通过“\编号”表示法进行引用。


var color = "#990000";

/#(\d+)/.test(color);

alert(RegExp.$1);//990000

 

alert(/(dog)\1/.test("dogdog"))//true

 

var num = "1234 5678";

var newNum = num.replace(/(\d{4}) (\d{4})/,"$2 $1");

alert(newNum)

候选


继续在分组上做文章。在分组中插入管道符(“|”),把它划分为两个或多个候多项。


var reg = /(red|black|yellow)!!/;

alert(reg.test("red!!"))//true

alert(reg.test("black!!"))//true

alert(reg.test("yellow!!"))//true

非捕获性分组


并不是所有分组都能创建反向引用,有一种特别的分组称之为非捕获性分组,它是不会创建反向引用。反之,就是捕获性分组。要创建一个非捕获性分组,只要在分组的左括号的后面紧跟一个问号与冒号就行了。


var color = "#990000";

/#(?:\d+)/.test(color);

alert(RegExp.$1);//""

题目,移除所有标签,只留下innerText!


var html = "<p><a href='http://www.cnblogs.com/rubylouvre/'>Ruby Louvre</a>by <em>司徒正美</em></p>";

var text = html.replace(/<(?:.|\s)*?>/g, "");

alert(text)

注意:javascript不存在命名分组


前瞻


继续在分组内做文章。前瞻与后瞻其实都属于零宽断言,但javascript不支持后瞻。


零宽断言

正则名称描述

(?=exp)正向前瞻匹配exp前面的位置

(?!exp)负向前瞻匹配后面不是exp的位置

(?<=exp)正向后瞻匹配exp后面的位置不支持

(?<!exp)负向后瞻匹配前面不是exp的位置不支持

正向前瞻用来检查接下来的出现的是不是某个特定的字符集。而负向前瞻则是检查接下来的不应该出现的特定字符串集。零宽断言是不会被捕获的。


var str1 = "bedroom";

var str2 = "bedding";

var reBed = /(bed(?=room))///在我们捕获bed这个字符串时,抢先去看接下来的字符串是不是room

alert(reBed.test(str1));//true

alert(RegExp.$1)//bed

alert(RegExp.$2 === "")//true

alert(reBed.test(str2))//false

var str1 = "bedroom";

var str2 = "bedding";

var reBed = /(bed(?!room))/  //要来它后面不能是room

alert(reBed.test(str1))//false

alert(reBed.test(str2))//true

题目,移除hr以外的所有标签,只留下innerText!


var html = "<p><a href='http://www.cnblogs.com/rubylouvre/'>Ruby Louvre</a></p><hr/><p>by <em>司徒正美</em></p>";

var text = html.replace(/<(?!hr)(?:.|\s)*?>/ig,"")

alert(text)//Ruby Louvre<hr/>by 司徒正美

边界


一个要与字符类合用的东西。


边界

正则名称描述

^开头注意不能紧跟于左中括号的后面

$结尾

\b单词边界指[a-zA-Z_0-9]之外的字符

\B非单词边界

题目,设计一个字符串原型方法,实现首字母大写!


var a = "ruby";

String.prototype.capitalize =  function () {

     return this.replace(/^\w/, function (s) {

         return s.toUpperCase();

     });

 }

alert(a.capitalize())//Ruby

单词边界举例。要匹配的东西的前端或未端不能为英文字母阿拉伯字数字或下横线。


var str = "12w-eefd&efrew";

alert(str.match(/\b\w+\b/g))//12w,eefd,efrew

实例属性描述

global是当前表达式模式首次匹配内容的开始位置,从0开始计数。其初始值为-1,每次成功匹配时,index属性都会随之改变。

ignoreCase返回创建RegExp对象实例时指定的ignoreCase标志(i)的状态。如果创建RegExp对象实例时设置了i标志,该属性返回True,否则返回False,默认值为False。

lastIndex是当前表达式模式首次匹配内容中最后一个字符的下一个位置,从0开始计数,常被作为继续搜索时的起始位置,初始值为-1, 表示从起始位置开始搜索,每次成功匹配时,lastIndex属性值都会随之改变。(只有使用exec()或test()方法才会填入,否则为0)

multiLine返回创建RegExp对象实例时指定的multiLine标志(m)的状态。如果创建RegExp对象实例时设置了m标志,该属性返回True,否则返回False,默认值为False。

source返回创建RegExp对象实例时指定的表达式文本字符串。

var str = "JS's Louvre";

var reg = /\w/g;

alert(reg.exec(str));//J

alert(reg.lastIndex);//1

alert(reg.exec(str));//S

alert(reg.lastIndex);//2

alert(reg.exec(str));//s

alert(reg.lastIndex);//4

alert(reg.exec(str));//L

alert(reg.lastIndex);//6

来源:https://www.cnblogs.com/rubylouvre/archive/2010/03/09/1681222.html

锋镝

几个常用的非贪婪匹配Pattern

几个常用的非贪婪匹配Pattern

*? 重复任意次,但尽可能少重复 

+? 重复1次或更多次,但尽可能少重复 

?? 重复0次或1次,但尽可能少重复 

{n,m}? 重复n到m次,但尽可能少重复 

{n,}? 重复n次以上,但尽可能少重复


几个常用的非贪婪匹配Pattern

*? 重复任意次,但尽可能少重复 

+? 重复1次或更多次,但尽可能少重复 

?? 重复0次或1次,但尽可能少重复 

{n,m}? 重复n到m次,但尽可能少重复 

{n,}? 重复n次以上,但尽可能少重复


山子

常用正则表达式(长期更新)

jsp页面:1.input输入框,可以是小数,保留两位。

this.value= this.value.match(/\d+(\.\d{0,2})?/) ? this.value.match(/\d+(\.\d{0,2})?/)[0] : '' 或者this.value=(this.value.match(/\d+(\.\d{0,2})?/)||[''])[0]

例子:<input type="text" name="name"  onkeyup="this.value=(this.value...

jsp页面:1.input输入框,可以是小数,保留两位。

this.value= this.value.match(/\d+(\.\d{0,2})?/) ? this.value.match(/\d+(\.\d{0,2})?/)[0] : '' 或者this.value=(this.value.match(/\d+(\.\d{0,2})?/)||[''])[0]

例子:<input type="text" name="name"  onkeyup="this.value=(this.value.match(/\d+(\.\d{0,2})?/)||[''])[0]"/>

锋镝

正则表达式

正则表达式是用来进行字符串匹配的。

定义正则表达式有两种方法:/wor/或者new RegExp("wor")。

使用方法

在JS中,使用正则表达式的方法有:

字符串的search方法:"hello".search(/e/)返回1。(以0开始的索引,如果未匹配到,返回-1)

字符串的match方法:"hello".match(/e/)返回["e"]。(表示匹配到的字符串,若未匹配,返回空数组)

字符串的replace方法:"hello".replace(/blue/g,"red...

正则表达式是用来进行字符串匹配的。

定义正则表达式有两种方法:/wor/或者new RegExp("wor")。

使用方法

在JS中,使用正则表达式的方法有:

字符串的search方法:"hello".search(/e/)返回1。(以0开始的索引,如果未匹配到,返回-1)

字符串的match方法:"hello".match(/e/)返回["e"]。(表示匹配到的字符串,若未匹配,返回空数组)

字符串的replace方法:"hello".replace(/blue/g,"red");

正则表达式对象的test方法:(/e/).test("hello")返回true。(表示匹配了)

正则表达式对象的exec方法:(/e/).exec("hello")返回["e"]。(表示匹配到的字符串,若未匹配,返回空数组)

字符

字符本身表示该字符,比如/w/匹配字符w,如"world".search(/w/)返回0。

\b表示单词的起始和结束位置。比如/\bme\b/可以匹配"me too!",但不能匹配"media player"。

\d表示任意数字(digital)。

\w表示任意字母,数字或下划线(word)。

\s表示任意单个空格或制表符(space)。两个空格必须由两个\s匹配,比如"hi  you".match(/\b\s\s\b/)返回["  "](注意有两个空格),而"hi  you".match(/\b\s\b/)返回null。

.(点符号)匹配除了换行符的任意字符。

^表示整个字符串的开头。

$表示整个字符串的结尾。

\B,\D,\W,\S,表示\b,\d,\w,\s的逆:非单词起始或结束位置,非数字,等等。

\\,\.,\^,$等表示转义,如\^表示实际的字符"^"而不是字符串开头。

[]中添加字符表示匹配其中的任一个字符,比如[abc]或[a-c]可以匹配字母a,b或者c,例如"banana".match(/[a-c]/g)返回["b","a","a","a"]。

[]中的^表示反义,比如/[^abc]/表示任意不是a,b或者c的字符,例如"abgbac".match(/[^abc]/)返回["g"],"fref<afr><frf>.match(/<a[^>]+>/)返回["<afr>"],其含义为“尖括号内以a开头的字符串(包括尖括号)”。

重复

某一个匹配重复了若干次,有以下三种表达:

{n},表示元素重复了n此。如"hi3456good".match(/\d{3}/)会返回["345"],匹配了索引从2开始的3个数字。

{n,m},表示元素重复了n到m次。如"hi3456good".match(/\d{2,10}/)返回["3456"],因为任意数字出现了2到10次(这里是4次)。

{n,},表示元素至少重复了n次。如"hi3456good".match(/\d{2,}/)返回["3456"]。

*,表示重复任意次(包括零次),等同于{0,},如"higood".match(/hi\d*good/)返回["higood"]。

+,表示重复一次或更多,等同于{1,},如"higood".match(/hi\d+good/)返回null。

?,表示重复零次或一次,等同于{0,1}。

分支

用|创建分支条件:

比如"hello Joey".match(/hi|hello/)返回["hello"],"hi Joey".match(/hi|hello/)返回"hi"。

比如,匹配一个0~255之间的数(在匹配IP地址时常用到):/2[0-4]\d|25[0-5]|[01]?\d\d?/。

分组

用()分组,提高运算优先级:

比如,/^(\d{3}[a-z])*$/.test("123x456y789z")返回true。

使用分组时,会给组别分配组名,并使用\<组名>的形式匹配相同的文本:

比如,/(\b\w+\b)/可以匹配任意一个单词,那么/(\b\w+\b)\s+\1/就可以匹配中间带有空格的两个一样的单词,如"go go"。

断言

断言用来匹配“出现在……之前”或者“出现在……之后”的字符。其格式为(?=exp)或类似的格式。比如:

"going and watching".match(/\b\w+(?=ing\b)/g);其返回["go", "watch"]。

JS不支持负向零宽断言(即出现在……之后)的情况。

来源:http://www.cnblogs.com/yiyezhai/p/3312272.html

fanzhengbiao

正则获取文件名

//获取文件名,不带后缀

var file_name=file_path.replace(/(.*\/)*([^.]+).*/ig,"$2");


 //获取文件后缀 

1.var FileExt=file_path.replace(/.+\./,""); 

2.var fileExtension = file_path.substring(file_path.lastIndexOf('.') + 1); 

//截取文件后缀

var reg = /\.\w+$/; 

var...

//获取文件名,不带后缀

var file_name=file_path.replace(/(.*\/)*([^.]+).*/ig,"$2");


 //获取文件后缀 

1.var FileExt=file_path.replace(/.+\./,""); 

2.var fileExtension = file_path.substring(file_path.lastIndexOf('.') + 1); 

//截取文件后缀

var reg = /\.\w+$/; 

var file_name = file_path.replace(reg,'');

_My_Memory

任意URL匹配的正则

//注意,这里把上面的正则表达式中的单引号用反斜杠转义了,不然没法放在字符串里

$regex = '@(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:\'".,<>?«...

//注意,这里把上面的正则表达式中的单引号用反斜杠转义了,不然没法放在字符串里

$regex = '@(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:\'".,<>?«»“”‘’]))@';


var_dump( preg_match($regex, 'http://segmentfault.com/q/1010000000584340') );  //true


ref:http://segmentfault.com/q/1010000000584340

锋镝

正则表达式分组、断言、不捕获

(?=)会作为匹配校验,但不会出现在匹配结果字符串里面

(?:)会作为匹配校验,并出现在匹配结果字符里面,它跟(...)不同的地方在于,不作为子匹配返回。

var data = 'windows 98 is ok';

data.match(/windows (?=\d+)/);  // ["windows "]

data.match(/windows (?:\d+)/);  // ["windows 98"]

//?: 为不捕获括号里...

(?=)会作为匹配校验,但不会出现在匹配结果字符串里面

(?:)会作为匹配校验,并出现在匹配结果字符里面,它跟(...)不同的地方在于,不作为子匹配返回。

var data = 'windows 98 is ok';

data.match(/windows (?=\d+)/);  // ["windows "]

data.match(/windows (?:\d+)/);  // ["windows 98"]

//?: 为不捕获括号里的内容

data.match(/windows (\d+)/);    // ["windows 98", "98"]


正则表达式中的断言,作为高级应用出现,倒不是因为它有多难,而是概念比较抽象,不容易理解而已,今天就让小菜通俗的讲解一下。

       如果不用断言,以往用过的那些表达式,仅仅能获取到有规律的字符串,而不能获取无规律的字符串。

       举个例子,比如html源码中有<title>xxx</title>标签,用以前的知识,我们只能确定源码中的<title>和</title>是固定不变的。因此,如果想获取页面标题(xxx),充其量只能写一个类似于这样的表达式:<title>.*</title>,而这样写匹配出来的是完整的<title>xxx</title>标签,并不是单纯的页面标题xxx。

       想解决以上问题,就要用到断言知识。

       在讲断言之前,读者应该先了解分组,这有助于理解断言。

       分组在正则中用()表示,根据小菜理解,分组的作用有两个:

       n  将某些规律看成是一组,然后进行组级别的重复,可以得到意想不到的效果。

       n  分组之后,可以通过后向引用简化表达式。

       先来看第一个作用,对于IP地址的匹配,简单的可以写为如下形式:

 \d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}


       但仔细观察,我们可以发现一定的规律,可以把.\d{1,3}看成一个整体,也就是把他们看成一组,再把这个组重复3次即可。表达式如下:


  \d{1,3}(.\d{1,3}){3}

       这样一看,就比较简洁了。     


再来看第二个作用,就拿匹配<title>xxx</title>标签来说,简单的正则可以这样写:

       <title>.*</title>


       可以看出,上边表达式中有两个title,完全一样,其实可以通过分组简写。表达式如下:

       <(title)>.*</\1>

       这个例子实际上就是反向引用的实际应用。对于分组而言,整个表达式永远算作第0组,在本例中,第0组是<(title)>.*</\1>,然后从左到右,依次为分组编号,因此,(title)是第1组。

      用\1这种语法,可以引用某组的文本内容,\1当然就是引用第1组的文本内容了,这样一来,就可以简化正则表达式,只写一次title,把它放在组里,然后在后边引用即可。

       以此为启发,我们可不可以简化刚刚的IP地址正则表达式呢?原来的表达式为\d{1,3}(.\d{1,3}){3},里边的\d{1,3}重复了两次,如果利用后向引用简化,表达式如下:

       (\d{1,3})(.\1){3}

       简单的解释下,把\d{1,3}放在一组里,表示为(\d{1,3}),它是第1组,(.\1)是第2组,在第2组里通过\1语法,后向引用了第1组的文本内容。

       经过实际测试,会发现这样写是错误的,为什么呢?

       小菜一直在强调,后向引用,引用的仅仅是文本内容,而不是正则表达式!

       也就是说,组中的内容一旦匹配成功,后向引用,引用的就是匹配成功后的内容,引用的是结果,而不是表达式。

       因此,(\d{1,3})(.\1){3}这个表达式实际上匹配的是四个数都相同的IP地址,比如:123.123.123.123。    

       至此,读者已经掌握了传说中的后向引用,就这么简单。

       接下来说说什么是断言。 

       所谓断言,就是指明某个字符串前边或者后边,将会出现满足某种规律的字符串。

       就拿文章开篇的例子来说,我们想要的是xxx,它没有规律,但是它前边肯定会有<title>,后边肯定会有</title>,这就足够了。

       想指定xxx前肯定会出现<title>,就用正后发断言,表达式:(?<=<title>).*

       向指定xxx后边肯定会出现</title>,就用正先行断言,表达式:.*(?=</title>)

       两个加在一起,就是(?<=<title>).*(?=</title>)

       这样就能匹配到xxx。    

       相信读者看到这,已经蒙了,不用急,待小菜慢慢讲来。

       其实掌握了规律,就很简单了,无论是先行还是后发,都是相对于xxx而言的,也就是相对于目标字符串而言。

       假如目标字符串后边有条件,可以理解为目标字符串在前,就用先行断言,放在目标字符串之后。

       假如目标字符串前边有条件,可以理解为目标字符串在后,就用后发断言,放在目标字符串之前。

       假如指定满足某个条件,就是正。

       假如指定不满足某个条件,就是负。

       断言只是条件,帮你找到真正需要的字符串,本身并不会匹配!

【总结】----------------------------------------------------------

Windows (?!95|98|NT|2000)

能匹配 “Windows 3.1〃 中的 “Windows”,但不能匹配 “Windows 2000〃 中的 “Windows”。 

(?=中国)人               

只想匹配中国人的人字

industr(?:y|ies)        

相当于 industry|industries


来源:http://www.cnblogs.com/iyangyuan/archive/2013/05/30/3107390.html

dph5199278

拆拼不规则版本号,以0填充(js、java)

js版:

var version = "2.17z517.25";

var versions = version.split('.');


var size = 0;
var value;
for(var key in versions) {
  value = versions[key];
if(size < value.length) size =  value.length;
}


version.replace(/[\w]+/g, function(word) {

  if(size >...

js版:

var version = "2.17z517.25";

var versions = version.split('.');


var size = 0;
var value;
for(var key in versions) {
  value = versions[key];
if(size < value.length) size =  value.length;
}


version.replace(/[\w]+/g, function(word) {

  if(size > word.length) {

  return Array(size - word.length + 1).join('0') + word;

  }

  return word;

});


java版:

String version = "2.17z517.25";

String[] versions = version.split("\\.");


int size = 0;

for(String s : versions) {

if(size < s.length()) size = s.length();

}


StringBuffer sbs = new StringBuffer();

StringBuffer numFormat = new StringBuffer("%").append(sizes).append("s");

for(String str : versions) {

sbs.append(".").append(String.format(numFormat, str).replaceAll(" ", "0"));

}

if(0 < sbs.length()) sbs.delete(0, 1);


如有更好逻辑思路,请不吝赐教


锋镝

只有20行Javascript代码!手把手教你写一个页面模板引擎

最初我的想法是这样子的:


var TemplateEngine = function(tpl, data) {

    // magic here ...

}

var template = '<p>Hello, my name is <%name%>. I\'m <%age%> years old.</p>';

console.log(TemplateEngine(template, {

    name: ...

最初我的想法是这样子的:


var TemplateEngine = function(tpl, data) {

    // magic here ...

}

var template = '<p>Hello, my name is <%name%>. I\'m <%age%> years old.</p>';

console.log(TemplateEngine(template, {

    name: "Krasimir",

    age: 29

}));


一个简单的函数,输入是我们的模板以及数据对象,输出么估计你也很容易想到,像下面这样子:


<p>Hello, my name is Krasimir. I'm 29 years old.</p>


其中第一步要做的是寻找里面的模板参数,然后替换成传给引擎的具体数据。我决定使用正则表达式来完成这一步。不过我不是最擅长这个,所以写的不好的话欢迎随时来喷。


var re = /<%([^%>]+)?%>/g;


这句正则表达式会捕获所有以<%开头,以%>结尾的片段。末尾的参数g(global)表示不只匹配一个,而是匹配所有符合的片段。Javascript里面有很多种使用正则表达式的方法,我们需要的是根据正则表达式输出一个数组,包含所有的字符串,这正是exec所做的。


var re = /<%([^%>]+)?%>/g;

var match = re.exec(tpl);


如果我们用console.log把变量match打印出来,我们会看见:


[

    "<%name%>",

    " name ",

    index: 21,

    input:

    "<p>Hello, my name is <%name%>. I\'m <%age%> years old.</p>"

]

不过我们可以看见,返回的数组仅仅包含第一个匹配项。我们需要用while循环把上述逻辑包起来,这样才能得到所有的匹配项。


var re = /<%([^%>]+)?%>/g;

while(match = re.exec(tpl)) {

    console.log(match);

}


如果把上面的代码跑一遍,你就会看见<%name%> 和 <%age%>都被打印出来了。


下面,有意思的部分来了。识别出模板中的匹配项后,我们要把他们替换成传递给函数的实际数据。最简单的办法就是使用replace函数。我们可以像这样来写:


var TemplateEngine = function(tpl, data) {

    var re = /<%([^%>]+)?%>/g;

    while(match = re.exec(tpl)) {

        tpl = tpl.replace(match[0], data[match[1]])

    }

    return tpl;

}


好了,这样就能跑了,但是还不够好。这里我们以data["property"]的方式使用了一个简单对象来传递数据,但是实际情况下我们很可能需要更复杂的嵌套对象。所以我们稍微修改了一下data对象:


{

    name: "Krasimir Tsonev",

    profile: { age: 29 }

}


不过直接这样子写的话还不能跑,因为在模板中使用<%profile.age%>的话,代码会被替换成data[‘profile.age’],结果是undefined。这样我们就不能简单地用replace函数,而是要用别的方法。如果能够在<%和%>之间直接使用Javascript代码就最好了,这样就能对传入的数据直接求值,像下面这样:


var template = '<p>Hello, my name is <%this.name%>. I\'m <%this.profile.age%> years old.</p>';


你可能会好奇,这是怎么实现的?这里John使用了new Function的语法,根据字符串创建一个函数。我们不妨来看个例子:

var fn = new Function("arg", "console.log(arg + 1);");

fn(2); // outputs 3

fn可是一个货真价实的函数。它接受一个参数,函数体是console.log(arg + 1);。上述代码等价于下面的代码:


var fn = function(arg) {

    console.log(arg + 1);

}

fn(2); // outputs 3


通过这种方法,我们可以根据字符串构造函数,包括它的参数和函数体。这不正是我们想要的嘛!不过先别急,在构造函数之前,我们先来看看函数体是什么样子的。按照之前的想法,这个模板引擎最终返回的应该是一个编译好的模板。还是用之前的模板字符串作为例子,那么返回的内容应该类似于:


return

"<p>Hello, my name is " +

this.name +

". I\'m " +

this.profile.age +

" years old.</p>";


当然啦,实际的模板引擎中,我们会把模板切分为小段的文本和有意义的Javascript代码。前面你可能看见我使用简单的字符串拼接来达到想要的效果,不过这并不是100%符合我们要求的做法。由于使用者很可能会传递更加复杂的Javascript代码,所以我们这儿需要再来一个循环,如下:


var template =

'My skills:' +

'<%for(var index in this.skills) {%>' +

'<a href=""><%this.skills[index]%></a>' +

'<%}%>';


如果使用字符串拼接的话,代码就应该是下面的样子:


return

'My skills:' +

for(var index in this.skills) { +

'<a href="">' +

this.skills[index] +

'</a>' +

}


当然,这个代码不能直接跑,跑了会出错。于是我用了John的文章里写的逻辑,把所有的字符串放在一个数组里,在程序的最后把它们拼接起来。


var r = [];

r.push('My skills:');

for(var index in this.skills) {

r.push('<a href="">');

r.push(this.skills[index]);

r.push('</a>');

}

return r.join('');


下一步就是收集模板里面不同的代码行,用于生成函数。通过前面介绍的方法,我们可以知道模板中有哪些占位符(译者注:或者说正则表达式的匹配项)以及它们的位置。所以,依靠一个辅助变量(cursor,游标),我们就能得到想要的结果。


var TemplateEngine = function(tpl, data) {

    var re = /<%([^%>]+)?%>/g,

        code = 'var r=[];\n',

        cursor = 0;

    var add = function(line) {

        code += 'r.push("' + line.replace(/"/g, '\\"') + '");\n';

    }

    while(match = re.exec(tpl)) {

        add(tpl.slice(cursor, match.index));

        add(match[1]);

        cursor = match.index + match[0].length;

    }

    add(tpl.substr(cursor, tpl.length - cursor));

    code += 'return r.join("");'; // <-- return the result

    console.log(code);

    return tpl;

}

var template = '<p>Hello, my name is <%this.name%>. I\'m <%this.profile.age%> years old.</p>';

console.log(TemplateEngine(template, {

    name: "Krasimir Tsonev",

    profile: { age: 29 }

}));


上述代码中的变量code保存了函数体。开头的部分定义了一个数组。游标cursor告诉我们当前解析到了模板中的哪个位置。我们需要依靠它来遍历整个模板字符串。此外还有个函数add,它负责把解析出来的代码行添加到变量code中去。有一个地方需要特别注意,那就是需要把code包含的双引号字符进行转义(escape)。否则生成的函数代码会出错。如果我们运行上面的代码,我们会在控制台里面看见如下的内容:


var r=[];

r.push("<p>Hello, my name is ");

r.push("this.name");

r.push(". I'm ");

r.push("this.profile.age");

return r.join("");


等等,貌似不太对啊,this.name和this.profile.age不应该有引号啊,再来改改。


var add = function(line, js) {

    js? code += 'r.push(' + line + ');\n' :

        code += 'r.push("' + line.replace(/"/g, '\\"') + '");\n';

}

while(match = re.exec(tpl)) {

    add(tpl.slice(cursor, match.index));

    add(match[1], true); // <-- say that this is actually valid js

    cursor = match.index + match[0].length;

}


占位符的内容和一个布尔值一起作为参数传给add函数,用作区分。这样就能生成我们想要的函数体了。


var r=[];

r.push("<p>Hello, my name is ");

r.push(this.name);

r.push(". I'm ");

r.push(this.profile.age);

return r.join("");


剩下来要做的就是创建函数并且执行它。因此,在模板引擎的最后,把原本返回模板字符串的语句替换成如下的内容:


return new Function(code.replace(/[\r\t\n]/g, '')).apply(data);


我们甚至不需要显式地传参数给这个函数。我们使用apply方法来调用它。它会自动设定函数执行的上下文。这就是为什么我们能在函数里面使用this.name。这里this指向data对象。


模板引擎接近完成了,不过还有一点,我们需要支持更多复杂的语句,比如条件判断和循环。我们接着上面的例子继续写。


var template =

'My skills:' +

'<%for(var index in this.skills) {%>' +

'<a href="#"><%this.skills[index]%></a>' +

'<%}%>';

console.log(TemplateEngine(template, {

    skills: ["js", "html", "css"]

}));


这里会产生一个异常,Uncaught SyntaxError: Unexpected token for。如果我们调试一下,把code变量打印出来,我们就能发现问题所在。


var r=[];

r.push("My skills:");

r.push(for(var index in this.skills) {);

r.push("<a href=\"\">");

r.push(this.skills[index]);

r.push("</a>");

r.push(});

r.push("");

return r.join("");


带有for循环的那一行不应该被直接放到数组里面,而是应该作为脚本的一部分直接运行。所以我们在把内容添加到code变量之前还要多做一个判断。


var re = /<%([^%>]+)?%>/g,

    reExp = /(^( )?(if|for|else|switch|case|break|{|}))(.*)?/g,

    code = 'var r=[];\n',

    cursor = 0;

var add = function(line, js) {

    js? code += line.match(reExp) ? line + '\n' : 'r.push(' + line + ');\n' :

        code += 'r.push("' + line.replace(/"/g, '\\"') + '");\n';

}


这里我们新增加了一个正则表达式。它会判断代码中是否包含if、for、else等等关键字。如果有的话就直接添加到脚本代码中去,否则就添加到数组中去。运行结果如下:


var r=[];

r.push("My skills:");

for(var index in this.skills) {

r.push("<a href=\"#\">");

r.push(this.skills[index]);

r.push("</a>");

}

r.push("");

return r.join("");


当然,编译出来的结果也是对的。


My skills:<a href="#">js</a><a href="#">html</a><a href="#">css</a>


最后一个改进可以使我们的模板引擎更为强大。我们可以直接在模板中使用复杂逻辑,例如:


var template =

'My skills:' +

'<%if(this.showSkills) {%>' +

    '<%for(var index in this.skills) {%>' +

    '<a href="#"><%this.skills[index]%></a>' +

    '<%}%>' +

'<%} else {%>' +

    '<p>none</p>' +

'<%}%>';

console.log(TemplateEngine(template, {

    skills: ["js", "html", "css"],

    showSkills: true

}));


除了上面说的改进,我还对代码本身做了些优化,最终版本如下:


var TemplateEngine = function(html, options) {

    var re = /<%([^%>]+)?%>/g, reExp = /(^( )?(if|for|else|switch|case|break|{|}))(.*)?/g, code = 'var r=[];\n', cursor = 0;

    var add = function(line, js) {

        js? (code += line.match(reExp) ? line + '\n' : 'r.push(' + line + ');\n') :

            (code += line != '' ? 'r.push("' + line.replace(/"/g, '\\"') + '");\n' : '');

        return add;

    }

    while(match = re.exec(html)) {

        add(html.slice(cursor, match.index))(match[1], true);

        cursor = match.index + match[0].length;

    }

    add(html.substr(cursor, html.length - cursor));

    code += 'return r.join("");';

    return new Function(code.replace(/[\r\t\n]/g, '')).apply(options);

}


代码比我预想的还要少,只有区区15行!

来源:http://blog.jobbole.com/56689/

二优

关于填写银行卡每4位加一个空格的解决方法

1、原生js写法

!function(){

    document.getElementById('bankCard').onkeyup=function(event){

        varv=this.value;

        if(/\S{5}/.test(v)){...


1、原生js写法

!function(){

    document.getElementById('bankCard').onkeyup=function(event){

        varv=this.value;

        if(/\S{5}/.test(v)){

            this.value=v.replace(/\s/g,'').replace(/(.{4})/g,"$1 ");

        }

    };

}();

2、jQuery写法

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title></title>

</head>

<body>

<input type="text"id="J_BankCard"/>

<script src="http://static.ydcss.com/libs/jquery/1.11.2/jquery.js"></script>

<script>

    !function(){

        $('#J_BankCard').on('keyup mouseout input',function(){

            var$this=$(this),

                v=$this.val();

            /\S{5}/.test(v)&&$this.val(v.replace(/\s/g,'').replace(/(.{4})/g,"$1 "));

        });

    }();

</script>

</body>

</html>


锋镝

常用js正则表达式大全

一、校验数字的js正则表达式


1 数字:^[0-9]*$

2 n位的数字:^\d{n}$

3 至少n位的数字:^\d{n,}$

4 m-n位的数字:^\d{m,n}$

5 零和非零开头的数字:^(0|[1-9][0-9]*)$

6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)+(.[0-9]{1,2})?$

7 带1-2位小数的正数或负数:^(\-)?\d+(\.\d{1,2})?$

8 正数、负数、和小数:^(\-|\+)?\d+(\.\d+)?$

9 有两位小数的正实数:^[0-9]+(.[0-9]{2})?$

10 有1...

一、校验数字的js正则表达式


1 数字:^[0-9]*$

2 n位的数字:^\d{n}$

3 至少n位的数字:^\d{n,}$

4 m-n位的数字:^\d{m,n}$

5 零和非零开头的数字:^(0|[1-9][0-9]*)$

6 非零开头的最多带两位小数的数字:^([1-9][0-9]*)+(.[0-9]{1,2})?$

7 带1-2位小数的正数或负数:^(\-)?\d+(\.\d{1,2})?$

8 正数、负数、和小数:^(\-|\+)?\d+(\.\d+)?$

9 有两位小数的正实数:^[0-9]+(.[0-9]{2})?$

10 有1~3位小数的正实数:^[0-9]+(.[0-9]{1,3})?$

11 非零的正整数:^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$

12 非零的负整数:^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$

13 非负整数:^\d+$ 或 ^[1-9]\d*|0$

14 非正整数:^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$

15 非负浮点数:^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$

16 非正浮点数:^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$

17 正浮点数:^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$

18 负浮点数:^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$

19 浮点数:^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$

 二、校验字符的js正则表达式


1 汉字:^[\u4e00-\u9fa5]{0,}$

2 英文和数字:^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$

3 长度为3-20的所有字符:^.{3,20}$

4 由26个英文字母组成的字符串:^[A-Za-z]+$

5 由26个大写英文字母组成的字符串:^[A-Z]+$

6 由26个小写英文字母组成的字符串:^[a-z]+$

7 由数字和26个英文字母组成的字符串:^[A-Za-z0-9]+$

8 由数字、26个英文字母或者下划线组成的字符串:^\w+$ 或 ^\w{3,20}$

9 中文、英文、数字包括下划线:^[\u4E00-\u9FA5A-Za-z0-9_]+$

10 中文、英文、数字但不包括下划线等符号:^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$

11 可以输入含有^%&',;=?$\"等字符:[^%&',;=?$\x22]+

12 禁止输入含有~的字符:[^~\x22]+

 三、特殊需求js正则表达式


1 Email邮箱地址:^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$  另外一个:  /^[A-Za-z0-9._%-]+@([A-Za-z0-9-]+\.)+[A-Za-z]{2,4}$/

2 url域名:[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?

3 InternetURL:[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$

4 手机号码:^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$  另外一个:/^1[3|4|5|7|8]\d{9}$/

5 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX):

       ^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$ 

6 国内电话号码(0511-4405222、021-87888822):\d{3}-\d{8}|\d{4}-\d{7}     //懒人建站http://www.51xuediannao.com/

7 身份证号:

15或18位身份证:^\d{15}|\d{18}$

15位身份证:^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$

18位身份证:^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$

8 短身份证号码(数字、字母x结尾):^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$

9 帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

10 密码(以字母开头,长度在6~18之间,只能包含字母、数字和下划线):^[a-zA-Z]\w{5,17}$

11 强密码(必须包含大小写字母和数字的组合,不能使用特殊字符,长度在8-10之间):^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$  

12 日期格式:^\d{4}-\d{1,2}-\d{1,2}

13 一年的12个月(01~09和1~12):^(0?[1-9]|1[0-2])$

14 一个月的31天(01~09和1~31):^((0?[1-9])|((1|2)[0-9])|30|31)$ 

15 钱的输入格式:

16    1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000":^[1-9][0-9]*$ 

17    2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式:^(0|[1-9][0-9]*)$ 

18    3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号:^(0|-?[1-9][0-9]*)$ 

19    4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分:^[0-9]+(.[0-9]+)?$ 

20    5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的:^[0-9]+(.[0-9]{2})?$ 

21    6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样:^[0-9]+(.[0-9]{1,2})?$ 

22    7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样:^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$ 

23    8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须:^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$ 

24    备注:这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里

25 xml文件:^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$

26 中文字符的正则表达式:[\u4e00-\u9fa5]

27 双字节字符:[^\x00-\xff]    (包括汉字在内,可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1))

28 空白行的正则表达式:\n\s*\r    (可以用来删除空白行)

29 HTML标记的正则表达式:<(\S*?)[^>]*>.*?</\1>|<.*? />    (网上流传的版本太糟糕,上面这个也仅仅能部分,对于复杂的嵌套标记依旧无能为力)

30 首尾空白字符的正则表达式:^\s*|\s*$或(^\s*)|(\s*$)    (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等),非常有用的表达式)

31 腾讯QQ号:[1-9][0-9]{4,}    (腾讯QQ号从10000开始)

32 中国邮政编码:[1-9]\d{5}(?!\d)    (中国邮政编码为6位数字)

33 IP地址:\d+\.\d+\.\d+\.\d+    (提取IP地址时有用)

34 不能为空:/\S/

来源:http://www.51xuediannao.com/javascript/zhengzedaquan.html

锋镝

js变量模板-replace用法

<script type="text/javascript">

var _tplshowHtml = '<div class="modal fade" id="{Id}">' +

'<div class="modal-header">' +

'<button type="button" class="close" data-dismiss="modal"><...

<script type="text/javascript">

var _tplshowHtml = '<div class="modal fade" id="{Id}">' +

'<div class="modal-header">' +

'<button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">×</span><span class="sr-only">Close</span></button>' +

'<h5 class="modal-title">{Title}</h5>' +

'</div>' +

'<div class="modal-body " >' +

'<div class="row" id = "bodyContext" ></div>'+

'</div>' +

'<div class="modal-footer" >' +

'<button type="button" class="btn btn-primary ok" data-dismiss="modal" onclick="avdSearchSubmit()">{BtnOk}</button>' +

'<button type="button" class="btn btn-default cancel" data-dismiss="modal">{BtnCancel}</button>' +

'</div>' +

'</div>';

var html = _tplshowHtml.replace(/\{(\w+)\}/igm, function(node, key,index) {

console.log(node+":"+key,index);

return {

Id : "modalId",

Title : "ops.title",

Url : "ops.url",

Height : "ops.height",

BtnOk : "ops.btnok",

BtnCancel : "ops.btncl",

width : "ops.width"

}[key];

});

alert(html);

</script>

<button id="button1">弹出普通replace结果</button>

<button id="button2">弹出含回调replace结果</button>

<script type="text/javascript">

document.getElementById("button1").onclick = function() {

    alert('10 13 21 48 52'.replace(/\d+/g, '*')); //用 * 替换所有的数字

};

document.getElementById("button2").onclick = function() {

    alert('10 13 21 48 52'.replace(/\d+/g, function(match,x) {

    alert(x);

        return parseInt(match) < 30 ? '*' : match;

    }));

};

</script>

<script type="text/javascript">

name = "Doe, John, John";

var name1=name.replace(/(\w+)\s*, \s*(\w+), \s*(\w+)/,"$3 $1 $2");

alert(name1);

</script>

有点无聊

js 正则 判断空

var reg = /^\s*$/g;
reg.test($("#userNmae").val())

var reg = /^\s*$/g;
reg.test($("#userNmae").val())
                  

有点无聊

js正则表达式/replace替换变量方法

zt:http://www.blogjava.net/pingpang/archive/2012/08/12/385342.html

最近项目任务繁重,更新博客会较慢,不过有时间希望可以把自己的积累分享出来。

   JavaScript正则实战(会根据最近写的不断更新)

1、javascript 正则对象替换创建 和用法: /pattern/flags  先简单案例学习认识下replace能干什么

    正则表达式构造函数: new RegExp("pattern"...

zt:http://www.blogjava.net/pingpang/archive/2012/08/12/385342.html

最近项目任务繁重,更新博客会较慢,不过有时间希望可以把自己的积累分享出来。

   JavaScript正则实战(会根据最近写的不断更新)

1、javascript 正则对象替换创建 和用法: /pattern/flags  先简单案例学习认识下replace能干什么

    正则表达式构造函数: new RegExp("pattern"[,"flags"]); 

    正则表达式替换变量函数:stringObj.replace(RegExp,replace Text);

参数说明: 
pattern -- 一个正则表达式文本 
flags -- 如果存在,将是以下值: 
g: 全局匹配 
i: 忽略大小写 
gi: 以上组合 

//下面的例子用来获取url的两个参数,并返回urlRewrite之前的真实Url
var
reg=new RegExp("(http://www.qidian.com/BookReader/)(\\d+),(\\d+).aspx","gmi");
var url="http://www.qidian.com/BookReader/1017141,20361055.aspx";

//方式一,最简单常用的方式
var rep=url.replace(reg,"$1ShowBook.aspx?bookId=$2&chapterId=$3");
alert(rep);

//方式二 ,采用固定参数的回调函数
var rep2=url.replace(reg,function(m,p1,p2,p3){return p1+"ShowBook.aspx?bookId="+p3+"&chapterId="+p3});
alert(rep2);

//方式三,采用非固定参数的回调函数
var rep3=url.replace(reg,function(){var args=arguments; return args[1]+"ShowBook.aspx?bookId="+args[2]+"&chapterId="+args[3];});
alert(rep3);

//方法四
//方式四和方法三很类似, 除了返回替换后的字符串外,还可以单独获取参数
var bookId;
var chapterId;
function capText()
{
    var args=arguments; 
    bookId=args[2];
    chapterId=args[3];
    return args[1]+"ShowBook.aspx?bookId="+args[2]+"&chapterId="+args[3];
}

var rep4=url.replace(reg,capText);
alert(rep4);
alert(bookId);
alert(chapterId);

//使用test方法获取分组
var reg3=new RegExp("(http://www.qidian.com/BookReader/)(\\d+),(\\d+).aspx","gmi");
reg3.test("http://www.qidian.com/BookReader/1017141,20361055.aspx");
//获取三个分组
alert(RegExp.$1); 
alert(RegExp.$2);
alert(RegExp.$3);

2、 学习最常用的 test exec match search  replace  split 6个方法

1) test  检查指定的字符串是否存在
var data = “123123″;
var reCat = /123/gi;
alert(reCat.test(data));  //true
//检查字符是否存在  g 继续往下走  i 不区分大小写

2) exec 返回查询值
var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
var reCat = /cat/i;
alert(reCat.exec(data));  //Cat

3)match  得到查询数组
var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
var reCat = /cat/gi;
var arrMactches = data.match(reCat)
for (var i=0;i < arrMactches.length ; i++)
{
alert(arrMactches[i]);   //Cat  cat
}

4) search  返回搜索位置  类似于indexof
var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
var reCat = /cat/gi;
alert(data.search(reCat));  //23

5) replace  替换字符  利用正则替换
var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
var reCat = /cat/gi;
alert(data.replace(reCat,”libinqq”));

6)split   利用正则分割数组
var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
var reCat = /\,/;
var arrdata = data.split(reCat);
for (var i = 0; i < arrdata.length; i++)
{
alert(arrdata[i]);
}

3、常用表达式收集:

"^\\d+$"  //非负整数(正整数 + 0)
"^[0-9]*[1-9][0-9]*$"  //正整数
"^((-\\d+)|(0+))$"  //非正整数(负整数 + 0)
"^-[0-9]*[1-9][0-9]*$"  //负整数
"^-?\\d+$"    //整数
"^\\d+(\\.\\d+)?$"  //非负浮点数(正浮点数 + 0)
"^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$"
//正浮点数
"^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$"  //非正浮点数(负浮点数 + 0)
"^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"
//负浮点数
"^(-?\\d+)(\\.\\d+)?$"  //浮点数
"^[A-Za-z]+$"  //由26个英文字母组成的字符串
"^[A-Z]+$"  //由26个英文字母的大写组成的字符串
"^[a-z]+$"  //由26个英文字母的小写组成的字符串
"^[A-Za-z0-9]+$"  //由数字和26个英文字母组成的字符串
"^\\w+$"  //由数字、26个英文字母或者下划线组成的字符串
"^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$"    //email地址
"^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$"  //url
"^[A-Za-z0-9_]*$"。

============================================正则表达式基础知识==============================================

^ 匹配一个输入或一行的开头,/^a/匹配"an A",而不匹配"An a" 
$ 匹配一个输入或一行的结尾,/a$/匹配"An a",而不匹配"an A" 
* 匹配前面元字符0次或多次,/ba*/将匹配b,ba,baa,baaa
+ 匹配前面元字符1次或多次,/ba+/将匹配ba,baa,baaa
? 匹配前面元字符0次或1次,/ba?/将匹配b,ba
(x) 匹配x保存x在名为$1...$9的变量中 
x|y 匹配x或y 
{n} 精确匹配n次 
{n,} 匹配n次以上 
{n,m} 匹配n-m次 
[xyz] 字符集(character set),匹配这个集合中的任一一个字符(或元字符) 
[^xyz] 不匹配这个集合中的任何一个字符 
[\b] 匹配一个退格符 
\b 匹配一个单词的边界 
\B 匹配一个单词的非边界 
\cX 这儿,X是一个控制符,/\cM/匹配Ctrl-M 
\d 匹配一个字数字符,/\d/ = /[0-9]/ 
\D 匹配一个非字数字符,/\D/ = /[^0-9]/ 
\n 匹配一个换行符 
\r 匹配一个回车符 
\s 匹配一个空白字符,包括\n,\r,\f,\t,\v等 
\S 匹配一个非空白字符,等于/[^\n\f\r\t\v]/ 
\t 匹配一个制表符 
\v 匹配一个重直制表符 
\w 匹配一个可以组成单词的字符(alphanumeric,这是我的意译,含数字),包括下划线,如[\w]匹配"$5.98"中的5,等于[a-zA-Z0-9] 
\W 匹配一个不可以组成单词的字符,如[\W]匹配"$5.98"中的$,等于[^a-zA-Z0-9]。 



更多信息请访问  java教程网 www.itchm.com


LOFTER

让兴趣,更有趣

简单随性的记录
丰富多彩的内容
让生活更加充实

下载移动端
关注最新消息