ruby regular

 

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

  }

 

 

 

 

 

#Ruby