1. 一般规则:
/a/ 匹配字符a。
/\?/ 匹配特殊字符?。特殊字符包括^, $, ? , ., /, \, [, ], {, }, (, ), +, *.
. 匹配任意字符，例如/a./匹配ab和ac
/[ab]c/ 匹配ac和bc,[]之间代表范围。例如：/[a-z]/ , /[a-zA-Z0-9]/
/[^a-zA-Z0-9]/ 匹配不在该范围内的字符串
/[\d]/ 代表任意数字
/[\w]/ 代表任意字母，数字或者_
/[\s]/ 代表空白字符，包括空格，TAB和换行
/[\D]/，/[\W]/，/[\S]/ 均为上述的否定情况
2. 高级规则:
? 代表0或1个字符。/Mrs?\.?/匹配"Mr"，"Mrs"，"Mr."，"Mrs."
“*” 代表0或多个字符。/Hello*/匹配"Hello",“HelloJack”
+ 代表1或多个字符。/a+c/匹配："abc"，"abbdrec"等等
/\d{3}/ 匹配3个数字
/\d{1,10}/ 匹配1-10个数字
/\d{3,}/ 匹配3个数字以上
/([A-Z]\d{4})/ 匹配首位是大写字母，后面4个是数字的字符
3. 下面我们就来具体看几个例子吧:
/Mrs?\.?/
上面匹配的是：M后面是字符r, 后面是0或1个字符s, 在后面是0或1个字符"." , 匹配Mr、Mrs、Mr.、Mrs.
/<\s*\/\s*p\s*>/
上面可以匹配:
</p>, </ p>,</p >,< /p>
4. 贪婪量词和不贪婪量词
量词*(零个或多个)和+(一个或多个)是贪婪的，它们会匹配尽可能多的字符,我们可以在*和+后面加一个?，使它成为非贪婪量词
irb(main):001:0> string = "abcdefGhigkGmnGop"
=> "abcdefGhigkGmnGop"
irb(main):002:0> match = /.+G/.match(string) #+会贪婪的匹配
=> #<MatchData "abcdefGhigkGmnG">
irb(main):003:0> match[0]
=> "abcdefGhigkGmnG"
irb(main):004:0> lmatch = /.+?G/.match(string) #+?不会贪婪的匹配,找到一个就停止
=> #<MatchData "abcdefG">
irb(main):004:0> lmatch = /.+?G/.match(string) #+?不会贪婪的匹配,找到一个就停止
=> #<MatchData "abcdefG">
irb(main):005:0> lmatch[0]
=> "abcdefG"
5. 锚
锚是指必须满足一定的条件，才能继续匹配
^ 行首
$ 行尾
\A 字符串的开始
\z 字符串的结尾
\Z 字符串的结尾(不包括最后的换行符)
\b 单词边界
irb(main):001:0> string = "&&&Join@@@@"
=> "&&&Join@@@@"
irb(main):002:0> match = /\b\w+\b/.match(string)
=> #<MatchData "Join">
irb(main):003:0> match[0]
=> "Join"
6. 前视断言
前视断言表示想要知道下一个指定的是什么，但并不匹配
1. 肯定的前视断言（？=）
irb(main):001:0> string = "123 456 789.032"
=> "123 456 789.032"
irb(main):002:0> match = /\d+(?=\.)/.match(string)
=> #<MatchData "789">
irb(main):003:0> match[0]
=> "789"
假设我们想要匹配一个数的序列，该序列以一个圆点结束，但并不想把圆点作为模式匹配的一部分
2. 否定的前视断言(?!)
irb(main):004:0> string = "123 456 789.032"
=> "123 456 789.032"
irb(main):005:0> match = /\d+(?!\.)/.match(string)
=> #<MatchData "123">
irb(main):006:0> match[0]
=> "123"
7. 修饰语
修饰语位于正则表达式最结束正则表达式的正斜杠的后面
1. i 使正则表达式对大小写不敏感,看个例子
irb(main):001:0> string = "AbCdefG"
=> "AbCdefG"
irb(main):002:0> match = /abc/i.match(string)
=> #<MatchData "AbC">
irb(main):003:0> match[0]
=> "AbC"
irb(main):004:0> match = /abc/.match(string)
=> nil
2. m 使得正则表达式可以和任何字符匹配，包括换行符，通常情况下圆点通配符不匹配换行符 我们来看个稍微复杂点的
irb(main):001:0> string = <<EOF #定义一个多行的字符串
irb(main):002:0" <div id="xx">
irb(main):003:0" <p></p>
irb(main):004:0" </div>
irb(main):005:0" EOF
=> "<div id=\"xx\">\n<p></p>\n</div>\n"
irb(main):006:0> match = /<div.+<\/div>/m.match(string) #加上m就可以匹配多行
=> #<MatchData "<div id=\"xx\">\n<p></p>\n</div>">
irb(main):007:0> match[0]
=> "<div id=\"xx\">\n<p></p>\n</div>"
irb(main):008:0> match = /<div.+<\/div>/.match(string) #不加上m就匹配不到
=> nil
8. 现有如下格式字符串:
str = “”www.google.com">I love ruby"
现要使str变为I love ruby怎么做？
就是获得去掉a标签后的内容.请看下面:
irb(main):001:0> str = '<a href="www.google.com">I love ruby</a>'
=> "<a href=\"www.google.com\">I love ruby</a>"
irb(main):002:0> str.sub(/<a.*?>(.*?)<\/a>/,'\1')
=> "I love ruby"
9. 还有gsub的用法:
irb(main):001:0> a = "i love ruby"
=> "i love ruby"
irb(main):002:0> a.gsub(/ruby/,'java')
=> "i love java"
irb(main):002:0> a.gsub(/ruby/,'java')
=> "i love java"
10. 本节的结束，我们来看一个变态的gsub夹杂这scan的用法:
str = "<li>a</li>" + "<li>1</li>" + "<li>2</li>" + "<li>3</li>" + "<li>b</li>" + "<li>c</li>" + "<li>d</li>"
result = str.gsub(/<li>.+?<\/li>/) do |match|
del = false
match.scan(/<li>(\d+)<\/li>/) do |num|
del = true
end
if del
""
else
match
end
end
p result #"<li>a</li><li>b</li><li>c</li><li>d</li>" 可以看到带数字的li被干掉了.不可思议！
** 常用和不常用的Ruby正则表达式
1. 1> 用户注册名
/^[a-z0-9_-]{3,16}$/
以字母开头, 包含字母,数字,_,-的3-16个字符
2> 用户密码
/^[a-z0-9_-]{6,18}$/
跟第一个一样，除了字符数
3> 十六进制数
/^#?([a-f0-9]{6}|[a-f0-9]{3})$/
以#开头或者不以#开头, 后面跟 6个字符(a-f或者0-9) 或者 3个字符(a-f或者0-9)
4> 匹配一个Slug(啥叫Slug?看看上面地址栏里的那一陀)
/^[a-z0-9-]+$/
很简单，多个字母(a-z),数字(0-9),和-组成的字符
5> 匹配Email地址,这个用途太广泛了
/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
6> 匹配Url
/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/
7> 匹配IP地址
num = /\d|[01]?\d\d|2[0-4]\d|25[0-5]/
exp = /^(#{num}\.){3}#{num}$/
num是每个数字串的匹配模式, exp就是最终的RegExp了,下面是演示:
irb(main):001:0> num = /\d|[01]?\d\d|2[0-4]\d|25[0-5]/
=> /\d|[01]?\d\d|2[0-4]\d|25[0-5]/
irb(main):002:0> exp = /^(#{num}\.){3}#{num}$/
=> /^((?-mix:\d|[01]?\d\d|2[0-4]\d|25[0-5])\.){3}(?-mix:\d|[01]?\d\d|2[0-4]\d|25[0-5])$/
irb(main):003:0> exp.match("192.168.1.22")
=> #<MatchData "192.168.1.22" 1:"1.">
8> 匹配时间/日期类型（yyyy.mm.dd hh:mm:ss)
yyyy = /[1-9]\d\d\d/
mm = /0?[1-9]|1[12]/
dd = /0?[1-9]|[12]\d|3[01]/
hh = /[01]?[1-9]|2[0-4]/
MM = /[0-5]\d/
ss = /[0-5]\d/
date_time = /^(#{yyyy}\.#{mm}\.#{dd}) (#{hh}:#{MM}:#{ss})$/
date_time =~ '2008.8.27 22:12:10' # 0
date_time =~ '2008.8.27 22:12:60' # nil
上面的已经解释的很清楚了,我还是觉得一个一个串拼起来比较清楚
9> 解决一个问题, 给了一个ip地址：192.168.1.1，想要转为Array: [192,168,1,1]
irb(main):001:0> "192.168.1.1".scan(/(\d+)\.?/)
=> [["192"], ["168"], ["1"], ["1"]]
irb(main):002:0> "192.168.1.1".scan(/(\d+)\.?/).flatten
=> ["192", "168", "1", "1"]
irb(main):003:0> "192.168.1.1".scan(/(\d+)\.?/).flatten.map{|n| n.to_i }
=> [192, 168, 1, 1]
irb(main):001:0> "192.168.1.1".split(".").map{|x| x.to_i}
=> [192, 168, 1, 1]
# thanks Hooopo for this
======================================================================================================================
正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
匹配空白行的正则表达式：\n\s*\r
评注：可以用来删除空白行
匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?|<.*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力
匹配首尾空白字符的正则表达式：^\s*|\s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
评注：表单验证时很实用
匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用
匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822
匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始
匹配中国邮政编码：[1-9]\d{5}(?!\d)
评注：中国邮政编码为6位数字
匹配身份证：\d{15}|\d{18}
评注：中国的身份证为15位或18位
匹配ip地址：\d+\.\d+\.\d+\.\d+
评注：提取ip地址时有用
匹配特定数字：
^[1-9]\d*$ //匹配正整数
^-[1-9]\d*$ //匹配负整数
^-?[1-9]\d*$ //匹配整数
^[1-9]\d*|0$ //匹配非负整数（正整数 + 0）
^-[1-9]\d*|0$ //匹配非正整数（负整数 + 0）
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ //匹配正浮点数
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ //匹配负浮点数
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$ //匹配浮点数
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$ //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$ //匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正
匹配特定字符串：
^[A-Za-z]+$ //匹配由26个英文字母组成的字符串
^[A-Z]+$ //匹配由26个英文字母的大写组成的字符串
^[a-z]+$ //匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$ //匹配由数字和26个英文字母组成的字符串
^\w+$ //匹配由数字、26个英文字母或者下划线组成的字符串
评注：最基本也是最常用的一些表达式
// 手机号验证
function isRightMobileNumber(s){
var patrn=/^0?1(4\d|3\d|5[012356789]|8[012356789])\d{8}$/;
if (!patrn.exec(s)) return false
return true
}