精华内容
下载资源
问答
  • 正则表达式完全指南 每个人都在谈论正则表达式,但是每个人都讨厌正则表达式,但最终还是使用了正则表达式! 那么什么是正则表达式? 嗯,我们需要更深入吗? 是的,让我们简短介绍一下正则表达式的组成部分。 ...

    正则表达式完全指南

    每个人都在谈论正则表达式,但是每个人都讨厌正则表达式,但最终还是使用了正则表达式!

    那么什么是正则表达式? 嗯,我们需要更深入吗? 是的,让我们简短介绍一下正则表达式的组成部分。

    正则表达式:

    正则表达式或有理表达式本身就是对象,并且描述字符的模式。 它使我们能够搜索特定的文本模式,还有助于匹配,定位和管理文本。 尽管它们看起来很复杂,但是功能非常强大,但是您绝对可以为几乎任何您认为的文本模式创建一个正则表达式。

    正则表达式的基本组成部分:

    元字符是正则表达式的基础。 正则表达式中的字符应理解为具有特殊含义的元字符或具有文字含义的常规字符。

    保留的元字符:

    保留并需要转义的元字符:

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

    我们稍后会看到逃跑的例子。

    其他常见的元字符是:

    脱字号(^):

    (^)匹配字符串的开头,并且在多行模式下还匹配每个换行符之后的字符串。

    例:

    ^\d{3 } will match with patterns like "456" in "456-112-112" .

    美元($):

    ($)匹配字符串的末尾或在字符串末尾的换行符之前,并且在多行模式下也匹配换行符的前面。

    例:

    \d{3 }$  will match with patterns like "112" in "456-112-112" .

    \ d:

    \d匹配整数或数字(0–9)\d的数字确定了我们的正则表达式将匹配的数字的位数。 即, \d表示一位数字\d\d = double digits ,依此类推。

    例:

    \d\d\d将匹配327 , 123, 787 but not 1223匹配327 , 123, 787 but not 1223因为“ 1223”中有4位数字,而我们的正则表达式是3位数字的匹配项。

    \d =1

    \d\d = 12

    \d\d\d ≠ 473847因为它返回3位数字,但473847包含6位数字。

    \d\d\d ≠ cat因为它将仅匹配数字,但cat包含字母。

    \ D:

    反向\d 。 匹配除数字外的任何内容。

    例:

    \D\D = AB

    \D\D = xy

    \D\D ≠ 12因为它与数字字符不匹配。

    \ w:

    匹配任何字母数字(单词)字符。

    例:

    \w\w\w = 467

    \w\w\w\w = Crow

    \w\w\w ≠ python

    \w\w\w不返回python,因为python包含6个字符。

    \ W:

    与\ D相似\ W与\ wi,e相反:匹配字母数字字符以外的任何字符

    例:

    \W\W = ,, or !! or @#

    \W\W\W = !@#

    \W\W\W\W != Titanic2因为每个字符都是字母数字。

    / s

    匹配任何空格字符,例如空格和制表符。

    例如,在上例example_text中,正则表达式\s仅匹配两个单词之间的空格,而忽略其他所有内容。

    / S

    匹配所有与\s不同的非空白字符

    中继器( *, + and { } ):

    *, + and { } 之所以称为中继器,是因为它们表示前一个字符将被使用多次。

    星号(*):

    *前面的字符匹配0次或更多次时,星号匹配。 即:告诉计算机将前面的字符(或一组字符)匹配0次或更多次(最多无限次)。

    例:

    Gre*n = Green(e is found 2 times), Grn(e is found 0 time), Greeeeen (e is found 5 times) ,依此类推..

    tre* != trees因为存在“ s”,后跟“ ee”。

    加号(+):

    '+'前面的字符至少匹配一次或多次(最多无限次(+)时, (+)符号匹配。

    例如

    Gre+n = Green, Greeeen, Gren等。

    Gre+n != Grn此处没有Gre+n != Grn因为“ e”。

    点(。):

    句点与任何字母数字字符或符号匹配。 有趣的是,它可以代替任何其他符号,因此被称为通配符

    例:

    Gre. = Gree, Gren, Gre1 Gre. = Gree, Gren, Gre1

    Gre. != Green Gre. != Green为。 本身仅匹配单个字符,在此是该词的第4个位置。 n是第5个字符,在RegEx中未考虑。

    但是Gre.*会匹配绿色,因为它告诉您可以匹配任何字符
    使用了多次。

    交替(|):

    允许替代比赛。 | 就像布尔或一样。

    例:

    A|B创建将匹配A or B的正则表达式

    H(i!|ey!)将与Hi! or Hey!匹配Hi! or Hey! Hi! or Hey!

    M(s|r|rs)\.?\s[AZ]\w+将匹配以Ms, Mr or Mrs开头的任何名称。

    问号(?):

    当前面的字符匹配吗? 仅出现0或1次,使字符匹配为可选。

    例:

    Favou?rite = Favourite (发现1次)

    Favou?rite = Favorite (找到0次)

    字符集 ([]):

    1. []用于指示一组字符。 在一组中:
    2. 字符可以单独列出,例如[cat]将匹配'c', 'a', or 't' 。 字符范围可以通过指定两个字符并用'-'隔开来表示
    3. 例如

    • [AZ]将匹配任何大写ASCII字母,
    • [0–9]将匹配0 to 9任何数字。
    • [0-3][0-3]将匹配所有从00 to 33的两位数字
    • [0-9A-Fa-f]将匹配任何十六进制数字。
    • 如果-进行了转义(例如[A\-Z])或者将其放置为第一个或最后一个字符(例如[A-]) ,则它将匹配文字'-'。
    • 字符的顺序无关紧要。
    • 特殊字符在集合内失去其特殊含义。例如, [(+*)]将匹配任何文字字符'(', '+', '*', or ')'
    • 要在集合中匹配文字'{',请在其前面加上反斜杠,或将其放在集合的开头。 例如, [()[\]{}][]()[{}]都将匹配括号。
    • 字符组():

      一个人物 组由()表示,以完全相同的顺序匹配字符。

      例:

      (abc) = abc不是acb

      (123) = 123而不是321

      https?://(www\.)?(\w+)(\.\w+)将匹配任何网址。 这里有3组。

      第一组:可选的www.

      第二组:域名google, facebook

      第三组:顶级域名.com, .net, .org

      还有一种隐性组组0组0的一切,我们在我们的情况下,整个拍摄的url

      量词:

      正则表达式使用量词指示搜索字符串的范围。 我们可以在搜索字符串中使用多个量词。 量词是:

      {n}:

      当前一个字符或字符组恰好出现n次时匹配。

      例:

      \d{3}=123

      pand[ora]{2} = pandar, pandoo

      pand[ora]{2} ≠ pandora因为量词{2}仅允许字符集[ora] 2个字母。

      {n,m}:

      当前一个字符或字符组出现至少n次且最多出现m次时匹配。

      例如

      \d{2,6} = 430973, 4303, 38238

      \d{2, 6} ≠ 3 3不匹配,因为它是1位数字,因此超出了字符范围。

      转义元字符:

      要搜索作为保留的元字符的字符( 。[{{)\ ^ $ |?* +的任何一个 ),我们可以使用反斜杠\对该字符进行转义以使其能够被识别。

      例:

      正则表达式下方将匹配任何有效的邮件ID。 在这里,我们使用\来转义保留字符。

      ^([a-zA-Z0–9_\-\.]+)@([a-zA-Z0–9_\-\.]+)\.([a-zA-Z]{2,5})$

      恭喜你! 现在您知道了正则表达式的基本知识,一天已经太多了!

      在我即将发表的文章中,我们将使用python练习正则表达式。

      翻译自: https://hackernoon.com/a-programmers-guide-to-regex-or-regular-expressions-0daw30be

      正则表达式完全指南

    展开全文
  • Python正则表达式1.3正则表达式和Python编译正则表达式compile()函数匹配对象以及group()和groups()方法使用match()方法匹配字符串使用search()在一个字符串中查找模式(搜索与匹配的对比) 正则表达式和Python 在...

    正则表达式和Python

    在Python中,通过使用re模块来支持正则表达式。re模块支持更强大而且更加通用的Perl风格的正则表达式,且该模块允许多线程共享同一个已编辑的正则表达式对象,也支持命名子组。

    编译正则表达式

    在模式匹配发生前,正则表达式模式必须编译成正则表达式对象。但由于在执行的过程中将进行多次比较操作,因此最好先预编译。
    所以大致步骤如下:
    正则表达式—(预编译)—>—(编译)—>正则表达式对象

    compile()函数

    在执行编译的时候,使用compile()函数。
    功能如下:

    compile(pattern,flags=0)
    # 使用任何可选的标记来编译正则表达式的模式,然后返回一个正则表达式对象 
    

    匹配对象以及group()和groups()方法

    匹配对象:顾名思义,是调用match()和search()返回的对象。
    匹配对象主要有两种方法:
    group()
    groups()

    使用match()方法匹配字符串

    match()函数试图从字符串起始部分对模式进行匹配,如果匹配成功,就返回一个匹配对象;如果失败,返回None,匹配对象的group()方法能够用于显示那个成功的匹配。

    示例如下:

    import re
    
    def re_match():
        content = 'Hello 123 4567 World_This is a Regex Demo'
        result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}.*Demo$', content)
        #^符号匹配字符串开头,Hello开头的字符串写过来,
    	#\s匹配任意的空白字符的,\d可以匹配任意的数字的
    	#后面有4567,写4个\d太麻烦了,d{4}
    	#\w匹配字母或者下划线
    	#后面一长串字符不想写了。直接用.来全部代替,匹配任意字符
    	#* 匹配0个或多个表达式
    	#也就是.*可以匹配任意的字符除了换行符
    	#用Demo$制定正则表达式的结尾
        print(len(content))
        print(result)
        print(result.group())
        print(result.span())
    
    if __name__ == '__main__':
        re_match()
    
    

    运行后结果如下:

    41
    <re.Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
    Hello 123 4567 World_This is a Regex Demo
    (0, 41)
    >>>
    

    使用search()在一个字符串中查找模式(搜索与匹配的对比)

    search()的工作方式与match()完全一致,不同之处在于search()会用到它的字符串参数,会在任意位置对给定正则表达式模式搜索第一次出现的匹配情况。如果搜索到成功的匹配,就会返回一个匹配对象,否则返回None。

    示例如下:

    import re
    
    def re_search():
        content = 'The food is tasted like foot !'
        result = re.search('foo', content)
        print(len(content))
        print(result)
        print(result.group())
        print(result.span())
    
    if __name__ == '__main__':
        re_search()
    

    结果如下:

    30
    <re.Match object; span=(4, 7), match='foo'>
    foo
    (4, 7)
    >>> 
    

    由此可见,search()函数不但会搜索模式在字符串中第一次出现的位置,而且严格地从字符串从左到右搜索,但是细心的博友可以看到我的本意是想搜索出两个’foo’,但结果只显示了第一个’foo’的位置,那么想要实现搜索多个字符串,就要看接下来的知识点了。

    匹配多个字符串

    示例如下:

    >>> import re
    >>> bt = 'bat|bet|bit'
    >>> m = re.match(bt,'bat')
    >>> if m is not None:
    	m.group()
    
    	
    'bat' #匹配成功
    ##############################
    >>> m = re.match(bt,'blt')
    >>> if m is not None:
    	m.group()
    
    	
    # 对于'blt'没有匹配
    ##############################
    >>> m = re.match(bt,'He bit me!')
    >>> if m is not None:
    	m.group()
    	
    # 匹配失败不能匹配字符串
    #################################	
    >>> m = re.search(bt,'He bit me!')
    >>> if m is not None:
    	m.group()
    
    	
    'bit'  # 通过搜索查找'bit'
    >>> 
    

    匹配任何单个字符

    接下来,我通过代码展示点号(.)不能匹配一个换行符\n或者非字符,也就是空字符串。

    示例1:

    import re
    
    anyend = '.end'
    
    def re_match_1():
        m = re.match(anyend,'bend')
        print('-----1------')
        if m is not None:
            print(m.group())
        
    def re_match_2():
        m = re.match(anyend,'end')
        print('-----2------')
        if m is not None:
            print(m.group())
        
    def re_match_3():
        m = re.match(anyend,'\nend')
        print('-----3------')
        if m is not None:
            print(m.group())
            
    def re_search_1():
        m = re.search(anyend,'The end.')
        print('-----4------')
        if m is not None:
            print(m.group())
            
    if __name__ == '__main__':
        re_match_1()
        re_match_2()
        re_match_3()
        re_search_1()
    
    

    执行结果如下:

    -----1------
    bend
    -----2------
    -----3------
    -----4------
     end
    >>> 
    

    由此发现:
    第一个match()成功进行点号匹配b;
    第二个match()因为end前空字符串,故不匹配任何字符;
    第三个match()因为end前有换行符\n,故不匹配任何字符;
    最后一个search()在搜索中匹配end前的空字符

    示例2:
    下面的示例是在正则表达式中搜索一个真正的句点(小数点),而我么通过使用一个反斜线对句点的功能进行转义:

    import re
    
    patt314 = '3.14'
    pi_patt = '3\.14'
    
    
    def re_match_1():
        m = re.match(pi_patt,'3.14')
        print('-----1------')
        if m is not None:
            print(m.group())
        
    def re_match_2():
        m = re.match(patt314,'3014')
        print('-----2------')
        if m is not None:
            print(m.group())
        
    def re_match_3():
        m = re.match(patt314,'3.14')
        print('-----3------')
        if m is not None:
            print(m.group())
    
    if __name__ == '__main__':
        re_match_1()
        re_match_2()
        re_match_3()
        
    

    执行结果如下:

    -----1------
    3.14
    -----2------
    3014
    -----3------
    3.14
    >>> 
    

    由此可见:
    第一个match()精确匹配字符串;
    第二个match()点号匹配0
    第三个match()点号匹配.,表示字面量的点号。

    创建字符集([ ])

    下面通过一个示例说明对于’|‘的限制比’[]'更为严格。
    示例:

    import re
    
    def re_match_1():
        m = re.match('[cr][23][dp][o2]','c3po')
        print('-----1------')
        if m is not None:
            print(m.group())
        
    def re_match_2():
        m = re.match('[cr][23][dp][o2]','c2do')
        print('-----2------')
        if m is not None:
            print(m.group())
            
    def re_match_3():
        m = re.match('r2d2|c2po','c2do')
        print('-----3------')
        if m is not None:
            print(m.group())
    
    def re_match_4():
        m = re.match('r2d2|c2po','r2d2')
        print('-----4------')
        if m is not None:
            print(m.group())
            
    if __name__ == '__main__':
        re_match_1()
        re_match_2()
        re_match_3()
        re_match_4()
        
    

    执行结果如下:

    -----1------
    c3po
    -----2------
    c2do
    -----3------
    -----4------
    r2d2
    >>> 
    

    重复,特殊字符以及分组

    正则表达式中最常见的情况包括特殊字符的使用、正则表达式模式的重复出现,以及使用圆括号对匹配模式的各部分进行分组和提取操作。

    首先,举一个简单的电子邮箱地址的正则表达式的例子:

    \w+\@\w+.com
    

    如果我们想要匹配比这个正则表达式所允许的更多邮箱地址。例如在域名前添加主机名称支持(www.xxx.com),仅仅允许xxx.com作为整个域名等等。
    示例代码:

    import re
    def re_match():
        patt='\w+@(\w+\.)?\w+\.com'
        m=re.match(patt,'nobody@xxx.com')
        print(m.group())
    
    if __name__ == '__main__':
        re_match()
    
    

    但是仅仅是数字字母字符并不能完全成功匹配,因为电子邮件地址还可能为:xxx-yyy.com,诸如此类域名,都是无法成功才匹配的,对应解决代码如下:

    import re
    m = re.match('\w\w\w=\d\d\d','abc-123')
    if m is not None:
    	m.group()
    
    执行结果:'abc-123'
    

    为了使该正则表达式能够提取字母数字字符串和数字,可以使用分组,下例子解决如何使用group()方法访问每个独立的子组以及group()方法以获取一个包含所有匹配子组的元组。

    import re
    
    
    def re_match():
        patt='(\w\w\w)-(\d\d\d)'
        m=re.match(patt,'abc-123')
        for i in range(0,3):    #通过一个for循环打印出数组
            print(m.group(i))
        print(m.groups())    #最后打印出所有数组的集合
    
    if __name__ == '__main__':
        re_match()
    

    执行结果如下:

    abc-123
    abc
    123
    ('abc', '123')
    

    匹配字符串的起始和结尾以及单词边界

    如下显示突出显示表示位置的正则表达式操作符,该操作符更多应用于表示搜索而不是匹配,因为match()总是从字符串开始位置进行匹配的。

    import re
    
    def re_search1():
        demo1=('The end.','end. The')
        demo2=('bite the dog','bitethe dog')
        for i in range(0,2):
            m=re.search('^The', demo1[i])
            if m is not None:
                print(m.group(),'|')
        for i in range(0,2):
            m=re.search(r'\bthe',demo2[i])
            if m is not None:
                print(m.group(),'|')
        for i in range(0,2):
            m=re.search(r'\Bthe',demo2[i])
            if m is not None:
                print(m.group(),'|')
    if __name__ == '__main__':
        re_search1()
        
    

    显示结果:

    The |
    the |
    the |
    >>>
    
    展开全文
  • mysql 提供的模式匹配的其他类型是使用扩展正则表达式。 当你对这类模式进行匹配测试时,使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE,它们是同义词)。 扩展正则表达式的一些字符是: “.”匹配任何单个的...
  • java正则表达式 正则表达式是用于文本搜索的非常重要的工具。 以下是用于执行正则表达式搜索并基于正则表达式捕获字符串的不同部分的代码段 public class RegexTest { public static void main(String[] args) { ...
    java正则表达式

    java正则表达式

    正则表达式是用于文本搜索的非常重要的工具。 以下是用于执行正则表达式搜索并基于正则表达式捕获字符串的不同部分的代码段

     public class RegexTest { 
        public static void main(String[] args) { 
            String name = "01_My-File.pdf" ;
    
            match(name);
    
            match( "09_03_12File.docx" );
    
            match( "09_03_12File.q123" ); 
        }
    
        public static void match(String input){
    
            System.out.println( "********* Analysing " + input+ " *********" );
    
            String regex = "([0-9]+)([_])(.*)([\\.])([A-Za-z]+)" ;
    
            Pattern pattern = Pattern.compile(regex);
    
            Matcher matcher = pattern.matcher(input);
    
            if (!matcher.matches()){
    
                System.out.println( "Input not matches regex" );
    
                return ;
    
            }
    
            System.out.println( "Matches: " + matcher.matches());
    
            String number = matcher.group(1);
    
            System.out.println( "Index: " + number);
    
            String fileName = matcher.group(3);
    
            System.out.println( "FileName: " + fileName);
    
            String extension = matcher.group(5);
    
            System.out.println( "Extension: " + extension);
    
        }
     }
    

    使用()捕获组。 在上面的正则表达式中([0-9]+)([_])(.*)([\.])([A-Za-z]+)

    • 第一组定义为至少一个数字的数字
    • 第二组是固定字符_
    • 第三组是任何文本。
    • 第四组是固定字符。 (我们必须使用\\进行转义.因为在正则表达式中, .表示任何字符,符号,空格或数字)。
    • 第五组是长度大于0的字符组。

    我们使用Pattern类来编译正则表达式,并使用它匹配输入以生成Matcher实例。 此Matcher具有有关正则表达式匹配结果的信息。

    翻译自: https://www.javacodegeeks.com/2020/02/how-to-use-regular-expression-in-java.html

    java正则表达式

    展开全文
  • 定义正则表达式 定义正则表达式的方法:构造法和直接量。 构造正则表达式 RegExp构造函数可以定义正则表达式,用法如下: new RegExp(pattern,attributes) 说明: 参数pattern是一个字符串,指定了正则...

    定义正则表达式

    定义正则表达式的方法:构造法和直接量。

    构造正则表达式

    RegExp构造函数可以定义正则表达式,用法如下:

    new RegExp(pattern,attributes)
    

    说明:

    • 参数pattern是一个字符串,指定了正则表达式的模式或者其他正则表达式;
    • 参数attributes是一个可选的修饰性标志,包含“g”,“i”,“m”,分别用于全局匹配、区分大小写的匹配和多行匹配。如果pattern是正则表达式,而不是字符串,则必须省略该参数。
    • 该函数将返回一个新的RegExp对象,具有指定的模式和标志。
    var r=new RegExp("a");//构造最简单的正则表达式
    var s="javascript!=JAVA";//定义字符串直接量
    var a=s.match(r);//调用正则表达式执行匹配操作,返回匹配的数组
    alert(a);//a
    alert(a.index);//1
    
    var r=new RegExp("a","gi");
    var s="javascript!=JAVA";
    var a=s.match(r);
    alert(a);//a,a,A,A
    

    为了避免RegExp()构造函数的误解,必须使用“\\”代表"\"字符。(双反斜杠代替反斜杠)

    var r=new RegExp("\\b\\w","gi");
    var s="javascript JAVA";
    var a=s.match(r);
    alert(a);//j,J
    

    正则表达式直接量

    正则表达式直接量使用双斜杆作为分隔符进行定义,双斜杆之间包含的字符为正则表达式的字符模式,字符模式不能使用引号,标志字符放在最后一个斜杆的后面。语法:

    /pattern/attributes
    

    定义一个正则表达式直接量,然后进行调用。

    var r=/\b\w/gi;
    var s="javascript JAVA";
    var a=s.match(r);
    alert(a);//j,J
    

    在RegExp()构造函数中可以传递变量,而在正则表达式直接量中是不允许的。

    访问正则表达式对象

    RegExp对象属性

    属性说明
    global返回Boolean值,检测RegExp对象是否具有标志g
    ignoreCase返回Boolean值,检测RegExp对象是否具有标志i
    multiline返回Boolean值,检测RegExp对象是否具有标志m
    lastIndex一个整数,返回或者设置开始执行下一次匹配的字符位置
    sourse返回正则表达式的源字符串文本
    var r=/adrfg/gi;
    alert(r.global);//true
    alert(r.ignoreCase);/true
    alert(r.multiline);//false
    alert(r.source);//adrfg
    
    var s="javascript is not java";
    var r=/a/gi;
    r.exec(s);
    alert(r.lastIndex);//2
    r.exec(s);
    alert(r.lastIndex);//4
    r.exec(s);
    alert(r.lastIndex);//20
    r.exec(s);
    alert(r.lastIndex);//22
    r.exec(s);
    alert(r.lastIndex);//0
    
    var s="0123456789";
    var r=/\d/g;//匹配单个数字
    r.lastIndex=5;
    var a=r.exec(s);
    alert(a);//5
    

    执行匹配操作

    RegExp对象方法

    方法说明
    exec()检索字符串中指定的值,返回找到的值,并确定其位置
    test()检索字符串中指定的值,返回true或false
    compile()编译正则表达式

    exec()方法的具体用法:

    RegExpObject.exec(string)
    

    参数string是要检索的字符串。返回一个数组,其中存放匹配的结果。如果未找到匹配结果,则返回null。

    除了数组元素和length属性之外,exec()方法还返回以下属性:

    • index:匹配文本的第一个字符的位置。
    • input:存放被检索的字符串(string)。

    说明:在调用非全局模式下的RegExp对象的exec()方法时,返回的数组与调用String.match()方法返回的数组是相同的。

    在调用全局模式的RegExp对象的exec()方法时,RegExpObject的lastIndex属性指定执行匹配的起始位置,当exec()方法找到了与表达式相匹配的文本后,将把lastIndex设置为匹配文本的最后一个字符的下一个位置。即可以反复调用exec()方法来遍历字符串中所有匹配文本,当exec()找不到匹配文本时,将返回null,并把lastIndex属性重置为0。

    var s="javascript";
    var r=/\w/g;
    while((a=r.exec(s))!=null){
    	alert(a[0]+"\n"+a.index+"\n"+r.lastIndex);
    }
    

    说明:如果在一个字符串中完成了一次模式匹配之后,再开始检索新的字符串,就必须手动把正则表达式的lastIndex属性重置为0.

    compile()方法用于脚本执行过程中改变或重新编译正则表达式,即更换正则表达式对象所使用的匹配模式。用法如下:

    RegExpObject.compile(regexp,modifier)
    

    参数regexp表示正则表达式,modifier定义匹配类型,如“g”,“i”,“gi”。

    var str1="Every man in the world!Every women on earth!";
    patt=/man/g;
    str2=str1.replace(patt,"person");
    document.write(str2+"<br />");
    patt=/(wo)?men/g;
    patt.compile(patt);
    str2=str1.replace(patt,"person");
    document.write(str2);
    

    输出:
    Every person in the world!Every women on earth!
    Every man in the world!Every person on earth!

    访问匹配信息

    RegExp静态属性

    长名 / 短名说明
    input ( $_ )返回当前所作用的字符串,初始值为空字符串“”
    index当前模式匹配的开始位置,从0开始计数。初始值为-1,每次成功匹配时,index属性值都会随之改变
    lastIndex当前模式匹配的最后一个字符的下一个字符位置,从0开始计算,常被作为继续匹配的起始。初始值为-1,表示从起始位置开始搜索,每次成功匹配时,lastIndex值都会随之改变
    lastMatch($&)最后模式匹配的字符串,初始值为空字符串“”。在每次成功匹配时,lastMatch属性值都会随之改变
    lastParen($+)最后子模式匹配的字符串,如果匹配模式中包含有子模式(包含小括号的子表达式),在最后模式匹配中最后一个子模式所匹配的子字符串。初始值为空字符串“”,每次成功匹配时,lastParent属性值都会随之改变
    leftContext($`)在当前所作用的字符串中,最后模式匹配的字符串左边的所有内容。初始值为空字符串“”,每次成功匹配时,其属性值都会随之改变
    rightContext($’)在当前所作用的字符串中,最后模式匹配的字符串右边的所有内容。初始值为空字符串。每次成功匹配,其属性值都会随之改变
    $1-$9只读属性,如果匹配模式中小括号包含的子模式,$1-$9属性值分别是第1个到第9个子模式所匹配到的内容,如果超过9个以上的子模式,则分别对应最后9个子模式匹配的结果
    var s="JavaScript ,not Javascript";
    var r=/(Java)Script/g;
    var a=r.exec(s);//执行匹配操作
    alert(RegExp.input);//JavaScript ,not Javascript
    alert(RegExp.leftContext);//空字符串
    alert(RegExp.rightContext);// ,not Javascript
    alert(RegExp.lastMatch);//JavaScript
    alert(RegExp.lastParen);//Java
    
    var s="JavaScript ,not Javascript";
    var r=/(Java)Script/g;
    var a=r.exec(s);//执行匹配操作
    alert(RegExp.$_);//JavaScript ,not Javascript
    alert(RegExp["$`"]);//空字符串
    alert(RegExp["$'"]);// ,not Javascript
    alert(RegExp["$&"]);//JavaScript
    alert(RegExp["$+"]);//Java
    
    var s="JavaScript ,not Javascript";
    var r=/(Java)(Script)/g;
    var a=r.exec(s);//执行匹配操作
    alert(RegExp.lastParen);//Script
    

    条件检测

    test()方法能够检测一个字符串是否符合指定匹配模式,该方法适宜作为条件检测使用。用法如下:

    RegExpObject.test(string)
    

    参数string表示要检测的字符串。如果字符串中含有与RegExpObjject匹配的文本,则返回true,否则返回false。

    var s="javscript";
    var r=/\w/g;
    var b=r.test(s);
    alert(b);//true
    
    var s="javscript";
    var r=/\d/g;//匹配数字
    var b=r.test(s);
    alert(b);//false
    
    展开全文
  • 最近在写程序遇到需要用正则表达式验证EXCEL数据名称是否为中文或英文,找到了下面这篇文章主要介绍了正则表达式同时匹配中英文及常用正则表达式的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下 ...
  • ruby中的正则表达式 Ruby正则表达式 (Ruby regular expressions) Regular expressions are a series of characters which are used to define the pattern to carry out a specific search. It can also be termed ...
  • 前言:对正则表达式一直都很向往觉得他很神奇,尤其是在处理前端页面表单的时候,实在不想写if else判断,所以抽了点时间简单学习了一下,总结下学习成果。我在处理表单验证和页面数据渲染的时候会用到正则表达式,...
  • 正则表达式:符合一定规则的表达式特点:用一些特定地符号,来表示一些代码操作.如,用 a* 代表abcdse 这个字符串.所以学习正则表达式,就是在学习一些特殊符号的使用作用:用于专门操作字符串string类型提供的字符串的...
  • awk 使用正则表达式 在awk中,正则表达式(regex)允许动态和复杂的模式定义。 您不仅限于搜索简单的字符串,而且还搜索模式中的模式。 使用正则表达式匹配awk中的行的语法为: word ~ / match / 相反的是不...
  • 正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具,拥有自己独特的语法以及一个独立的处理引擎,效率上可能不如str自带的方法,但功能十分强大。本模块提供了和Perl里的正则表达式类似的功能...
  • Python中常用的正则表达式处理函数。Python的正则表达式主要有两种方法完成模式匹配:『搜索』和『匹配』re.matchre.match 尝试从字符串的开始全部或者部分匹配某个模式,如:下面的例子匹配第一个单词。# @param ...
  • 正则语言和正则表达式by Alaina Kafkes 由Alaina Kafkes 探索正则表达式背后的语言学 (Exploring the Linguistics Behind Regular Expressions) 语言突破是如何在代码中结束的 (How a linguistic breakthrough ...
  • 今天,冷月将给小伙伴们带来正则表达式的基本语法和一些简单的实例。 正则表达式的基本语法 定界符 表示一个正则表达式的开始和结束,一般用特殊符号来表示。简单来说就是用特殊符号把内容包住。 /……/ {……...
  • hive 正则表达式详解

    万次阅读 2016-04-09 18:56:22
    hive中的正则表达式还是很强大的。数据工作者平时也离不开正则表达式。对此,特意做了个hive正则表达式的小结。所有代码都经过亲测,正常运行。1.regexp语法: A REGEXP B 操作类型: strings 描述: 功能与RLIKE相同...
  • 常用转义字符、通配符和正则表达式转义字符:shell的其他特殊字符:通配符和正则表达式:通配符:正则表达式:转义字符:有时候,我们想让 通配符,或者元字符 变成普通字符,不需要使用它。那么这里我们就需要用到...
  • 一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行...
  • 在Linux命令行操作或者SHELL...对于通配符和正则表达式之间容易理解的方法就是,在文本过滤命令中这些元字符是用做正则表达式,比如像awk,sed,grep等,主要是针对文件内容的。然而通配符多用在文件名上,比如查找f...
  • 正则表达式速记理解技巧   四个字符是所有语言都支持的正则表达式,所以这个四个是基础的正则表达式。正则难理解因为里面有一个等价的概念,这个概念大大增加了理解难度,让很多初学者看起来会蒙,如果把等价都恢复...
  • 正则表达式口诀 + 常用的正则表达式 + 正则表达式学习工具+正则处理工具 正则是每个程序员绕不开的堡垒,只有把它攻下来。我觉得正则之所以难,第一难是需要记忆,第二难是要求具备抽象逻辑思维。 签于网上太多的...
  • 指数-普通正则表达式 Expynent是一个小型库,提供常见的正则表达式模式。 如果您不想手动编写正则表达式,这将很有用。 您也可以使用该库作为测试框架的,例如 。 安装 ~ pip install expynent 用法 只需导入所需...
  • [正则表达式]非常经典的正则表达式作者:Mikel 日期:2008-11-04 前言: 半年前我对正则表达式产生了兴趣,在网上查找过不少资料,看过不少的教程,最后在使用一个正则表达式工具RegexBuddy时发现他的教程写的非常好,...
  • 在Linux命令行操作或者...对于通配符和正则表达式之间容易理解的方法就是,在文本过滤命令中这些元字符是用做正则表达式,比如像awk,sed,grep等,主要是针对文件内容的。然而通配符多用在文件名上,比如查找find,...
  • 正则表达式相关:收录常用的正则表达式

    千次阅读 多人点赞 2011-12-27 14:27:57
    正则表达式在项目中用时常还是会用到的,不过写起来还是要费些工夫的,于是搜集了一些常用的正则,就不用每次都要自己写了。君子善假于物也,借助现有的经验资料以提高编程的效率。  匹配中文字符的正则表达式: ...
  • 知道正则表达式引擎如果工作可以让你很容易的构造出更好的正则表达式。这会帮助你理解为什么有的正则表达式并不如你预期的那样工作,这会帮你省下很多时间。 有2种正则表达式引擎,文本导向引擎和正则导向引擎。...
  • 正则表达式用于字符串处理,表单验证等场合,实用高效,但用到时总是不太把握,以致往往要上网查一番。我将一些常用的表达式收藏在这里,作备忘之用。本贴随时会更新。 匹配中文字符的正则表达式: [u4e00-u9fa5]...
  • js 正则表达式匹配非法字符 示例(此示例验证通过) var pat=new RegExp("[^a-zA-Z0-9\_\u4e00-\u9fa5]","i"); var strTest = $("#testId").val(); if(pat.test(strTest)==true) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 127,667
精华内容 51,066
关键字:

not正则表达式