精华内容
下载资源
问答
  • 正则表达式生成器 给定字符串,生成匹配所有字符串正则表达式
  • mysql 字符串正则表达式

    千次阅读 2018-03-06 14:11:26
    字符串是否匹配正则表达式 RLIKE 字符串是否匹配正则表达式 正则表达式是指定复杂搜索的模式的有力方式。本文讨论可用于正则表达式匹配的操作符,并举例说明可以用于正则表达式操作的一些特殊字符和构造。 ...

    概述

    名称描述
    NOT REGEXP否定的REGEXP
    REGEXP字符串是否匹配正则表达式
    RLIKE字符串是否匹配正则表达式

    正则表达式是指定复杂搜索的模式的有力方式。本文讨论可用于正则表达式匹配的操作符,并举例说明可以用于正则表达式操作的一些特殊字符和构造。
    MySQL使用了Henry Spencer的正则表达式实现,这是为了符合POSIX 1003.2。MySQL使用扩展版本支持SQL语句中的正则表达式模式匹配操作。本文不包含 Henry Spencer’s regex(7)手册页中可以找到的所有细节。该手册页包含在MySQL源代码发行版中,在regex中,在regex目录下的文件。

    正则表达式运算符

    • expr NOT REGEXP pat, expr NOT RLIKE pat

    这与NOT(expr REGEXP pat)相同。

    • expr REGEXP pat, expr RLIKE pat

    如果字符串expr与模式pat指定的正则表达式匹配,则返回1。如果expr或pat为空,返回值为空。
    RLIKE是REGEXP的同义词。

    该模式可以是一个扩展的正则表达式,它的语法是在正则表达式语法中讨论的。模式不必是字符串。例如,可以将它指定为字符串表达式或表列。

    Note
    因为MySQL使用字符串中的C转义语法(例如,\n代表换行符),所以您必须将您在REGEXP参数中使用的任何\都增加一倍。

    正则表达式操作在决定字符类型和执行比较时使用字符串表达式和模式参数的字符集和排序。如果参数具有不同的字符集或排序规则,则强制规则适用于第10.8.4节中所描述的“在表达式中进行排序的强制性”。如果任何一个参数都是二进制字符串,那么这些参数将以区分大小写的方式作为二进制字符串处理。

    mysql> SELECT 'Michael!' REGEXP '.*';
    +------------------------+
    | 'Michael!' REGEXP '.*' |
    +------------------------+
    |                      1 |
    +------------------------+
    mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
    +---------------------------------------+
    | 'new*\n*line' REGEXP 'new\\*.\\*line' |
    +---------------------------------------+
    |                                     0 |
    +---------------------------------------+
    mysql> SELECT 'a' REGEXP '^[a-d]';
    +---------------------+
    | 'a' REGEXP '^[a-d]' |
    +---------------------+
    |                   1 |
    +---------------------+
    mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';
    +----------------+-----------------------+
    | 'a' REGEXP 'A' | 'a' REGEXP BINARY 'A' |
    +----------------+-----------------------+
    |              1 |                     0 |
    +----------------+-----------------------+

    警告
    REGEXP和RLIKE操作符以字节的方式工作,因此它们不是多字节安全的,并且可能会产生多字节字符集的意外结果。此外,这些运算符将字符的字节值和重音字符进行比较,即使给定的排序规则将它们视为相等,它们也可能不相等。

    正则表达式语法

    正则表达式描述一组字符串。最简单的正则表达式是没有特殊字符的表达式。例如,正则表达式hello匹配hello和其他内容。
    另一类正则表达式使用某些特殊结构,以便它们能够匹配多个字符串。例如,正则表达式“hello|world“包含 |,匹配hello或world。
    作为一个更复杂的例子,正则表达式B[an]*s匹配任何字符串Bananas、Baaaaas、Bs和任何以B开头的字符串,以s结尾,中间包含任意数量的a或n字符。
    REGEXP操作符的正则表达式可以使用下列任何特殊字符和构造:

    • ^

    匹配字符串的开头

    mysql> SELECT 'fo\nfo' REGEXP '^fo$';                   -> 0
    mysql> SELECT 'fofo' REGEXP '^fo';                      -> 1
    • $

    匹配字符串结尾

    mysql> SELECT 'fo\no' REGEXP '^fo\no$';                 -> 1
    mysql> SELECT 'fo\no' REGEXP '^fo$';                    -> 0
    • .

    匹配任意字符(包括会车,换行)

    mysql> SELECT 'fofo' REGEXP '^f.*$';                    -> 1
    mysql> SELECT 'fo\r\nfo' REGEXP '^f.*$';                -> 1
    • a*

    匹配任意一个或者多个字符

    mysql> SELECT 'Ban' REGEXP '^Ba*n';                     -> 1
    mysql> SELECT 'Baaan' REGEXP '^Ba*n';                   -> 1
    mysql> SELECT 'Bn' REGEXP '^Ba*n';                      -> 1
    • a+

    匹配任意一个或者多个字符

    mysql> SELECT 'Ban' REGEXP '^Ba+n';                     -> 1
    mysql> SELECT 'Bn' REGEXP '^Ba+n';                      -> 0
    • a?

    匹配0或1个字符。

    mysql> SELECT 'Bn' REGEXP '^Ba?n';                      -> 1
    mysql> SELECT 'Ban' REGEXP '^Ba?n';                     -> 1
    mysql> SELECT 'Baan' REGEXP '^Ba?n';                    -> 0
    • de|abc

    交替; 匹配序列de或abc。

    mysql> SELECT 'pi' REGEXP 'pi|apa';                     -> 1
    mysql> SELECT 'axe' REGEXP 'pi|apa';                    -> 0
    mysql> SELECT 'apa' REGEXP 'pi|apa';                    -> 1
    mysql> SELECT 'apa' REGEXP '^(pi|apa)$';                -> 1
    mysql> SELECT 'pi' REGEXP '^(pi|apa)$';                 -> 1
    mysql> SELECT 'pix' REGEXP '^(pi|apa)$';                -> 0
    • (abc)*

    匹配0或多个序列abc的实例。

    mysql> SELECT 'pi' REGEXP '^(pi)*$';                    -> 1
    mysql> SELECT 'pip' REGEXP '^(pi)*$';                   -> 0
    mysql> SELECT 'pipi' REGEXP '^(pi)*$';                  -> 1
    • {1}, {2,3}

    重复;{n}和{m,n}表示法提供了一种更通用的方法来编写正则表达式,该方法可以匹配模式的前一个原子(或“块”)的多次出现。m和n是整数。

    * a* 
    可以写成{0}。
    
    * a+ 
    可以写成{1}。
    
    * a? 
    可以写成{0,1}。
    

    更确切地说,一个{n}恰好与n个实例匹配,一个{n,}匹配n个或多个实例,一个{m,n}匹配m到n个实例的a,包含。如果给定m和n, m必须小于等于n。

    m和n必须在从0到RE_DUP_MAX(默认255)的范围内。

    mysql> SELECT 'abcde' REGEXP 'a[bcd]{2}e';              -> 0
    mysql> SELECT 'abcde' REGEXP 'a[bcd]{3}e';              -> 1
    mysql> SELECT 'abcde' REGEXP 'a[bcd]{1,10}e';           -> 1
    • [a-dX], [^a-dX]

    匹配任何字符(或者不是,如果使用^)要么是a,b,c,d或x字的另外两个人物之间形成一个范围从第一个字符匹配所有字符。例如,[0-9]匹配任何十进制数字。要包含一个文字字符,它必须立即跟随开头的括号[。要包含一个文字字符,必须先写或最后写。任何没有在[]对中定义特殊含义的字符只匹配它自己。

    mysql> SELECT 'aXbc' REGEXP '[a-dXYZ]';                 -> 1
    mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]$';               -> 0
    mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]+$';              -> 1
    mysql> SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$';             -> 0
    mysql> SELECT 'gheis' REGEXP '^[^a-dXYZ]+$';            -> 1
    mysql> SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$';           -> 0
    • [.characters.]

    在一个括号表达式中(使用[和]),匹配该排序元素的字符序列。字符要么是单个字符,要么是像newline这样的字符名称。下表列出了允许的字符名称。下表显示了允许的字符名称和它们匹配的字符。对于以数字值表示的字符,值在八进制中表示。

    NameCharacterNameCharacter
    NUL0SOH001
    STX002ETX003
    EOT004ENQ005
    ACK006BEL007
    alert007BS010
    backspace‘\b’HT011
    tab‘\t’LF012
    newline‘\n’VT013
    vertical-tab‘\v’FF014
    form-feed‘\f’CR015
    carriage-return‘\r’SO016
    SI017DLE020
    DC1021DC2022
    DC3023DC4024
    NAK025SYN026
    ETB027CAN030
    EM031SUB032
    ESC033IS4034
    FS034IS3035
    GS035IS2036
    RS036IS1037
    US037space’ ‘
    exclamation-mark‘!’quotation-mark‘”’
    number-sign‘#’dollar-sign‘$’
    percent-sign‘%’ampersand‘&’
    apostrophe‘\”left-parenthesis‘(‘
    right-parenthesis‘)’asterisk‘*’
    plus-sign‘+’comma‘,’
    hyphen‘-‘hyphen-minus‘-‘
    period‘.’full-stop‘.’
    slash‘/’solidus‘/’
    zero‘0’one‘1’
    two‘2’three‘3’
    four‘4’five‘5’
    six‘6’seven‘7’
    eight‘8’nine‘9’
    colon‘:’semicolon‘;’
    less-than-sign‘<’equals-sign‘=’
    greater-than-sign‘>’question-mark‘?’
    commercial-at‘@’left-square-bracket‘[‘
    backslash‘\’reverse-solidus‘\’
    right-square-bracket‘]’circumflex‘^’
    circumflex-accent‘^’underscore‘_’
    low-line‘_’grave-accent‘`’
    left-brace‘{‘left-curly-bracket‘{‘
    vertical-line’ right-brace ‘}’
    right-curly-bracket‘}’tilde‘~’
    DEL177
    mysql> SELECT '~' REGEXP '[[.~.]]';                     -> 1
    mysql> SELECT '~' REGEXP '[[.tilde.]]';                 -> 1
    • [=character_class=]

    在一个括号表达式中(使用[和]),[=character_class=]表示一个等价类。它匹配所有具有相同排序值的字符,包括它自己。例如,如果o和(+)是等价类的成员,[[=o=]], [[=(+)=]], [o(+)]都是同义词。等价类不能用作范围的端点。

    • [:character_class:]

    在一个括号表达式中(使用[和]),[:character_class:]表示一个字符类,它匹配属于该类的所有字符。下表列出了标准类名。这些名称代表在ctype(3)手册页中定义的字符类。一个特定的地区可能提供其他类名。字符类不能用作范围的端点。

    Character Class NameMeaning
    alnumAlphanumeric characters
    alphaAlphabetic characters
    blankWhitespace characters
    cntrlControl characters
    digitDigit characters
    graphGraphic characters
    lowerLowercase alphabetic characters
    printGraphic or space characters
    punctPunctuation characters
    spaceSpace, tab, newline, and carriage return
    upperUppercase alphabetic characters
    xdigitHexadecimal digit characters
    Character Class NameMeaning
    mysql> SELECT 'justalnums' REGEXP '[[:alnum:]]+';       -> 1
    mysql> SELECT '!!' REGEXP '[[:alnum:]]+';               -> 0
    • [[:<:]], [[:>:]]

    这些标记代表单词的边界。它们分别匹配单词的开头和结尾。一个单词是一个单词字符序列,它不是在前面或后面跟着单词字符。字字符是alnum类或下划线(_)中的字母数字字符。

    mysql> SELECT 'a word a' REGEXP '[[:<:]]word[[:>:]]';   -> 1
    mysql> SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]';  -> 0

    在正则表达式中使用一个特殊字符的文字实例,在它前面加上两个反斜杠()字符。MySQL解析器解释一个反斜杠,正则表达式库解释另一个。例如,要匹配包含特殊+字符的字符串1+2,只有以下正则表达式的最后一个是正确的:

    mysql> SELECT '1+2' REGEXP '1+2';                       -> 0
    mysql> SELECT '1+2' REGEXP '1\+2';                      -> 0
    mysql> SELECT '1+2' REGEXP '1\\+2';                     -> 1

    参考文档:

    https://dev.mysql.com/doc/refman/5.7/en/regexp.html

    展开全文
  • Java 字符串 正则表达式

    千次阅读 2018-10-31 11:29:59
    字符串 String类:最常用的字符串。初始化后不可改变,String变量的重新赋值其实是重新分配内存。...正则表达式 部分转载自: http://www.runoob.com/java/java-regular-expressions.html?yyue=a21bo.5...

    字符串

    String类:最常用的字符串。初始化后不可改变,String变量的重新赋值其实是重新分配内存。

    StringBuffer类:多线程环境中,可变字符串类。

    StringBuilder类:单线程环境中,可变字符串类。

    正则表达式

    部分转载自:

    http://www.runoob.com/java/java-regular-expressions.html?yyue=a21bo.50862.201879

    https://www.cnblogs.com/lzq198754/p/5780340.html

    https://docs.oracle.com/javase/8/docs/api/index.html?overview-tree.html

    https://www.cnblogs.com/ggjucheng/p/3423731.html

    java.util.regex 包

    java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳). 

    • Pattern 类:

      pattern 对象是一个正则表达式的编译表示。

    •  

      Matcher类:

      Matcher 对象是对输入字符串进行解释和匹配操作的引擎。

       

    • PatternSyntaxException:

      PatternSyntaxException 是一个非强制异常类,它表示一个正则表达式模式中的语法错误。

    捕获组的概念

    捕获组可以通过从左到右计算其开括号来编号,编号是从1 开始的。例如,在表达式 ((A)(B(C)))中,存在四个这样的组:

    1        ((A)(B(C)))
    2        (A)
    3        (B(C))
    4        (C)

    组零始终代表整个表达式。 以 (?) 开头的组是纯的非捕获 组,它不捕获文本,也不针对组合计进行计数。

    与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组,则在第二次计算失败时将保留其以前捕获的值(如果有的话)例如,将字符串"aba" 与表达式(a(b)?)+ 相匹配,会将第二组设置为 "b"。在每个匹配的开头,所有捕获的输入都会被丢弃。


    详解Pattern类和Matcher类


    Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式, 
    Java代码示例: 

    Pattern p=Pattern.compile("\\w+"); 
    p.pattern();//返回 \w+ 

    pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

    1.Pattern.split(CharSequence input)

    Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[],我猜String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的. 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); 

    结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com" 

    2.Pattern.matches(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.

    Java代码示例: 

    Pattern.matches("\\d+","2223");//返回true 
    Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到 
    Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到 

     

    3.Pattern.matcher(CharSequence input)

    说了这么多,终于轮到Matcher类登场了,Pattern.matcher(CharSequence input)返回一个Matcher对象.
    Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例. 
    Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

    4.Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()

    Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false 
    matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.matches();//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功. 
    Matcher m2=p.matcher("2223"); 
    m2.matches();//返回true,因为\d+匹配到了整个字符串

    我们现在回头看一下Pattern.matcher(String regex,CharSequence input),它与下面这段代码等价 
    Pattern.compile(regex).matcher(input).matches() 

    lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.lookingAt();//返回true,因为\d+匹配到了前面的22 
    Matcher m2=p.matcher("aa2223"); 
    m2.lookingAt();//返回false,因为\d+不能匹配前面的aa 

    find()对字符串进行匹配,匹配到的字符串可以在任何位置. 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.find();//返回true 
    Matcher m2=p.matcher("aa2223"); 
    m2.find();//返回true 
    Matcher m3=p.matcher("aa2223bb"); 
    m3.find();//返回true 
    Matcher m4=p.matcher("aabb"); 
    m4.find();//返回false 

    5.Mathcer.start()/ Matcher.end()/ Matcher.group()

    当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息. 
    start()返回匹配到的子字符串在字符串中的索引位置. 
    end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置. 
    group()返回匹配到的子字符串 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("aaa2223bb"); 
    m.find();//匹配2223 
    m.start();//返回3 
    m.end();//返回7,返回的是2223后的索引号 
    m.group();//返回2223 
    
    Mathcer m2=m.matcher("2223bb"); 
    m.lookingAt();   //匹配2223 
    m.start();   //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0 
    m.end();   //返回4 
    m.group();   //返回2223 
    
    Matcher m3=m.matcher("2223bb"); 
    m.matches();   //匹配整个字符串 
    m.start();   //返回0,原因相信大家也清楚了 
    m.end();   //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串 
    m.group();   //返回2223bb 

    说了这么多,相信大家都明白了以上几个方法的使用,该说说正则表达式的分组在java中是怎么使用的. 
    start(),end(),group()均有一个重载方法它们是start(int i),end(int i),group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组. 
    Java代码示例: 

     

    Pattern p=Pattern.compile("([a-z]+)(\\d+)"); 
    Matcher m=p.matcher("aaa2223bb"); 
    m.find();   //匹配aaa2223 
    m.groupCount();   //返回2,因为有2组 
    m.start(1);   //返回0 返回第一组匹配到的子字符串在字符串中的索引号 
    m.start(2);   //返回3 
    m.end(1);   //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置. 
    m.end(2);   //返回7 
    m.group(1);   //返回aaa,返回第一组匹配到的子字符串 
    m.group(2);   //返回2223,返回第二组匹配到的子字符串 

     

    现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单. 
    Java代码示例: 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com"); 
    while(m.find()) { 
         System.out.println(m.group()); 
    } 

    输出: 

    456456 
    0532214 
    123 

     

    如将以上while()循环替换成 

    while(m.find()) { 
         System.out.println(m.group()); 
         System.out.print("start:"+m.start()); 
         System.out.println(" end:"+m.end()); 
    } 

    则输出: 

    456456 
    start:6 end:12 
    0532214 
    start:19 end:26 
    123 
    start:36 end:39 

    现在大家应该知道,每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息. 
    注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用.

    正则表达式语法

    注:Java正则表达式中,为防止表达式元字符被Java编译器当作转义字符吃掉,需要多加一个"\",例如正则表达式"\d",在java中要写成"\\d".

    元字符

    描述

    \

    将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如,“\\n”匹配\n。“\n”匹配换行符。序列“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。

    ^

    匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性,^也匹配“\n”或“\r”之后的位置。

    $

    匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性,$也匹配“\n”或“\r”之前的位置。

    *

    匹配前面的子表达式任意次。例如,zo*能匹配“z”,“zo”以及“zoo”。*等价于{0,}。

    +

    匹配前面的子表达式一次或多次(大于等于1次)。例如,“zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。+等价于{1,}。

    ?

    匹配前面的子表达式零次或一次。例如,“do(es)?”可以匹配“do”或“does”中的“do”。?等价于{0,1}。

    {n}

    n是一个非负整数。匹配确定的n次。例如,“o{2}”不能匹配“Bob”中的“o”,但是能匹配“food”中的两个o。

    {n,}

    n是一个非负整数。至少匹配n次。例如,“o{2,}”不能匹配“Bob”中的“o”,但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。

    {n,m}

    m和n均为非负整数,其中n<=m。最少匹配n次且最多匹配m次。例如,“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。

    ?

    当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串“oooo”,“o+?”将匹配单个“o”,而“o+”将匹配所有“o”。

    .点

    匹配除“\r\n”之外的任何单个字符。要匹配包括“\r\n”在内的任何字符,请使用像“[\s\S]”的模式。

    (pattern)

    匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到,在VBScript中使用SubMatches集合,在JScript中则使用$0…$9属性。要匹配圆括号字符,请使用“\(”或“\)”。

    (?:pattern)

    匹配pattern但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分是很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。

    (?=pattern)

    正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”,但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。

    (?!pattern)

    正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”,但不能匹配“Windows2000”中的“Windows”。

    (?<=pattern)

    反向肯定预查,与正向肯定预查类似,只是方向相反。例如,“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”,但不能匹配“3.1Windows”中的“Windows”。

    (?<!pattern)

    反向否定预查,与正向否定预查类似,只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”,但不能匹配“2000Windows”中的“Windows”。

    x|y

    匹配x或y。例如,“z|food”能匹配“z”或“food”或"zood"(此处请谨慎)。“(z|f)ood”则匹配“zood”或“food”。

    [xyz]

    字符集合。匹配所包含的任意一个字符。例如,“[abc]”可以匹配“plain”中的“a”。

    [^xyz]

    负值字符集合。匹配未包含的任意字符。例如,“[^abc]”可以匹配“plain”中的“plin”。

    [a-z]

    字符范围。匹配指定范围内的任意字符。例如,“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。

    注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.

    [^a-z]

    负值字符范围。匹配任何不在指定范围内的任意字符。例如,“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。

    \b

    匹配一个单词边界,也就是指单词和空格间的位置(即正则表达式的“匹配”有两种概念,一种是匹配字符,一种是匹配位置,这里的\b就是匹配位置的)。例如,“er\b”可以匹配“never”中的“er”,但不能匹配“verb”中的“er”。

    \B

    匹配非单词边界。“er\B”能匹配“verb”中的“er”,但不能匹配“never”中的“er”。

    \cx

    匹配由x指明的控制字符。例如,\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则,将c视为一个原义的“c”字符。

    \d

    匹配一个数字字符。等价于[0-9]。

    \D

    匹配一个非数字字符。等价于[^0-9]。

    \f

    匹配一个换页符。等价于\x0c和\cL。

    \n

    匹配一个换行符。等价于\x0a和\cJ。

    \r

    匹配一个回车符。等价于\x0d和\cM。

    \s

    匹配任何不可见字符,包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

    \S

    匹配任何可见字符。等价于[^ \f\n\r\t\v]。

    \t

    匹配一个制表符。等价于\x09和\cI。

    \v

    匹配一个垂直制表符。等价于\x0b和\cK。

    \w

    匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”,这里的"单词"字符使用Unicode字符集。

    \W

    匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。

    \xn

    匹配n,其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如,“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。

    \num

    匹配num,其中num是一个正整数。对所获取的匹配的引用。例如,“(.)\1”匹配两个连续的相同字符。

    \n

    标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式,则n为向后引用。否则,如果n为八进制数字(0-7),则n为一个八进制转义值。

    \nm

    标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式,则nm为向后引用。如果\nm之前至少有n个获取,则n为一个后跟文字m的向后引用。如果前面的条件都不满足,若n和m均为八进制数字(0-7),则\nm将匹配八进制转义值nm。

    \nml

    如果n为八进制数字(0-7),且m和l均为八进制数字(0-7),则匹配八进制转义值nml。

    \un

    匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。例如,\u00A9匹配版权符号(&copy;)。

    \< \>匹配词(word)的开始(\<)和结束(\>)。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the",但是不能匹配字符串"otherwise"中的"the"。注意:这个元字符不是所有的软件都支持的。
    \( \)将 \( 和 \) 之间的表达式定义为“组”(group),并且将匹配这个表达式的字符保存到一个临时区域(一个正则表达式中最多可以保存9个),它们可以用 \1 到\9 的符号来引用。
    |将两个匹配条件进行逻辑“或”(Or)运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her",但是不能匹配"it belongs to them."。注意:这个元字符不是所有的软件都支持的。
    +匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。注意:这个元字符不是所有的软件都支持的。
    ?匹配0或1个正好在它之前的那个字符。注意:这个元字符不是所有的软件都支持的。
    {i} {i,j}匹配指定数目的字符,这些字符是在它之前的表达式定义的。例如正则表达式A[0-9]{3} 能够匹配字符"A"后面跟着正好3个数字字符的串,例如A123、A348等,但是不匹配A1234。而正则表达式[0-9]{4,6} 匹配连续的任意4个、5个或者6个数字

    常用正则表达式

    规则正则表达式语法  
    一个或多个汉字^[\u0391-\uFFE5]+$ 
    邮政编码^[1-9]\d{5}$
    QQ号码^[1-9]\d{4,10}$ 
    邮箱(默认前缀、后缀不以'_'、'-'、'.'结尾)^[A-Za-z\d]+([-_.][A-Za-z\d]+)*@([A-Za-z\d]+[-.])+[A-Za-z\d]{2,4}$
    用户名(字母开头 + 数字/字母/下划线)^[A-Za-z][A-Za-z1-9_-]+$
    手机号码^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$
    URL^((http|https)://)?([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$ 
    15/18位身份证号^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$)|(^[1-9]\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}$)

     

    在线测试正则表达式

    http://tool.oschina.net/regex/

     

    展开全文
  • js系列教程3-字符串、正则表达式全解js中字符串正则表达式正则法则的应用正则表达式 = /pattern/flags 其中flags中g表示匹配全部,i表示不区分大小写,m表示匹配多行。 pattern包含 ([{\^$|)?*+.]}元字符,若匹配...
       
    

    全栈工程师开发手册 (作者:栾鹏)

    js系列教程3-字符串、正则表达式全解

    js中字符串正则表达式

    正则法则的应用

    正则表达式 = /pattern/flags 其中flags中g表示匹配全部,i表示不区分大小写,m表示匹配多行。
    pattern包含 ([{^$|)?*+.]}元字符,若匹配的字符串中包含元字符,使用\转义。
    代码如下:

    var patter1 = /(.)u/gi;                 //正则表达式,标志没有,可为空,也可以使用var patter1 = new RegExp("pattern","flags"),使用new是创建对象
    if(patter1.test(name)){                 //test查找符合要求的子串是否存在,返回true
        RegExp.input;               //原始字符串
        RegExp.leftContext;         //捕捉到的位置的左边字符串
        RegExp.rightContext;        //捕捉到的位置的右边字符串
      
    展开全文
  • 匹配json字符串正则表达式

    万次阅读 2017-03-24 20:40:10
    需求:一个字符串里可能包含一个或多个json格式的子串以及一些普通格式的子串, 希望用正则把json格式的子串都匹配出来. 正则:(?(?:\{\s*"(?:\\"|[^"])+"\s*:\s*(?:(?P>json)|"(?:\\"|[^"])+"|[-+]?(0|[1-9]\d*)(?:\....

    在处理日志时, 发现文本里夹杂有json字符串, 希望能准确提取出来. 于是就有了下面这个正则表达式:

    (?<json>(?:\{\s*"(?:\\"|[^"])+"\s*:\s*(?:(?P>json)|"(?:\\"|[^"])+"|[-+]?(0|[1-9]\d*)(?:\.[-+]?(0|[1-9]\d*))?(?:[eE][-+]?(0|[1-9]\d*))?|(?:true|false)|null)(?:\s*,\s*"(?:\\"|[^"])+"\s*:\s*(?:(?P>json)|"(?:\\"|[^"])+"|[-+]?(0|[1-9]\d*)(?:\.[-+]?(0|[1-9]\d*))?(?:[eE][-+]?(0|[1-9]\d*))?|(?:true|false)|null))*\s*\}|\[\s*(?:(?P>json)|"(?:\\"|[^"])+"|[-+]?(0|[1-9]\d*)(?:\.[-+]?(0|[1-9]\d*))?(?:[eE][-+]?(0|[1-9]\d*))?|(?:true|false)|null)(?:\s*,\s*(?:(?P>json)|"(?:\\"|[^"])+"|[-+]?(0|[1-9]\d*)(?:\.[-+]?(0|[1-9]\d*))?(?:[eE][-+]?(0|[1-9]\d*))?|(?:true|false)|null))*\s*\]))

    匹配规则完全符合官网规范说明 http://www.json.org
    生成正则时得益于两种思想: 分而治之和递归
    以下是生成正则的代码和简单的测试.

    <?php
    function json_reg() {
        echo '<xmp>';
    
        //基础元素
        $r_int   = '-?\d+'; //整数: 100, -23
        $r_blank = '\s*'; //空白
        $r_obj_l = '\\{'.$r_blank; // {
        $r_obj_r = $r_blank.'\\}'; // }
        $r_arr_l = '\\['.$r_blank; // [
        $r_arr_r = $r_blank.'\\]'; // [
        $r_comma = $r_blank.','.$r_blank; //逗号
        $r_colon = $r_blank.':'.$r_blank; //冒号
    
        //基础数据类型
        $r_str   = '"(?:\\\\"|[^"])+"';  //双引号字符串
        $r_num   = "{$r_int}(?:\\.{$r_int})?(?:[eE]{$r_int})?"; //数字(整数,小数,科学计数): 100,-23; 12.12,-2.3; 2e9,1.2E-8
        $r_bool  = '(?:true|false)'; //bool值
        $r_null  = 'null'; //null
    
        //衍生类型
        $r_key = $r_str; //json中的key
        $r_val = "(?:(?P>json)|{$r_str}|{$r_num}|{$r_bool}|{$r_null})"; //json中val: 可能为 json对象,字符串,num, bool,null
        $r_kv  = "{$r_key}{$r_colon}{$r_val}"; //json中的一个kv结构
    
        $r_arr = "{$r_arr_l}{$r_val}(?:{$r_comma}{$r_val})*{$r_arr_r}"; //数组: 由val列表组成
        $r_obj = "{$r_obj_l}{$r_kv}(?:{$r_comma}{$r_kv})*{$r_obj_r}";   //对象: 有kv结构组成
    
        $reg = "/(?<json>(?:{$r_obj}|{$r_arr}))/is";  //数组或对象
        echo $reg, "\n"; //最终正则表达式
    
        //以下是测试
    
        $str = '
      {
          "_in\"dex" : "log_idx",
          "_type" : "test",
          "_id" : "1",
          "_version" : 1,
          "_shards" : {
             "total" : 2,
             "successful" : 1.3,
             "successful0" : -1.3,
             "successful2" : 1.3e-3,
             "successful4" : 1.3E3,
             "failed" : 0
          },
          "created" : true
       }';
    
    
        preg_match_all($reg, $str, $arr);
        print_r($arr);
    
    }
    
    //调用函数执行
    json_reg();
    展开全文
  • AS3字符串正则表达式

    千次阅读 2013-03-06 09:43:13
    //将指定的 pattern 与字符串匹配,pattern可以是正则表达式或者字符串,如果是字符串就直接匹配。 下面是它文档中的说明: 参数   pattern:* — 要匹配的模式,可以为任何类型的对象,但通常是...
  • 例如:dsdsdsdadadsadada TJP ...grok正则表达式:(?&lt;log_type&gt;(.*)(?=TJP)/?) 输出结果:log_type:"dsdsdsdadadsadada" Grok正则表达式调试地址:http://grokdebug.herokuapp.com/  ...
  • dash 和 bash 的语法有差异,在 dash 下,用正则表达式匹配字符串的时候,提示“[[ not found”,需要使用egrep: dash写法: if echo "$msg" | egrep -q "$regex_string"; then xxx bash写法: if [[ "$msg" =~...
  • 正则表达式是我们经常要用到的检验字符串的是否合法的一个技术点,正则表达式(regular expression)描述了一种字符串匹配的模式(pattern),可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中...
  • 1、匹配字符串全部是中文字符的正则表达式 代码如下:”^[\u4e00-\u9fa5]+$” 说明:“^”表示字符串开头,“$”表示字符串结束,“[\u4e00-\u9fa5]+”表示一个或多个中文字符。 2、匹配字符串中包含中文字符的正则...
  • java正则表达式 过滤特殊字符正则表达式
  • 正则表达式一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。 Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。 re 模块使 Python 语言拥有全部的正则表达式功能。...
  • 文章目录正则表达式匹配两个字符串中间的字符串两个字符中间的字符串两个字符串中间的字符串 两个字符中间的字符串 测试用例casetest.txt: <h1>RUNOOB-菜鸟教程</h1> 目的:匹配一个h1,下面是正则...
  • 有时需要从采集内容或者网址中截取部分字符串,可以使用正则表达式截取 如从/.../中截取出来,\/[\w]+\/,截取/example/字符串,含//符号,非常实用 附录: 以此网址为列 ...
  • 主要介绍了C#正则表达式匹配与替换字符串功能,结合具体实例形式分析了C#字符串正则替换相关类、方法的使用技巧与相关注意事项,需要的朋友可以参考下
  • 字符串正则表达式匹配

    千次阅读 2019-06-12 14:41:33
    和 * 的正则表达式。模式中的字符 . 表示任意一个字符,而 * 表示它前面的字符可以出现任意次(包含0次)。 在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串"aaa"与模式"a.a"和"ab*ac*a"匹配,但是...
  • 譬如我要匹配一个字符串“请拨打110求助”,这个正则不仅要匹配“请拨打110求助”, 也要能匹配包含html标签的字符串(中间的|去掉,防止被过滤用的)如:“请拨打<|span>110<|/span>求助“
  • 正则表达式简介: 正则表达式用于定义一些字符串的规则。 计算机可以根据这些正则表达式,来检查一个... 正则表达式的方法,test()使用这个方法可以用来检查一个字符串是否符合正则表达式的规则。如果符合返回t..
  • 请教一个正则表达式,匹配所有Html标签外部的指定字符串
  • 这里给大家详细讲解一下一个匹配IP地址的正则表达式。 在讲解之前,我先给大家介绍一下,ip地址的生成规则。 IP地址,是由32位数字二进制转为四个十进制的字符串组成。 怎么转化?下面讲解: 二进制:...
  • 先从搜索一个匹配字符串开始。 在一个字符串中搜索满足文本模式的字符串需要使用search方法,该方法的参数与match方法类似。 m = re.search('abc','xabcy') # abc是文本模式字符串,xabcy是待搜索的字符串 pr...
  • 一个用于正则匹配检查的工具,用于使用正则表达式提取字符串
  • 一、JS字符串基础 1、字符串长度 2、字符串中某一个指定的字符首次出现的...•match,找到一个或多个正则表达式匹配。 •search,检索与正则表达式匹配的值,返回初始下标。 •replace,替换与正则表达式匹配的子串。
  • 正则表达用来匹配字符串 正则表达式匹配过程 依次拿出表达式和文本中的字符串进行比价 如果每字符都能匹配,则匹配成功;一旦有匹配不成功的字符,则匹配失败 如果有量词和边界,则匹配过程稍微有些不同 正则...
  • 正则表达式对于程序员写代码的作用:正确有序的使用正则表达式去阅读查询代码会事半功倍,编译移植开源软件程序的时候休要修改Makefile或者configure文件等等,需要有条件查找某些字符串,就必须用到正则表达式了!...
  •  评注:可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1)  匹配空白行的正则表达式:ns*r  评注:可以用来删除空白行  匹配HTML标记的正则表达式:]*>.*?|  评注:网上流传的版本太...
  • 主要介绍了Python 正则表达式匹配数字及使用正则表达式找出字符串中的纯数字,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 第8章 PHP中的正则表达式及式样匹配 8.1 正则表达式简介 8.1.1 正则表达式概念 正则表达式Regular Expression)又称正规表达式简单地说就是若干字符组成的单个字符串它可以描述或者匹配一系列符合某个句法规则的字符...
  • 主要介绍了Python使用中文正则表达式匹配指定中文字符串的方法,结合实例形式分析了Python正则匹配及字符编码相关操作技巧,需要的朋友可以参考下
  • 当需要匹配多个字符串...例如匹配一个网页中的所有图片的url,而图片的url通常以jpg,png等后缀名结尾,以下代码演示如何匹配图片的url #!/usr/bin/env python # coding=utf-8import urllib.request as url import re

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 277,031
精华内容 110,812
关键字:

匹配一个字符串的正则表达式