精华内容
下载资源
问答
  • 2019-06-12 09:51:52
    最新手机号正则表达式:^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\D])|(19[^4,\D])|(18[0,1,2,5-9]))\d{8}$
    可以为空的手机号正则表达式:^\s{0}$|^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\D])|(19[^4,\D])|(18[0,1,2,5-9]))\d{8}$
    更多相关内容
  • chinmo 逆向思维解决方案 代码如下: [removed] /** * 至少有一个非空白字符并且不超过6个字符的正则表达式 * * 作者:chinmo * 整理:http://www.CodeBit.cn * 来源:...var pattern = /^[\s]{0,}$|^[\w\s]{7,}$/g;...
  • 在写备注或者说明输入框的时候,一般都要求不能有特殊字符,但是可以有逗号,可以输入汉字、...(^$) // 表示可以为空 (^[\u4E00-\u9FA5a-zA-Z0-9,,]{1,250}$) //表示可以输入1-250个字的数字、汉字、字母、逗号 ...

    在写备注或者说明输入框的时候,一般都要求不能有特殊字符,但是可以有逗号,可以输入汉字、字母、数字逗号。查了很多都不行,今天把自己的分享出来。

    /(^$)|(^[\u4E00-\u9FA5a-zA-Z0-9,,]{1,250}$)/
    
    (^$) // 表示可以为空
    (^[\u4E00-\u9FA5a-zA-Z0-9,,]{1,250}$)   //表示可以输入1-250个字的数字、汉字、字母、逗号
    
    展开全文
  • C++ 正则表达式教程解释了 C++ 中正则表达式的工作,包括正则表达式匹配、搜索、替换、输入验证和标记化的功能。 几乎所有的编程语言都支持正则表达式。 C++ 从 C++11 开始直接支持正则表达式。除了编程语言之外,...

    C++ 正则表达式教程解释了 C++ 中正则表达式的工作,包括正则表达式匹配、搜索、替换、输入验证和标记化的功能。

    几乎所有的编程语言都支持正则表达式。 C++ 从 C++11 开始直接支持正则表达式。除了编程语言之外,大多数文本处理程序(如词法分析器、高级文本编辑器等)都使用正则表达式。

    在本教程中,我们将探讨正则表达式的一般细节以及 C++ 编程方面的细节。

    正则匹配中的基础符号

    ^开头
    ()[]或,
    {}几次
    $结尾
    

    1. C++ 中的正则表达式 (Regex)

    正则表达式是包含一系列字符的表达式,这些字符定义了可用于字符串搜索算法、查找或查找/替换算法等的特定搜索模式。正则表达式也用于输入验证。

    大多数编程语言要么为正则表达式提供内置功能,要么通过库提供。从 C++11 开始,C++ 通过 标准库提供正则表达式支持。

    用于解析正则表达式的正则表达式处理器将其转换为内部表示,该表示被执行并与表示正在搜索的文本的字符串匹配。 C++11 使用 ECMAScript 语法作为正则表达式的默认语法。 ECMAScript 很简单,但它提供了强大的正则表达式功能。 让我们看看我们在正则表达式中指定的一些模式,如范围规范、重复模式等。

    1.1 范围规范

    指定字符或文字的范围是正则表达式中使用的最简单的标准之一。

    例如,我们可以指定一个从a到z的小写字母范围,如下所示:[a-z],这将只匹配一个小写字符。

    下列条件:[A-Za-z0-9]
    上面的表达式指定了包含一个大写字母、一个小写字母和0到9之间的数字的范围。

    上述表达式中的方括号([])具有特殊含义,即用于指定范围。如果你想包含一个括号作为表达式的一部分,那么你需要转义它。

    那么下面的表达式,[\[0-9]
    上面的表达式表示一个左括号和一个0到9范围内的数字作为正则表达式。

    但请注意,当我们使用 C++ 编程时,我们需要使用 C++ 特定的转义序列,如下所示:[\\[0-9]

    1.2 重复模式

    我们上面指定的范围示例只匹配一个字符或文字。如果我们想匹配多个字符,我们通常在模式中指定“表达式修饰符”,从而使其成为一个重复的模式。

    表达式修饰符可以是+,表示匹配一个模式出现一次或多次,也可以是*,表示匹配一个模式出现零次或多次。

    例如,下面的表达式,
    [a-z]+ 匹配 a、aaa、abcd、softwaretestinghelp 等字符串。请注意,它永远不会匹配空白字符串。
    [a-z]*将匹配一个空白字符串或任何上面的字符串。

    如果要指定一组字符匹配一次或多次,则可以使用括号,如下所示:(Xyz)+

    上面的表达式将匹配Xyz、XyzXyzXyzXyz等等。

    2. C++正则表达式的例子

    考虑一个匹配 MS-DOS 文件名的正则表达式,如下所示。

    char regex_filename[] =[a-zA-Z_] [a-zA-Z_0-9]*\\.[a-zA-Z0-9]+;
    

    上面的正则表达式可以解释如下:
    匹配一个字母(小写,然后大写)或下划线。然后匹配零个或多个字符,其中每个字符可以是字母、下划线或数字。然后匹配文字点(.)。在点之后,匹配一个或多个字符,其中每个字符可以是表示文件扩展名的字母或数字。

    3. C++正则表达式中使用的函数模板

    现在让我们讨论在 C++ 中编写正则表达式时的一些重要函数模板。

    3.1 regex_match()

    此函数模板用于匹配给定的模式。如果给定的表达式与字符串匹配,则此函数返回 true。否则,该函数返回 false

    以下是演示 regex_match 函数的 C++ 编程示例。

    #include <iostream>
    #include <string>
    #include <regex>
    using namespace std;
     
    int main () {
     
       if (regex_match ("softwareTesting", regex("(soft)(.*)") ))
          cout << "string:literal => matched\n";
     
       const char mystr[] = "SoftwareTestingHelp";
       string str ("software");
       regex str_expr ("(soft)(.*)");
     
       if (regex_match (str,str_expr))
          cout << "string:object => matched\n";
     
       if ( regex_match ( str.begin(), str.end(), str_expr ) )
          cout << "string:range(begin-end)=> matched\n";
     
       cmatch cm;  //匹配的词语检索出来
       regex_match (mystr,cm,str_expr);
        
       smatch sm;
       regex_match (str,sm,str_expr);
        
       regex_match ( str.cbegin(), str.cend(), sm, str_expr);
       cout << "String:range, size:" << sm.size() << " matches\n";
     
       
       regex_match ( mystr, cm, str_expr, regex_constants::match_default );
     
       cout << "the matches are: ";
       for (unsigned i=0; i<sm.size(); ++i) {
          cout << "[" << sm[i] << "] ";
       }
     
       cout << endl;
     
       return 0;
    }
    

    请添加图片描述
    在上面的程序中,首先,我们使用regex_match函数将字符串" softwareTesting "与正则表达式" (soft)(.*) "匹配。随后,我们还通过向regex_match传递字符串对象、范围等来演示regex_match的不同变体。

    3.2 regex_search()

    函数regex_search()用于在字符串中搜索匹配正则表达式的模式。

    考虑下面的c++程序,它显示了regex_search()的用法。

    #include <iostream> 
    #include <regex> 
    #include<string.h> 
    using namespace std; 
       
    int main() 
    { 
        //string to be searched
        string mystr = "She sells_sea shells in the sea shore"; 
       
        // regex expression for pattern to be searched 
        regex regexp("s[a-z_]+"); 
       
        // flag type for determining the matching behavior (in this case on string objects)
         smatch m; 
       
        // regex_search that searches pattern regexp in the string mystr  
        regex_search(mystr, m, regexp); 
      
        cout<<"String that matches the pattern:"<<endl;
        for (auto x : m) 
            cout << x << " "; 
        return 0; 
    }
    

    请添加图片描述
    我们先指定一个字符串,然后使用regex对象指定一个正则表达式。这个字符串和regex连同smatch标志类型一起被传递给regex_search函数。该函数在输入字符串中搜索第一个出现的模式,并返回匹配的字符串。

    3.3 regex_replace()

    函数regex_replace()用于用字符串替换与正则表达式匹配的模式。

    让我们使用一个c++程序来演示regex_replace()函数。

    #include <iostream> 
    #include <string> 
    #include <regex> 
    #include <iterator> 
    using namespace std; 
       
    int main() 
    {  
        string mystr = "This is software testing Help portal \n"; 
         
        cout<<"Input string: "<<mystr<<endl;
           
        // regex to match string beginning with 'p' 
        regex regexp("p[a-zA-z]+"); 
        cout<<"Replace the word 'portal' with word 'website' : "; 
        // regex_replace() for replacing the match with the word 'website'  
        cout << regex_replace(mystr, regexp, "website"); 
         
        string result; 
           
        cout<<"Replace the word 'website' back to 'portal': ";
        // regex_replace( ) for replacing the match back with 'portal' 
        regex_replace(back_inserter(result), mystr.begin(), mystr.end(), 
                      regexp,  "portal"); 
       
        cout << result; 
       
        return 0; 
    }
    

    请添加图片描述
    这里,我们有一个输入字符串。我们提供了一个正则表达式来匹配以 p 开头的字符串。然后我们将匹配的单词替换为website。接下来,我们将website替换回portal

    4.C++输入验证

    我们已经讨论了使用regex进行模式匹配的主要函数模板。值得注意的是,regex服务的主要目的是输入验证。可以使用regex表达式验证从标准输入设备输入的输入。

    检查下面的程序,以演示如何使用regex验证传入的数据。

    #include <iostream>
    #include <regex>
    #include <string>
    using namespace std;
      
    int main()
    {
        string input;
        regex integer_expr("(\\+|-)?[[:digit:]]+");
        //As long as the input is correct ask for another number
        while(true)
        {
            cout<<"Enter the input: ";
            cin>>input;
            if(!cin) break;
            //Exit when the user inputs q
            if(input=="q")
                break;
            if(regex_match(input,integer_expr))
                cout<<"Input is an integer"<<endl;
            else
            {cout<<"Invalid input : Not an integer"<<endl;}
        }
    }
    

    请添加图片描述
    这个程序匹配用户输入的输入,以验证它是否是整数。上面的输出显示,当输入一个整数时,它会给出一个适当的消息,而当输入任何其他数据时,它会将该消息作为无效输入。

    5.总结

    Regex在搜索引擎中用于搜索模式,搜索和替换应用程序的对话框,如字处理器和文本编辑器。Regex也用于UNIX实用程序,如sed、awk以及程序的词法分析。

    在本教程中,我们已经看到了用于匹配、搜索和替换模式的函数。使用这些函数,我们基本上可以开发一个高效的应用程序,使用regex实现所需的功能。

    Regex允许通过修补模式有效地验证输入或搜索并替换字符串,这可以使用很少的行来完成。

    参考目录

    https://www.softwaretestinghelp.com/regex-in-cpp/

    展开全文
  • 正则表达式 1. 什么是正则表达式? 百度百科提供的概念是这样的:正则表达式,又称规则表达式**。**(英语:Regular Expression,在代码中常简写regex、regexp或RE),计算机科学的一个概念。其通常被用来检索、...

    正则表达式

    1. 什么是正则表达式?

    百度百科提供的概念是这样的:正则表达式,又称规则表达式**。**(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。其通常被用来检索、替换那些符合某个模式(规则)的文本

    正则表达式其实是对字符串操作的一种公式,通过组合一些具有特殊含义的字符,来实现用户的操作逻辑,从而对文本完成操作。我们一般称这些“特殊字符的组合”为规则字符串

    在不同语言中,正则表达式有不同的变种,具体情况我们会在后文以JavaScriptPython为例进行说明

    2. 元字符

    正则表达式由一些普通字符和一些元字符(metacharacters)组成

    普通字符包括大小写的字母和数字,而元字符则具有特殊的含义,相关含义如下表所示:

    元字符含义
    \转义字符。例如,“n”会匹配小写字母n,但是“\n”则会匹配换行符\n
    ^匹配行首
    $匹配行尾
    ***匹配前面的子表达式任意次(大于等于0次)。**例如,zo*能匹配“z”,也能匹配“zo”以及“zoo”。*等价于{0,}。
    +**匹配前面的子表达式一次或多次(大于等于1次)。**例如,“zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。+等价于{1,}。
    ?**匹配前面的子表达式0次或1次。**例如,“do(es)?”可以匹配“do”或“does”。?等价于{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}**表示最少匹配n次且最多匹配m次,其中mn均为非负整数,其中n<=m。**例如,“o{1,3}”将匹配“fooooood”中的前三个o为一组,后三个o为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
    ?当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串,而默认的贪婪模式则尽可能多地匹配所搜索的字符串。例如,对于字符串“oooo”,“o+”将尽可能多地匹配“o”,得到结果[“oooo”],而“o+?”将尽可能少地匹配“o”,得到结果 [‘o’, ‘o’, ‘o’, ‘o’]
    .**匹配除“\n”和"\r"之外的任何单个字符。**要匹配包括“\n”和"\r"在内的任何字符,请使用像“[\s\S]”的模式。
    x|y**匹配x或y。**例如,“z|food”能匹配“z”或“food”。“[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”;“\b1_”可以匹配“1_23”中的“1_”,但不能匹配“21_3”中的“1_”。
    \B匹配非单词边界。“er\B”能匹配“verb”中的“er”,但不能匹配“never”中的“er”。
    \cx**匹配由x指明的控制字符。**例如,\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则,将c视为一个原义的“c”字符。
    \d**匹配一个数字字符。**等价于[0-9]。grep 要加上-P,perl正则支持
    \D**匹配一个非数字字符。**等价于[^0-9]。grep要加上-P,perl正则支持
    \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的向后引用。如果前面的条件都不满足,若nm均为八进制数字(0-7),则*nm将匹配八进制转义值nm
    *nml*如果n为八进制数字(0-7),且ml均为八进制数字(0-7),则匹配八进制转义值nml
    \un**匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。**例如,\u00A9匹配版权符号(©)。
    \p{P}**小写 p 是 property 的意思,表示 Unicode 属性,用于 Unicode 正表达式的前缀。**中括号内的“P”表示Unicode 字符集七个字符属性之一:标点字符。其他六个属性:L:字母;M:标记符号(一般不会单独出现);Z:分隔符(比如空格、换行等);S:符号(比如数学符号、货币符号等);N:数字(比如阿拉伯数字、罗马数字等);C:其他字符。*注:此语法部分语言不支持,例:javascript。
    <>**匹配词(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."。注意:这个元字符不是所有的软件都支持的。

    在正则表达式中,如果直接给出字符,就是精确匹配。用\d可以匹配一个数字,\w可以匹配一个字母或数字,所以:

    • '00\d'可以匹配'007',但无法匹配'00A'
    • '\d\d\d'可以匹配'010'
    • '\w\w\d'可以匹配'py3'

    .可以匹配任意字符,所以:

    • 'py.'可以匹配'pyc''pyo''py!'等等。

    要匹配变长的字符,在正则表达式中,用*表示任意个字符(包括0个),用+表示至少一个字符,用?表示0个或1个字符,用{n}表示n个字符,用{n,m}表示n-m个字符:

    来看一个复杂的例子:\d{3}\s+\d{3,8}

    我们来从左到右解读一下:

    1. \d{3}表示匹配3个数字,例如'010'
    2. \s可以匹配一个空格(也包括Tab等空白符),所以\s+表示至少有一个空格,例如匹配' '' '等;
    3. \d{3,8}表示3-8个数字,例如'1234567'

    综合起来,上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码。

    如果要匹配'010-12345'这样的号码呢?由于'-'是特殊字符,在正则表达式中,要用'\'转义,所以,上面的正则是\d{3}\-\d{3,8}

    但是,仍然无法匹配'010 - 12345',因为带有空格。所以我们需要更复杂的匹配方式。

    要做更精确地匹配,可以用[]表示范围,比如:

    • [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线;
    • [0-9a-zA-Z\_]+可以匹配至少由一个数字、字母或者下划线组成的字符串,比如'a100''0_Z''Py3000'等等;
    • [a-zA-Z\_][0-9a-zA-Z\_]*可以匹配由字母或下划线开头,后接任意个由一个数字、字母或者下划线组成的字符串,也就是Python合法的变量;
    • [a-zA-Z\_][0-9a-zA-Z\_]{0, 19}更精确地限制了变量的长度是1-20个字符(前面1个字符+后面最多19个字符)。

    A|B可以匹配A或B,所以(P|p)ython可以匹配'Python'或者'python'

    ^表示行的开头,^\d表示必须以数字开头。

    $表示行的结束,\d$表示必须以数字结束。

    你可能注意到了,py也可以匹配'python',但是加上^py$就变成了整行匹配,就只能匹配'py'了。

    3. Python中的正则表达式

    3.1 re模块

    有了准备知识,我们就可以在Python中使用正则表达式了。Python提供re模块,包含所有正则表达式的功能。由于Python的字符串本身也用\转义,所以要特别注意:

    s = 'ABC\\-001' # Python的字符串
    # 对应的正则表达式字符串变成:
    # 'ABC\-001'
    

    因此我们强烈建议使用Python的r前缀,就不用考虑转义的问题了:

    s = r'ABC\-001' # Python的字符串
    # 对应的正则表达式字符串不变:
    # 'ABC\-001'
    

    先看看如何判断正则表达式是否匹配:

    >>> import re
    >>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
    <_sre.SRE_Match object; span=(0, 9), match='010-12345'>
    >>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345')
    >>>
    

    match()方法判断是否匹配,如果匹配成功,返回一个Match对象,否则返回None。常见的判断方法就是:

    test = '用户输入的字符串'
    if re.match(r'正则表达式', test):
        print('ok')
    else:
        print('failed')
    

    3.2 分组

    除了简单地判断是否匹配之外,正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组(Group)。比如:

    ^(\d{3})-(\d{3,8})$分别定义了两个组,可以直接从匹配的字符串中提取出区号和本地号码:

    >>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
    >>> m
    <_sre.SRE_Match object; span=(0, 9), match='010-12345'>
    >>> m.group(0)
    '010-12345'
    >>> m.group(1)
    '010'
    >>> m.group(2)
    '12345'
    

    如果正则表达式中定义了组,就可以在Match对象上用group()方法提取出子串来

    注意到group(0)永远是原始字符串,group(1)group(2)……表示第1、2、……个子串

    提取子串非常有用。来看一个更凶残的例子:

    >>> t = '19:05:30'
    >>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
    >>> m.groups()
    ('19', '05', '30')
    

    这个正则表达式可以直接识别合法的时间。但是有些时候,用正则表达式也无法做到完全验证,比如识别日期:

    '^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$'
    

    对于'2-30''4-31'这样的非法日期,用正则还是识别不了,或者说写出来非常困难,这时就需要程序配合识别了

    3.3 贪婪匹配

    最后需要特别指出的是,正则匹配默认是贪婪匹配,也就是匹配尽可能多的字符。举例如下,匹配出数字后面的0

    >>> re.match(r'^(\d+)(0*)$', '102300').groups()
    ('102300', '')
    

    由于\d+采用贪婪匹配,直接把后面的0全部匹配了,结果0*只能匹配空字符串了

    必须让\d+采用非贪婪匹配(也就是尽可能少匹配),才能把后面的0匹配出来,加个?就可以让\d+采用非贪婪匹配:

    >>> re.match(r'^(\d+?)(0*)$', '102300').groups()
    ('1023', '00')
    

    3.4 编译

    当我们在Python中使用正则表达式时,re模块内部会干两件事情:

    1. 编译正则表达式,如果正则表达式的字符串本身不合法,会报错
    2. 用编译后的正则表达式去匹配字符串

    如果一个正则表达式要重复使用几千次,出于效率的考虑,我们可以预编译该正则表达式,接下来重复使用时就不需要编译这个步骤了,直接匹配:

    >>> import re
    # 编译:
    >>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
    # 使用:
    >>> re_telephone.match('010-12345').groups()
    ('010', '12345')
    >>> re_telephone.match('010-8086').groups()
    ('010', '8086')
    

    编译后生成Regular Expression对象,由于该对象自己包含了正则表达式,所以调用对应的方法时不用给出正则字符串

    4. JavaScrip中的正则表达式

    4.1 描述字符

    根据正则表达式语法规则,大部分字符仅能够描述自身,这些字符被称为普通字符,如所有的字母、数字等。

    元字符就是拥有特动功能的特殊字符,大部分需要加反斜杠进行标识,以便于普通字符进行区别,而少数元字符,需要加反斜杠,以便转译为普通字符使用。JavaScript 正则表达式支持的元字符如表所示。

    元字符描述
    .查找单个字符,除了换行和行结束符
    \w查找单词字符
    \W查找非单词字符
    \d查找数字
    \D查找非数字字符
    \s查找空白字符
    \S查找非空白字符
    \b匹配单词边界
    \B匹配非单词边界
    \0查找 NUL字符
    \n查找换行符
    \f查找换页符
    \r查找回车符
    \t查找制表符
    \v查找垂直制表符
    \xxx查找以八进制数 xxxx 规定的字符
    \xdd查找以十六进制数 dd 规定的字符
    \uxxxx查找以十六进制 xxxx规定的 Unicode 字符

    表示字符的方法有多种,除了可以直接使用字符本身外,还可以使用 ASCII 编码或者 Unicode 编码来表示。

    示例1

    下面使用 ASCII 编码定义正则表达式直接量。

    var r = /\x61/;
    var s = "JavaScript";
    var a = s.match(s);
    

    由于字母 a 的 ASCII 编码为 97,被转换为十六进制数值后为 61,因此如果要匹配字符 a,就应该在前面添加“\x”前缀,以提示它为 ASCII 编码。

    示例2

    除了十六进制外,还可以直接使用八进制数值表示字符。

    var r = /\141/;
    var s = "JavaScript";
    var a = s.match(r);
    

    使用十六进制需要添加“\x”前缀,主要是为了避免语义混淆,而八进制则不需要添加前缀。

    示例3

    ASCII 编码只能够匹配有限的单字节字符,使用 Unicode 编码可以表示双字节字符。Unicode 编码方式:“\u”前缀加上 4 位十六进制值。

    var r = "/\u0061/";
    var s = "JavaScript";
    var a = s.match(s);
    

    在 RegExp() 构造函数中使用元字符时,应使用双斜杠。

    var r = new RegExp("\\u0061"); 
    

    RegExp() 构造函数的参数只接受字符串,而不是字符模式。在字符串中,任何字符加反斜杠还表示字符本身,如字符串“\u”就被解释为 u 本身,所以对于“\u0061”字符串来说,在转换为字符模式时,就被解释为“u0061”,而不是“\u0061”,此时反斜杠就失去转义功能。解决方法:在字符 u 前面加双反斜杠。

    4.2 描述字符范围

    在正则表达式语法中,放括号表示字符范围。在方括号中可以包含多个字符,表示匹配其中任意一个字符。如果多个字符的编码顺序是连续的,可以仅指定开头和结尾字符,省略中间字符,仅使用连字符~表示。如果在方括号内添加脱字符^前缀,还可以表示范围之外的字符。例如:

    • [abc]:查找方括号内任意一个字符。
    • [^abc]:查找不在方括号内的字符。
    • [0-9]:查找从 0 至 9 范围内的数字,即查找数字。
    • [a-z]:查找从小写 a 到小写 z 范围内的字符,即查找小写字母。
    • [A-Z]:查找从大写 A 到大写 Z 范围内的字符,即查找大写字母。
    • [A-z]:查找从大写 A 到小写 z 范围内的字符,即所有大小写的字母。

    示例1

    字符范围遵循字符编码的顺序进行匹配。如果将要匹配的字符恰好在字符编码表中特定区域内,就可以使用这种方式表示。

    如果匹配任意 ASCII 字符:

    var r = /[\u0000-\u00ff]/g;
    

    如果匹配任意双字节的汉字:

    var r = /[^\u0000-\u00ff]/g;
    

    如果匹配任意大小写字母和数字:

    var r = /[a-zA-Z0-9]/g;
    

    使用 Unicode 编码设计,匹配数字:

    var r = /[\u0030-\u0039]/g;
    

    使用下面字符模式可以匹配任意大写字母:

    var r = /[\u0041-\u004A]/g;
    

    使用下面字符模式可以匹配任意小写字母:

    var r = /[\u0061-\u007A]/g;
    

    示例2

    在字符范围内可以混用各种字符模式。

    var s = "abcdez";     //字符串直接量
    var r = /[abce-z]/g;  //字符a、b、c,以及从e~z之间的任意字符
    var a = s.match(r);   //返回数组["a","b","c","e","z"]
    

    示例3

    在中括号内不要有空格,否则会误解为还要匹配空格。

    var r = /[0-9]/g;
    

    示例4

    字符范围可以组合使用,以便设计更灵活的匹配模式。

    var s = "abc4 abd6 abe3 abf1 abg7";  //字符串直接量
    var r = /ab[c-g][1-7]/g;             //前两个字符为ab,第三个字符为从c到g,第四个字符为1~7的任意数字
    var a = s.match(r);                  //返回数组["abc4","abd6","abe3","abf1","abg7"]
    

    示例5

    使用反义字符范围可以匹配很多无法直接描述的字符,达到以少应多的目的。

    var r = /[^0123456789]/g;
    

    在这个正则表达式中,将会匹配除了数字以外任意的字符。反义字符类比简单字符类的功能更强大和实用。

    4.3 选择匹配

    选择匹配类似于 JavaScript 的逻辑与运算,使用竖线|描述,表示在两个子模式的匹配结果中任选一个。例如:

    1. 匹配任意数字或字母
    var r = /\w+|\d+/;
    
    1. 可以定义多重选择模式。设计方法:在多个子模式之间加入选择操作符。
    var r = /(abc)|(efg)|(123)|(456)/;
    

    为了避免歧义,应该为选择操作的多个子模式加上小括号。

    示例

    设计对提交的表单字符串进行敏感词过滤。先设计一个敏感词列表,然后使用竖线把它们连接在一起,定义选择匹配模式,最后使用字符串的 replace() 方法把所有敏感字符替换为可以显示的编码格式。代码如下:

    var s = '<meta charset="utf-8">';  //待过滤的表单提交信息
    var r = /\'|\"|\<|\>/gi;  //过滤敏感字符的正则表达式
    function f() {  //替换函数    把敏感字符替换为对应的网页显示的编码格式    
    	return "&#" + arguments[0].charCodeAt(0) + ";";
    }
    var a =s.replace(r,f);  //执行过滤替换 
    document.write(a);  //在网页中显示正常的字符信息
    console.log(a);
    

    显示结果如下:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nr9fzaIA-1633857087626)(C:\Users\10754\AppData\Roaming\Typora\typora-user-images\image-20211010170548841.png)]

    4.4 重复匹配

    在正则表达式语法中,定义了一组重复类量词,如表所示。它们定义了重复匹配字符的确数或约数。

    量词描述
    n+匹配任何包含至少一个 n 的字符串
    n*匹配任何包含零个或多个 n 的字符串
    n?匹配任何包含零个或一个 n 的字符串
    n{x}匹配包含 x 个 n 的序列的字符串
    n{x,y}匹配包含最少 x 个、最多 y 个 n 的序列的字符串
    n{x,}匹配包含至少 x 个 n 的序列的字符串

    示例

    下面结合示例进行演示说明,先设计一个字符串:

    var s = "ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
    
    1. 如果仅匹配单词 ggle 和 gogle,可以设计:
    var r = /go?gle/g;
    var a = s.match(r);
    

    量词?表示前面字符或子表达式为可有可无,等效于:

    var r = /go{0,1}gle/g;
    var a = s.match(r);
    
    1. 如果匹配第 4 个单词 gooogle,可以设计:
    var r = /go{3}gle/g;
    var a = s.match(r);
    

    等效于:

    var r = /gooogle/g;
    var a = s.match(r);
    
    1. 如果匹配第 4 个到第 6 个之间的单词,可以设计:
    var r = /go{3,5}gle/g;
    var a = s.match(r);
    
    1. 如果匹配所有单词,可以设计:
    var r = /go*gle/g;
    var a = s.match(r);
    

    量词*表示前面字符或表达式可以不出现,或者重复出现任意多次。等效于:

    var r = /go(0,)gle/g;
    var a = s.match(r);
    
    1. 如果匹配包含字符“o”的所有词,可以设计:
    var r = /go+gle/g;
    var a = s.match(r);
    

    量词+表示前面字符或子表达式至少出现 1 次,最多重复次数不限。等效于:

    var r = /go{1,}gle/g;
    var a = s.match(r);
    

    重复类量词总是出现在它们所作用的字符或子表达式后面。如果想作用于多个字符,需要使用小括号把它们包裹在一起形成一个子表达式。

    4.4 惰性匹配

    重复类量词都具有贪婪性,在条件允许的前提下,会匹配尽可能多的字符。

    • ?、{n} 和 {n,m} 重复类具有弱贪婪性,表现为贪婪的有限性。
    • *、+ 和 {n,} 重复类具有强贪婪性,表现为贪婪的无限性。

    示例1

    越是排在左侧的重复类量词匹配优先级越高。下面示例显示当多个重复类量词同时满足条件时,会在保证右侧重复类量词最低匹配次数基础上,使最左侧的重复类量词尽可能占有所有字符。

    var s = "<html><head><title></title></head><body></body></html>";
    var r = /(<.*>)(<.*>)/;
    var a = s.match(r);//左侧表达式匹配
    console.log(a[1]);
    console.log(a[2]);  //右侧表达式匹配“</html>”
    

    与贪婪匹配相反,惰性匹配将遵循另一种算法:在满足条件的前提下,尽可能少的匹配字符。定义惰性匹配的方法:在重复类量词后面添加问号?限制词。贪婪匹配体现了最大化匹配原则,惰性匹配则体现最小化匹配原则。

    示例2

    下面示例演示了如何定义匹配模式。

    var s = "<html><head><title></title></head><body></body></html>";
    var r = /<.*?>/;
    var a = s.match(r);  //返回单个元素数组["<html>"]
    

    在上面示例中,对于正则表达式 /<.*?>/ 来说,它可以返回匹配字符串 “<>”,但是为了能够确保匹配条件成立,在执行中还是匹配了带有 4 个字符的字符串“html”。惰性取值不能够以违反模式限定的条件而返回,除非没有找到符合条件的字符串,否则必须满足它。

    针对 6 种重复类惰性匹配的简单描述如下:

    • {n,m}?:尽量匹配 n 次,但是为了满足限定条件也可能最多重复 m 次。
    • {n}?:尽量匹配 n 次。
    • {n,}?:尽量匹配 n 次,但是为了满足限定条件也可能匹配任意次。
    • ??:尽量匹配,但是为了满足限定条件也可能最多匹配 1 次,相当于 {0,1}?。
    • +?:尽量匹配 1 次,但是为了满足限定条件也可能匹配任意次,相当于 {1,}?。
    • *? :尽量不匹配,但是为了满足限定条件也可能匹配任意次,相当于 {0,}?。

    4.5 边界量词

    边界就是确定匹配模式的位置,如字符串的头部或尾部,具体说明如表所示。

    量词说明
    ^匹配开头,在多行检测中,会匹配一行的开头

    | $ | 匹配结尾,在多行检测中,会匹配一行的结尾
    下面代码演示如何使用边界量词。先定义字符串: |

    var s = "how are you"
    
    1. 匹配最后一个单词
    var r = /\w+$/;
    var a = s.match(r);  //返回数组["you"]
    
    1. 匹配第一个单词
    var r = /^\w+/;
    var a = s.match(r);  //返回数组["how"]
    
    1. 匹配每一个单词
    var r = /\w+/g;
    var a = s.match(r);  //返回数组["how","are","you"]
    

    4.6 声明词量

    声明表示条件的意思。声明词量包括正向声明和反向声明两种模式。

    正向声明

    指定匹配模式后面的字符必须被匹配,但又不返回这些字符。语法格式如下:

    匹配模式 (?= 匹配条件)

    声明包含在小括号内,它不是分组,因此作为子表达式。

    下面代码定义一个正前向生命的匹配模式。

    var s = "one : 1; two : 2";
    var r = /\w*(?==)/;  //使用正前向声明,指定执行匹配必须满足的条件
    var a = s.match(r);  //返回数组["two"]
    

    在上面示例中,通过?==锚定条件,指定只有在 \w* 所能够匹配的字符后面跟随一个等号字符,才能够执行 \w* 匹配。所以,最后匹配的字符串“two”,而不是字符串“one”。

    反向声明

    与正向声明匹配相反,指定接下来的字符都不必被匹配。语法格式如下:

    匹配模式(?! 匹配条件)

    下面代码定义一个反前向生命的匹配模式。

    var s = "one : 1; two : 2";
    var r = /\w*(?!=)/;  //使用正前向声明,指定执行匹配不必满足的条件
    var a = s.match(r);  //返回数组["one"]
    

    在上面示例中,通过?!=锚定条件,指定只有在“\w*”所能够匹配的字符后面不跟随一个等号字符,才能够执行 \w*匹配。所以,最后匹配的是字符串“one”,而不是字符串“two”。

    4.7 子表达式

    使用小括号可以对字符模式进行任意分组,在小括号内的字符串表示子表达式,也称为子模式。子表达式具有独立的匹配功能,保存独立的匹配结果;同时,小括号后的量词将会作用于整个子表达式。

    通过分组可以在一个完整的字符模式中定义一个或多个子模式。当正则表达式成功地匹配目标字符串后,也可以从目标字符串中抽出与子模式相匹配的子内容。

    示例

    在下面代码中,不仅能匹配出每个变量声明,同时还抽出每个变量及其值。

    var s = "ab=21, bc=45, cd=43";
    var r = /(\w+)=(\d*)/g;
    while (a = r.exec(s)) {    
    	console.log(a);  //返回类似["ab=21","bc=45","cd=43"]三个数组
    }
    

    4.8 反向引用

    在字符模式中,后面的字符可以引用前面的子表达式。实现方法如下:

    + 数字

    数字指定了子表达式在字符模式中的顺序。如“\1”引用的是第 1 个子表达式,“\2”引用的是第 2 个子表达式。

    示例1

    在下面代码中,通过引用前面子表达式匹配的文本,实现成组匹配字符串。

    var s = "<h1>title<h1><p>text<p>";
    var r = /(<\/?\w+>)\1/g;
    var a = s.match(r);  //返回数组["<h1>title<h1>","<p>text<p>"]
    

    由于子表达式可以相互嵌套,它们的顺序将根据左括号的顺序来确定。例如,下面示例定义匹配模式包含多个子表达式。

    var s = "abc";
    var r = /(a(b(c)))/;
    var a = s.match(r);  //返回数组["abc","abc","bc","c"]
    

    在这个模式中,共产生了 3 个反向引用,第一个是“(a(b©))”,第二个是“(b©)”,第三个是“©”。它们引用的匹配文本分别是字符串“abc”、“bc”和“c”。

    对子表达式的引用,是指引用前面子表达式所匹配的文本,而不是子表达式的匹配模式。如果要引用前面子表达式的匹配模式,则必须使用下面方式,只有这样才能够达到匹配目的。

    var s = "<h1>title</h1><p>text</p>";
    var r = /((<\/?\w+>).*(<\/?\w+>))/g;
    var a = s.match(r);  //返回数组["<h1>title</h1>","<p>text</p>"]
    

    反向引用在开发中主要有以下几种常规用法。

    示例2

    在正则表达式对象的 test() 方法中,以及字符串对象的 match() 和 search() 等方法中使用。在这些方法中,反向引用的值可以从 RegExp() 构造函数中获得。

    var s = "abcdefghijklmn";
    var r = /(\w)(\w)(\w)/;
    r.test(s);
    console.log(RegExp.$1);  //返回第1个子表达式匹配的字符a
    console.log(RegExp.$2);  //返回第2个子表达式匹配的字符b
    console.log(RegExp.$3);  //返回第3个子表达式匹配的字符c
    

    通过上面示例可以看到,正则表达式执行匹配检测后,所有子表达式匹配的文本都被分组存储在 RegExp() 构造函数的属性内,通过前缀符号$与正则表达式中子表达式的编号来引用这些临时属性。其中属性 $1 标识符指向第 1 个值引用,属性 $2 标识符指向第 2 个值引用。

    示例3

    可以直接在定义的字符模式中包含反向引用。这可以通过使用特殊转义序列(如 \1、\2 等)来实现。

    var s = "abcbcacba";
    var r = /(\w)(\w)(\w)\2\3\1\3\2\1/;
    var b = r.test(s);  //验证正则表达式是否匹配该字符串
    console.log(b);  //返回true
    

    在上面示例的正则表达式中,“\1”表示对第 1 个反向引用 (\w) 所匹配的字符 a 进行引用,“\2”表示对第 2 个反向引用 (\w) 所匹配的字符串 b 进行引用,“\3”表示对第 3 个反向引用 (\w) 所匹配的字符 c 进行引用。

    示例4

    可以在字符串对象的 replace() 方法中使用。通过使用特殊字符序列$1、$2、$3 等来实现。例如,在下面的示例中将颠倒相邻字母和数字的位置。

    var s = "aa11bb22c3d4e5f6";
    var r = /(\w+?)(\d+)/g;
    var b = s.replace(r,"$2$1");
    console.log(b);  //返回字符串“aa11bb22c3  d4e5f6”
    

    在上面例子中,正则表达式包括两个分组,第 1 个分组匹配任意连续的字母,第 2 个分组匹配任意连续的数字。在 replace() 方法的第 2 个参数中,$1 表示对正则表达式中第 1 个子表达式匹配文本的引用,而 $2 表示对正则表达式中第 2 个子表达式匹配文本的引用,通过颠倒 $1 和 $2 标识符的位置,即可实现字符串的颠倒来替换原字符串。

    4.9 禁止引用

    反向引用会占用一定的系统资源,在较长的正则表达式中,反向引用会降低匹配速度。如果分组仅仅是为了方便操作,可以禁止反向引用。

    实现方法:在左括号的后面加上一个问号和冒号。

    var s1 = "abc";
    var r = /(?:\w*?)|(?:\d*?)/;
    var a = r.test(si);
    

    非引用型分组必须使用子表达式,但是又不希望存储无用的匹配信息,或者希望提高匹配速度来说,是非常重用的方法。

    展开全文
  • 让后端的正则表达式允许为空
  • I use a validator that requires a regex to be specified. In the case of validating against an empty string, I don't know how to generate such a regex. What regex can I use to match the empty string?...
  • 表单验证的时候会用到 记录一下 ^$|你的正则式 /*例如:可 但填了必须6到16位*/ /(^$)|(.+){6,16}$/
  • 正则表达式的正文。正则表达式中使用了特殊符号。下面我就将各种符号以及其意义和用法简单的介绍一下(说明:"X以上包括X"):/ 表示在其后的文字是特殊符号。例:"n"和"n"是一致的。"/n"和换行符是一致的。^ 和...
  • 正则表达式(Regular Expression)一种文本模式,包括普通字符(例如,a 到 z 之间的字母)和特殊字符(称为"元字符")。使用单个字符串来描述、匹配一系列 某个句法规则的字符串。繁琐但强大,学会后可提高工作效率和成就...
  • 正则表达式:数字开头中间字母结尾数字如果你的结尾数字是多个也可以的话,你就要再加上一个+号,另外,中间的字母允许大写幺?允许的话要再加上A-Z,所以你可以改这样试试:"^[0-9]+[a-zA-Z]+[0-9]+$"如何用正则...
  • 注:本文《The Linux Command Line》正则表达式章节的笔记,引用了其中的大部分内容,转载请注明,本文标记转载文章的转载地址书籍网站地址 目录POSIX标准的正则表达式正则表达式的构成两种正则表达式基本正则...
  • 正则表达式允许输入汉字

    千次阅读 2019-12-12 15:39:08
    第一种 <el-form-item label="类目名称" :label-width="formLabelWidth" ... :rules="{ required: true, message: '类目名称不能为空', trigger: 'blur'}"> <el-input v-model="form.name" a...
  • 正则表达式的模式匹配

    千次阅读 2022-03-14 17:41:47
    正则表达式是一个描述字符模式的对象。JavaScript 的 RegExp 类表示正则表达式,String 和 RegExp 都定义了方法,后者使用正则表达式进行强大的模式匹配和文本检索与替换功能。 正则表达式的定义 正则表达式可以使用...
  • 正则语言和正则表达式by Alaina Kafkes 由Alaina Kafkes 探索正则表达式背后的语言学 (Exploring the Linguistics Behind Regular Expressions) 语言突破是如何在代码中结束的 (How a linguistic breakthrough ...
  • 正则表达式,前后非空,中间可

    千次阅读 2021-01-04 14:09:48
    1、正则表达式,不允许在字符串的开头和结尾使用空格,但允许在字符串的中间使用空格 ^[^\s]+(\s+[^\s]+)*$ 2、如果要包括字符限制 ^[-a-zA-Z0-9-()]+(\s+[-a-zA-Z0-9-()]+)*$
  • python正则表达式

    2020-11-28 18:31:22
    正则表达式(Regluar Expressions)又称规则表达式,在代码中常简写REs,regexes或regexp(regex patterns)。它本质上是一个小巧的、高度专用的编程语言。 通过正则表达式可以对指定的文本实现匹配测试、内容查找...
  • 一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符...在写个正则表达式的时候需要控制输入的字符串数字,但是不是必须输入,可以为空。如果用("^\\d+$")只校验数字的话,在不输的情况下也不会通过。所
  • 正则表达式匹配过程中,如果子表达式匹配到的字符内容,而非位置,并被保存到最终的匹配结果中,那么就认为这个子表达式是占有字符的;如果子表达式匹配的仅仅是位置,或者匹配的内容并不保存到最终的匹配结果中,...
  • 正则表达式, 字符串的替换与分解 正则表达式 正则表达式主要用于字符串匹配, 由一些具有特殊意义的符号和常规字符组成, 例如: 特殊符号: $ () * + . [] ? \ ^ {} 常规字符组合: \d \D \w \W \s \S \p ....
  • 正则表达式1.1 什么是正则表达式1.2 什么使用正则表达式2.语法2.1 普通字符2.2 限定符2.3 非打印字符2.4 特殊字符2.5 定位符2.6 修饰符(标记)2.7 选择2.8 运算符优先级3.常用正则表达式及在线工具4.Jmeter之正则...
  • 正则表达式,又称规则表达式,(英语:Regular Expression)在代码中常简写 regex、regexp 或 RE ,计算机科学的一个概念。 正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本 正则表达式不只有一种,...
  • 正则表达式学习1、正则表达式是一门独立的学科,和任何编程语言无关,2、在编程中使用正则表达式最主要是用来做字符串模式匹配。3、在正则表达式中规定一些特殊符号,每一个符号都具有特殊含义。4、在实际开发中我们...
  • 正则表达式(英语:Regular Expression,在代码中常简写regex)。 正则表达式是一个字符串,使用单个字符串来描述、用来定义匹配规则,匹配一系列符合某个句法规则的字符串。在开发中,正则表达式通常被用来检索...
  • Java正则表达式详解

    2020-12-21 09:06:11
    如果你曾经用过Perl或任何其他内建正则表达式支持的语言,你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语,那么“正则表达式”(RegularExpression)就是一个字符构成的串,它定义了一个...
  • 常用的正则表达式主要有以下几种: 匹配中文字符的正则表达式:[\u4e00-\u9fa5]获取日期正则表达式:\d{4}[年|\-|\.]\d{1,2}[月|\-|\.]\d{1,2}日?匹配双字节字符(包括汉字在内):[^\x00-\xff] 计算字符串的长度(一...
  • 正则表达式

    千次阅读 2020-07-26 23:41:14
    文章目录正则表达式之精华前言一、基础正则表达式1 .1正则表达式的定义1.2 正则表达式用途1.3 基础正则表达式1.4 grep命令1.4.1查找特定字符命令执行后,符合匹配标准的字符, 字体颜色会变为红色1.4.2利用中括号“...
  • Java正则表达式

    2021-03-07 14:18:35
    所以,在其他的语言中,一个反斜杠就足以具有转义的作用,而在正则表达式中则需要有两个反斜杠才能被解析其他语言中的转义作用。也可以简单的理解在正则表达式中,两个 代表其他语言中的一个 ,这也就是什么表示...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,342
精华内容 32,536
关键字:

正则表达式允许为空