精华内容
下载资源
问答
  • 正则表达式的概述 1.什么是正则表达式 正则表达式是用于匹配字符串中字符组合的模式。在JavaScript中,正则表达式也是对象。 作用:正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本,例如:验证...

    正则表达式的概述

    1.什么是正则表达式

    • 正则表达式是用于匹配字符串中字符组合的模式。在JavaScript中,正则表达式也是对象。

    • 作用:正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本,例如:验证表单:用户名表单只能输入英文字母、数字或者下划线,昵称输入框中可以输入中文(匹配)。此外,正则表达式还常用于过滤页面内容中的一些敏感词(替换),或从字符串中获取我们想要的特定部分(提取)。

    • 其他编程语言也一样会有正则表达式。

    2.正则表达式的特点

    (1)灵活性、逻辑性和功能性非常的强。

    (2)可以迅速地用极简单的方式达到字符串的复杂控制。

    (3)对于刚接触的人来说,比较晦涩难懂。

    (4)实际开发,一般都是直接复制写好的正则表达式,但是要求会使用正则表达式并且根据实际情况修改正则表达式。

    正则表达式在JavaScript中的使用

    1.创建正则表达式

    • 在JavaScript中,可以通过以下两种方式创建正则表达式:

      (1)通过调用RegExp对象的构造函数创建

      var 变量名 = new RegExp(/表达式/)
      //举例:
      var reg = new RegExp(/123/);
      console.log(reg);		//输出结果为:/123/
      

      (2)通过字面量创建

      var reg = /123/;
      

    2.测试正则表达式test

    • test()正则对象方法,用于检测字符串是否符合该规则,该对象会返回true或false,其参数是检测字符串。
    regexObj.test(str)
    

    (1)regexObj 是写的正则表达式。

    (2)str 是我们要测试的文本。

    (3)该方法就是检测str文本是否符合我们写的正则表达式规范。

    • 举例:
    var reg = /123/;
    console.log(reg.test(123));		//输出结果为:true
    

    正则表达式中的特殊字符

    1.正则表达式的组成

    • 一个正则表达式可以由简单的字符构成,比如:/abc/;也可以是简单和特殊字符的组合,比如:/ab*c/。其中,特殊字符也被称为元字符,在正则表达式中是具有特殊意义的专用符号,如:^、$、+等。

    • 特殊字符非常多,可以参考:

      MDN:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions

      jQuery手册:正则表达式部分

      正则测试工具:http://tool.oschina.net/regex

    2.边界符

    • 正则表达式中的边界符(位置符)用来提示字符所处的位置,主要有两个字符。
    边界符说明
    ^表示匹配行首的文本(以谁开始)
    $表示匹配行尾的文本(以谁结束)
    var rg = /abc/;		//正则表达式里面不需要加引号,不管是数字型还是字符串型
    //该正则表达式表示只要包含abc这个字符串,并且abc要连起来的,不能分开,返回的就是true
    console.log(re.test('abc'));		//输出结果为:true
    console.log(re.test('abcd'));		//输出结果为:true
    console.log(re.test('aabcd'));	//输出结果为:true
    console.log(re.test('ahbgc'));	//输出结果为:true
    
    console.log('----------------------');
    
    var reg = /^abc/;		//表示必须以abc开头,返回的才是true
    console.log(reg.test('abc'));		//输出结果为:true
    console.log(reg.test('abcd'));	//输出结果为:true
    console.log(reg.test('aabcd'));	//输出结果为:false
    
    console.log('----------------------');
    
    var reg = /^abc$/;		//精确匹配,要求必须是abc字符串才符合规范,才返回true,其他都是false
    console.log(reg.test('abc'));		//输出结果为:true
    console.log(reg.test('abcd'));	//输出结果为:false
    console.log(reg.test('aabcd'));	//输出结果为:false
    console.log(reg.test('abcabc'));//输出结果为:false
    

    3.字符类

    • []表示有一系列字符可供选择,只要匹配其中一个就可以了。
    var rg = /[abc]/;	//只要包含有a或者b或者c,都返回true(可以包含多个不同字符,同个字符也可以多次出现)
    console.log(rg.test('andy'));		//输出结果为:true
    console.log(rg.test('baby'));		//输出结果为:true
    console.log(rg.test('color'));	//输出结果为:ture
    console.log(rg.test('red'));		//输出结果为:false
    
    var rg = /^[abc]$/;		//表示只能三选一,即'a'或'b'或'c',才返回true
    console.log(rg.test('aa'));		//输出结果为:fasle
    console.log(rg.test('a'));		//输出结果为:true
    console.log(rg.test('b'));		//输出结果为:true
    console.log(rg.test('c'));		//输出结果为:true
    console.log(rg.test('abc'));	//输出结果为:false
    
    • [-]:方括号内部的范围符-
    var reg = /^[a-z]$/;
    console.log(reg.test('a'));		//输出结果为:true
    console.log(reg.test('z'));		//输出结果为:true
    console.log(reg.test(1));			//输出结果为:false
    console.log(reg.test('A'));		//输出结果为:false
    
    • 字符组合
    var reg = /^[a-zA-Z0-9_-]$/
    
    • [^]方括号内部的取反符 ^
    var reg = /^[^a-zA-Z0-9_-]$/
    

    4.量词符

    • 量词符用来设定某个模式出现的次数。
    量词说明
    *重复零次或更多次
    +重复一次或更多次
    ?重复零次或一次
    {n}重复n次
    {n,}重复n次或更多次
    {n,m}重复n到m次,注意逗号左右不要留有空格
    • *举例:
    var reg = /^a*$/;
    console.log(reg.test(''));		//输出结果为:true
    console.log(reg.test('a'));		//输出结果为:true
    console.log(reg.test('aaa'));	//输出结果为:true
    console.log(reg.test('b'));		//输出结果为:false
    

    5.括号总结

    (1)大括号:量词符,里面表示重复的次数。

    (2)中括号:字符集合,匹配方括号中的任意字符。

    (3)小括号:表示优先级。

    • 在线测试:https://c.runoob.com/

    6.预定义类

    • 预定义类指的是某些常见模式的简写方式。
    预定义说明
    \d匹配0-9之间的任一数字,相当于[0-9]
    \D匹配所有0-9以外的字符,相当于[ ^0-9]
    \w匹配任意的字母、数字和下划线,相当于[A-Za-z0-9_]
    \W除所有字母、数字和下划线以外的字符,相当于[ ^A-Za-z0-9_]
    \s匹配空格(包括换行符、制表符、空格符等),相当于[\t\r\n\v\f]
    \S匹配非空格的字符,相当于[ ^\t\r\n\v\f]

    7.补充

    • 或者符号为:|
    var reg = /^\d{3}-\d{8}|\d{4}-\d{7}$/;
    

    正则表达式中的替换

    1.replace替换

    • replace()方法可以实现替换字符串操作,用来替换的参数可以是一个字符串或是一个正则表达式。
    stringObject.replace(regexp/substr,replacement)
    

    (1)第一个参数:被替换的字符串或者正则表达式。

    (2)第二个参数:替换为的字符串。

    (3)返回值是一个替换完毕的新字符串。

    //第一个参数为字符串:
    var str = 'andy和red';
    var newStr1 = str.replace('andy','baby');
    console.log(newStr1);		//输出结果为:baby和red
    //第一个参数为正则表达式:
    var str = 'andy和red';
    var newStr2 = str.replace(/andy/,'baby');
    console.log(newStr2);		//输出结果为:baby和red
    

    2.正则表达式参数

    /表达式/[switch]
    
    • switch(也称为修饰符)按照什么样的模式来匹配。值如下:

      (1)g:全局匹配

      (2)i:忽略大小写

      (3)gi:全局匹配 + 忽略大小写

    • 应用举例:

    <body>
      <textarea name="" id="message"></textarea>
      <button>
        提交
      </button>
      <div>
      </div>
    </body>
    
    <script>
    	var text = document.querySelector('textarea');
      var btn = document.querySelector('button');
      var div = document.querySelector('div');
      btn.onclick = function(){
        div.innerHTML = text.value.replace(/神经|滚/g,'**');		//会把输入textarea的语句中所有“神经”和“滚”的字符替代为“**”;如果没有加g,并且用“|”连起来多个字符,则只会替换一次(不是每个的第一次都替换,而是全部的第一个出现被替换而言)
      }
    </script>
    

    微信公众号也会定期更新,觉得文章写得还可以的,可以加个关注!点个赞!谢谢!

    在这里插入图片描述

    展开全文
  • "中的内容,并且存入hashmap,用正则表达式做package com.company;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.regex.Matcher;import java.util...

    需求:

    提取"LR(:12970100:<5>)"字符串中"<>"中的内容,并且存入hashmap,用正则表达式做5>

    package com.company;

    import java.util.ArrayList;

    import java.util.HashMap;

    import java.util.List;

    import java.util.regex.Matcher;

    import java.util.regex.Pattern;

    public class Main {

    public static void main(String[] args) {

    // write your code here

    String line_1 = "L1(A:12970000:<97><5><5><5>)";5>5>5>97>

    String line_2 = "LR(:12970100:<5>)";5>

    Pattern p = Pattern.compile("");

    Matcher m = p.matcher(line_1);

    int size = 0;

    List> mList = new ArrayList<>();

    while (m.find()) {

    size++;

    System.out.println(m.group(1));

    HashMap map = new HashMap<>();

    String[] arr = m.group(1).split(":");

    map.put(arr[0], arr[1]);

    mList.add(map);

    }

    System.out.println("-------------------------------------------");

    for (int i = 0; i < size; i++) {

    System.out.println(mList.get(i));

    }

    }

    }

    运行结果:

    2d5fa9e863f4

    Paste_Image.png

    展开全文
  • 1.正则表达式到底是什么东西? 正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)是用于描述字符串规则的工具。换句话说,正则表达式就是记录文本规则的代码。 正则表达式语言由两种...

    1.正则表达式到底是什么东西?

    正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)是用于描述字符串规则的工具。换句话说,正则表达式就是记录文本规则的代码。

    正则表达式语言由两种基本字符类型组成原义(正常)文本字符元字符(metacharacter)。元字符使正则表达式具有处理能力。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符,可以用来规定其前导字符(即位于元字符前面的字符)在目标对象中的出现模式。

    在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard),也就是 * 和 ? 。如果你想查找某个目录下的所有的Word文档的话,你会搜索*.doc。在这里,*会被解释成任意的字符串。和通配符类似,正则表达式也是用来进行文本匹配的工具,只不过比起通配符,它能更精确地描述你的需求——当然,代价就是更复杂——比如你可以编写一个正则表达式,用来查找所有以0开头,后面跟着2-3个数字,然后是一个连字号“-”,最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

    2.常用正则表达式符号

    (1)常用的元字符
    \b 代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格,标点符号或者换行来分隔的,但是\b并不匹配这些单词分隔字符中的任何一个,它只匹配一个位置。
    . 匹配除了换行符以外的任意字符。
    \d 匹配一位数字(0,或1,或2,或……)。
    \s 匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等。
    \w 匹配字母或数字或下划线或汉字等。
    ^ 匹配字符串的开始。
    $ 匹配字符串的结束。有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项,^和$的意义就变成了匹配行的开始处和结束处。

    (2)常用的限定符
    * 代表数量——指定 * 前边的内容可以连续重复使用任意次以使整个表达式得到匹配。
    .* 连在一起就意味着任意数量的不包含换行的字符。
    + 是和 * 类似的元字符,不同的是: * 匹配重复任意次(可能是0次),而+则匹配重复1次或更多次。
    ? 重复零次或一次
    {n} 重复n次
    {n,} 重复n次或更多次
    {n,m} 重复n到m次
    [] 匹配没有预定义元字符的字符集合。
    例如:
    [0-9] 代表一位数字,与\d就是完全一致的;
    [a-z0-9A-Z_] 完全等同于\w(如果只考虑英文的话)。
    [.?!] 匹配标点符号( . 或 ? 或 ! )

    (3)常用的反义代码
    \W 匹配任意不是字母,数字,下划线,汉字的字符
    \S 匹配任意不是空白符的字符
    \D 匹配任意非数字的字符
    \B 匹配不是单词开头或结束的位置
    [^x] 匹配除了x以外的任意字符
    [^aeiou] 匹配除了aeiou这几个字母以外的任意字符

    (4)常用分组语法
    捕获:
    (exp) 匹配exp,并捕获文本到自动命名的组里
    (?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name’exp)
    (?:exp) 匹配exp,不捕获匹配的文本,也不给此分组分配组号
    零宽断言:
    (?=exp) 匹配exp前面的位置
    (?<=exp) 匹配exp后面的位置
    (?!exp) 匹配后面跟的不是exp的位置
    (?<!exp) 匹配前面不是exp的位置
    注释:
    (?#comment) 这种类型的分组不对正则表达式的处理产生任何影响,用于提供注释让人阅读

    (5)懒惰限定符
    *? 重复任意次,但尽可能少重复
    +? 重复1次或更多次,但尽可能少重复
    ?? 重复0次或1次,但尽可能少重复
    {n,m}? 重复n到m次,但尽可能少重复
    {n,}? 重复n次以上,但尽可能少重复

    3.正则表达式详细介绍

    字符转义
    如果你想查找元字符本身的话,比如查找 . ,或者 * ,是没办法直接指定它们的,因为它们会被解释成别的意思。这时你就得使用 \ 来取消这些字符的特殊意义。因此,应该使用 \. 和 \* 。当然,要查找 \ 本身,得用 \\。
    例如:china\.net 匹配 china.net,C:\\Windows匹配C:\Windows。

    分枝条件
    正则表达式里的分枝条件指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,匹配分枝条件时,将会从左到右地测试每个条件,如果满足了某个分枝的话,就不会去再管其它的条件了。具体方法是用 | 把不同的规则分隔开。

    我们来看一个复杂的表达式:\(?0\d{2}[) -]?\d{8}
    “(” 和 “)” 也是元字符,所以在这里需要使用转义。这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。我们对它进行一些分析吧:首先是一个转义字符 \( ,它能出现0次或1次(?),然后是一个0,后面跟着2个数字(\d{2}),然后是 ) 或 - 或空格中的一个,它出现1次或不出现(?),最后是8个数字(\d{8})。

    不幸的是,刚才那个表达式也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题,我们需要用到分枝条件。正则表达式里的分枝条件指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,具体方法是用|把不同的规则分隔开。听不明白?没关系,看例子:
    0\d{2}-\d{8}|0\d{3}-\d{7} 这个表达式能匹配两种以连字号分隔的电话号码:一种是三位区号,8位本地号(如010-12345678),一种是4位区号,7位本地号(0376-2233445)。

    (0\d{2})[- ]?\d{8}|0\d{2}[- ]?\d{8} 这个表达式匹配3位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。

    \d{5}-\d{4}|\d{5} 这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字,或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题:使用分枝条件时,要注意各个条件的顺序。如果你把它改成\d{5}|\d{5}-\d{4}的话,那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时,将会从左到右地测试每个条件,如果满足了某个分枝的话,就不会去再管其它的条件了。

    分组
    我们已经提到了怎么重复单个字符(直接在字符后面加上限定符就行了);但如果想要重复多个字符又该怎么办?你可以用小括号来指定子表达式(也叫做分组),然后你就可以指定这个子表达式的重复次数了,你也可以对子表达式进行其它一些操作。例如:
    (\d{1,3}.){3}\d{1,3} 是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配1到3位的数字,(\d{1,3}.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})。
    不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:(2[0-4]\d|25[0-5]|[01]?\d\d?).){3}(2[0-4]\d|25[0-5]|[01]?\d\d?
    (PS: IP地址中每个数字都不能大于255。IP 地址里的数字可以包含有前导 0 (leading zeroes),所以01.02.03.04 这样前面带有0的数字, 是正确的IP地址。)

    反义
    有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义。
    常用的反义正则表达式:
    \W 匹配任意不是字母,数字,下划线,汉字的字符
    \S 匹配任意不是空白符的字符
    \D 匹配任意非数字的字符
    \B 匹配不是单词开头或结束的位置
    [^x] 匹配除了x以外的任意字符
    [^aeiou] 匹配除了aeiou这几个字母以外的任意字符
    例子:\S+ 匹配不包含空白符的字符串。
    <a[^>]+> 匹配用尖括号括起来的以a开头的字符串。

    后向引用
    后向引用用于重复搜索前面某个分组匹配的文本。使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组的左括号为标志,第一个出现的分组的组号为1,第二个为2,以此类推。例如,\1代表分组1匹配的文本。

    请看一个较为复杂的示例:
    \b(\w+)\b\s+\1\b 可以用来匹配重复的单词,像go go, 或者kitty kitty。这个表达式首先是一个单词,也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b),这个单词会被捕获到编号为1的分组中,然后是1个或几个空白符(\s+),最后是分组1中捕获的内容,也就是前面匹配的那个单词(\1)。

    你也可以自己指定子表达式的组名。要指定一个子表达式的组名,请使用这样的语法:(?<Word>\w+)(或者把尖括号换成 ’ 也行:(?‘Word’\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容,你可以使用\k<Word>,所以上一个例子也可以写成这样:\b(?<Word>\w+)\b\s+\k<Word>\b。

    (?:exp) 不会改变正则表达式的处理方式,只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面,也不会拥有组号。你可以使用(?:exp)这样的语法来剥夺一个分组对组号分配的参与权。

    常用的捕获正则表达式 :
    (exp) 匹配exp,并捕获文本到自动命名的组里
    (?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name’exp)
    (?:exp) 匹配exp,不捕获匹配的文本,也不给此分组分配组号

    零宽断言
    零宽断言指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。
    它用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们像\b,^,$那样用于指定一个位置,这个位置应该满足一定的条件(即断言),因此被称为零宽断言。

    下面给出几个例子:
    (?=exp) 也叫零宽度正预测先行断言,它断言自身出现的位置的后面能匹配表达式exp。比如:
    \b\w+(?=ing\b),匹配以ing结尾的单词的前面部分(除了ing以外的部分),例如查找I’m singing while you’re dancing.时,它会匹配sing和danc。
    (?<=exp) 也叫零宽度正回顾后发断言,它断言自身出现的位置的前面能匹配表达式exp。比如:
    (?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分),例如在查找reading a book时,它匹配ading。
    (?<=\s)\d+(?=\s) 匹配以空白符间隔的数字(再次强调,不包括这些空白符)。

    常用的零宽断言正则表达式:
    (?=exp) 匹配exp前面的位置
    (?<=exp) 匹配exp后面的位置
    (?!exp) 匹配后面跟的不是exp的位置
    (?<!exp) 匹配前面不是exp的位置

    负向零宽断言
    前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现,但并不想去匹配它时怎么办?例如,如果我们想查找这样的单词–它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样:
    \b\w*q[^u]\w*\b 匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐,直接就观察出来了),你会发现,如果q出现在单词的结尾的话,像Iraq,Benq,这个表达式就会出错。这是因为[^u]总要匹配一个字符,所以如果q是单词的最后一个字符的话,后面的[^u]将会匹配q后面的单词分隔符(可能是空格,或者是句号或其它的什么),后面的\w*\b将会匹配下一个单词,于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题,因为它只匹配一个位置,并不消费任何字符。

    下面给出几个例子:
    (?!exp) 零宽度负预测先行断言,断言此位置的后面不能匹配表达式exp。例如:\d{3}(?!\d) 匹配三位数字,而且这三位数字的后面不能是数字;\b((?!abc)\w)+\b 匹配不包含连续字符串abc的单词。
    (?<!exp) 零宽度负回顾后发断言,断言此位置的前面不能匹配表达式exp。例如:(?<![a-z])\d{7} 匹配前面不是小写字母的七位数字。

    一个更复杂的例子:
    (?<=<(\w+)>).*(?=<\/\1>) 匹配不包含属性的简单HTML标签内里的内容。(?<=<(\w+)>)指定了这样的前缀:被尖括号括起来的单词(比如可能是<\b>),然后是 .* (任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/,它用到了前面提过的字符转义;\1则是一个反向引用,引用的正是捕获的第一组,前面的(\w+)匹配的内容,这样如果前缀实际上是<\b>的话,后缀就是</b>了。整个表达式匹配的是< b>和</b>之间的内容(再次提醒,不包括前缀和后缀本身)。

    注释
    (?#comment) 这种类型的分组不对正则表达式的处理产生任何影响,用于提供注释让人阅读
    小括号的另一种用途是通过语法(?#comment)来包含注释。例如:2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。

    贪婪与懒惰
    当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。以这个表达式为例:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。

    有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样 .*? 就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:

    a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab(第一到第三个字符)和ab(第四到第五个字符)。

    常用的懒惰正则表达式:
    *? 重复任意次,但尽可能少重复
    +? 重复1次或更多次,但尽可能少重复
    ?? 重复0次或1次,但尽可能少重复
    {n,m}? 重复n到m次,但尽可能少重复
    {n,}? 重复n次以上,但尽可能少重复

    本文部分引自:https://deerchao.net/tutorials/regex/regex.htm
    推荐一款在线的正则表达式调试工具:https://regex101.com/

    展开全文
  • 正则表达式括号括号括号问题 由于这是一个著名的编程问题,因此我们大多数人有可能在CS101课程或其他课程中解决了这个问题。 尽管如此,我仍然坚持在浏览下一部分之前,我们先浏览一下问题陈述。 ...

    正则表达式 圆括号 方括号


    圆括号问题

    由于这是一个著名的编程问题,因此我们大多数人有可能在CS101课程或其他课程中解决了这个问题。 尽管如此,我仍然坚持在浏览下一部分之前,我们先浏览一下问题陈述。

    假设我们有一个只能包含方括号[],括号()和大括号{}输入字符串 。 然后,当我们的输入字符串满足两个条件时,它被认为是平衡的:

    • LOFC( 最后打开的是第一个关闭的 )意味着最后打开的是第一个关闭的。
    • LOFC考虑到开括号和闭括号属于同一对,即(),[]和{}

    此外, 如果输入字符串为空,则可以说它是balance

    样本输入数据

    接下来,让我们看一些示例输入字符串,并找出它们是否平衡:

    [()[]{}]{} is balanced
    [][]() is balanced
    () is balanced
    ))(( is not balanced
    {) is not balanced

    偏见的头脑留有很小的空间

    是的,我知道我们中有些人已经创建了堆栈的心理图景来开始解决此问题。

    但是,这是您之前解决过的一件好事,或者您是第一次阅读此问题,并很快想到了基于堆栈的解决方案。 但是,我敦促您暂时释放空间 ,以免您的想法出现偏差。

    使用顶空的解决方案

    用正则表达式解决它的全部目的在于,如我们所见,编码更加直观 。 此外,就算法的时间复杂度而言,我绝对不是一个更好的方法!

    首先,让我们重新回顾上一部分示例输入列表中的第一个:

    [()[]{}]{}

    现在,让我们在尝试解决问题时尝试观察自己的想法 。 我们可以是一个天才,可以快速解决它,但是我们需要慢慢观察这个思考过程。 此外,我们应该牢记一切。 这意味着我们必须避免使用笔和纸。

    尽管我们不需要超过3分钟 ,但我们可以花尽可能多的时间来满意地完成此活动。

    除非我们花一些时间在这里,否则没有任何进一步的意义。 没有人会判断我们是否慢-越慢越好,但是我们必须全神贯注于这项活动以一次完成。

    并且,只要我们准备就绪,就尝试回答一些问题:

    • 我们一口气解决了吗?
    • 我们是否可以专注于字符串中的(),{}和[]之类的模式?
    • 发现平衡模式(),{},[]时我们做了什么?

    让我们为给我们一个宽敞的顶部空间以可视化地解决它的整个过程而努力。

    现在,每个人都可以以不同的方式想象到这一点。 现在,让我提出我如何形象化它。

    首先,我很快就能在较宽的方括号内发现(),[],{}的三种模式,以及在最右侧的{}模式。 但是,我必须提到,我实际上并没有看到包含三个平衡括号的更宽的括号。

    然后,一旦我发现了一些平衡的模式,我便试图通过忽略视线中已经发现的模式来集中精力。 结果,我可以看到[]的一种模式包含了较早观察到的模式。

    接下来,我知道没有更多的新模式可以识别了,如果我忽略所有这些模式,那么除了空字符串之外,我什么也没有。

    当然,在迈向下一步时,我必须更加集中精力。

    就像他们说的那样,一张图片值一千个字,因此我稍后尝试勾画此活动,以更好地描述整个过程:


    使用sed实现

    啊! 我知道。 我知道。 执行使我们很多人兴奋,

    我们,开发人员喜欢行动。 看到实际的代码使我们感到震撼。 是不是

    但是, sed
    真的吗? 不是Java,Python,Kotlin,Go,Haskell。 连C都没有?

    是的,sed,是的。 🙂

    sed 是用于模式匹配的出色工具 。 实际上,这是一种图灵完整的编程语言 。 所以,为什么不呢!

    无论如何,我们都遵循顶空方法,而sed将使我们很容易以代码形式形式化关于模式的思想:

    :combine
    s/\( \) //g
    s/ \{ \} //g
    s/ \[ \] //g
    t combine
    
    s/^$/balanced/p
    t
    s/.*/Unbalanced/p

    从字面上看,这就是我们所有的代码。 而且, 它适用于输入流,而不仅适用于单个string 。 这不是很好吗?

    尽管我喜欢这个简单的解决方案,但我也同意,如果您不熟悉sed,那么这些内容可能会让您有些不知所措。 所以,让我为您总结一下。

    因此, 我们的脚本使用了简单循环和使用regex进行替换的概念 。 对于替换,它使用s的s替换函数和全局标志g来在所有情况下应用效果:

    s/regex/ replacement /g

    此外,我们继续进行模式匹配和替换,直到找不到三种模式中的任何一种。 我们使用t函数test保持循环:

    tlabel 

    为此,我们之前使用 (label)函数 定义了称为 Combine 标签

    :label 

    我们必须注意,如果最后一次替换成功,则t函数将分支到标签,否则流程将逐行继续。

    一旦退出循环,对于平衡的情况我们将有一个空字符串,对于不平衡的情况我们将有一个非空字符串。

    结果,我们再次将s替换功能与print, p标志一起使用,以显示一条消息,指出“平衡”或“不平衡”。

    但是,等等,在倒数第二行,我们没有使用任何标签使用t函数来进行条件分支:

    t

    没有标签,测试功能将重新开始输入流中下一行的执行周期。 当脚本中的所有命令在当前循环中完成执行时,也会发生这种情况。

    现在,让我们进行一次信念飞跃,并使用一些示例输入字符串进行测试。

    我们的代码有效吗?

    首先,让我们看一下输入字符串:

    % nl input_parantheses.txt
         1 [()[]{}]{}
         2 [][]()
         3 ()
         4 ))((
         5 {)
         6 (()())
         7 ))
         8 ()
         9 )()(

    最后,让我们执行脚本并查看我们的工作成果:

    % sed -E -n -f balanced_parantheses.sed input_parantheses.txt | nl
         1 balanced
         2 balanced
         3 balanced
         4 Unbalanced
         5 Unbalanced
         6 balanced
         7 Unbalanced
         8 balanced
         9 Unbalanced

    叹! 我们可以看到输入的每一行的输出都符合预期的结果。

    结论

    在本教程中,我们依靠直觉和顶空来为圆括号的问题提供足够好的解决方案 。 另外,在sed中实现解决方案时,我们品尝了一些基本的正则表达式。

    参考资料

    翻译自: https://hackernoon.com/solving-balanced-parentheses-problem-using-regular-expressions-q82w3y4u

    正则表达式 圆括号 方括号

    展开全文
  • 正则表达式实例 一个字符串其实就是一个简单的正则表达式,例如 Hello World 正则表达式匹配 "Helljava 如何判断一个字符串符合正则表达式语法JAVA正则表达式获取大括号内容例: jdbc=jdbc:jtds:sql...
  • JS正则表达式完整版

    万次阅读 多人点赞 2018-07-17 13:14:13
    目录 引言 第一章 正则表达式字符匹配攻略 1 两种模糊匹配 2. 字符组 ...第二章 正则表达式位置匹配攻略 ...第三章 正则表达式括号的作用 1. 分组和分支结构 2. 引用分组 3. 反向引用 4. 非捕获分组 ...
  • 匹配对称的括号 正则表达式

    万次阅读 2010-05-27 10:26:00
    匹配对称的括号Matching Balanced Sets of Parentheses对称...函数的参数包含在函数名称之后的括号里,而这些参数本身又有可能包含嵌套的函数调用或是算式中的括号。我们先不考虑嵌套的括号,你或许会想到「/bfoo/([^])
  • ios 正则表达式去html标签[2021-01-27 12:53:55]简介:php正则表达式去掉html的方法:首先使用.../','',$_st系统运维正则表达式概述基础正则表达式扩展正则表达式正则表达式概述1. 正则表达式的定义正则表达式又称正...
  • 正则表达式-创建正则表达式

    千次阅读 2016-10-21 18:56:35
    正则表达式就是一个字符模式。和String对象类似,在JavaScript中正则表达式也是一个对象,它主要用于字符串的模式匹配。...正则表达式包含在两个斜杠之间的一个或多个字符,在后一个斜杠的后面,可以指定一个或多个选
  • 正则表达式一 基本正则表达式1.字符匹配1.匹配次数三级目录 写在前面:一直以来 对于正则表达式的使用都没有进行一个系统性的梳理学习,导致在工作中进行脚本编写时,总是会出现一些不符合自己认知的错误,最近抽空...
  • 正则表达式 - 示例简单表达式正则表达式的最简单形式是在搜索字符串中匹配其本身的单个普通字符。例如,单字符模式,如 A,不论出现在搜索字符串中的何处,它总是匹配字母 A。下面是一些单字符正则表达式模式的示例...
  • Python 通过 re 模块为正则表达式引擎提供一个接口,同时允许你将正则表达式编译成模式对象,并用它们来进行匹配。 注意: re 模块是使用 C 语言编写,所以效率比你用普通的字符串方法要高得多;将正则表达式进行...
  • 正则表达式可以用来搜索、编辑或处理文本。 正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。 正则表达式实例 一个字符串其实就是一个简单的正则表达式,例如 Hello World 正则表达式匹配 “Hello ...
  • 正则表达式及扩展正则表达式_REGEXP文本查找的需要:基本正则表达式:Basic REGEXP次数:锚定:grep :使用基本正则表达式定义的模式来过滤文本的命令:位置锚定分组后向引用扩展正则表达式:Extended REGEXPfgrep:...
  • 正则表达式将方括号视为特殊的元字符,因此方括号不参与匹配。元字符是在正则表达式中有特殊含义的字符,也是保留字符。[0-9]这种形式的正则表达式称作字符组,有时也叫字符集。 [012789]这个字符组只会匹配列出0、...
  • mysql 提供的模式匹配的其他类型是使用扩展正则表达式。 当你对这类模式进行匹配测试时,使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE,它们是同义词)。 扩展正则表达式的一些字符是: “.”匹配任何单个的...
  • Python的re模块,正则表达式 #导入re模块 import re 1、match方法的使用: result = re.match(正则表达式,待匹配的字符串) 正则表达式写法: 第一部分: 举例: >>> re.match(".","&and") #.匹配...
  • 正则表达式的基本概念正则表达式基本语法正则表达式常用函数通过学习正则表达式几个常用函数,可以根据需要对数据进行匹配筛选。1. 正则表达式简介在编写爬虫的过程中,我们需要解析网页的内容。那么作为文本解析...
  • 在日常开发工作中,无论你使用的语言是java、python、shell、golang还是C#。正则表达式是编程语言中几乎绕不...首先给大家介绍一下正则表达式使用的类,在java.util.regex 包中主要包括以下三个类:1.Pattern 类:p...
  • 正则表达式-正则表达式的元字符

    千次阅读 2016-10-21 18:57:57
    元字符是使用正则表达式不同于普通字符的地方,也是正则表达式能够发挥强大作用、具有强大表达能力的法宝。那么什么是元字符呢?元字符是一些在正则表达式中有特殊用途、不代表它本身字符意义的一组字符。利用元字符...
  • 正则表达式的概念正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式的语法...
  • 正则表达式分组 定义 在正则表达式中,以()建立正则表达式的内部分组,子组是正则表达式的一部分,可以作为内部整体操作对象。 备注:当我们的正则表达式中存在子组时,就不能用findall(),则要用search(). 作用 ①...
  • 1、正则表达式的优点正则表达式能够匹配只要你能描述出来的字符串,对于普通的文本中常用的一些关键词,如果想匹配某种模式很适合用而不是通过普通的contains这种是否含有等匹配。2、python正则表达式速查表3、...
  • 正则表达式有两类,分为基本正则表达式和扩展正则表达式,是使用命令egrep来使用扩展正则表达式,它与grep很多功能相同,仅在元字符上实现了些扩展扩展,在元字符的表示上与基本正则表达式略不同。 1.命令格式: ...
  • python正则表达式入门

    千次阅读 多人点赞 2021-07-04 17:23:43
    今天我们来学习python的正则表达式的部分,先说下为什么要学习这一部分呢,当然是因为正则表达式处理文本类型的数据实在是太方便了。为以后进入nlp领域打打基础! 先给大家推荐一个网站: 用于正则表达式验证. 大致就...
  • 在Linux Shell 编程中,我们常需要用到 正则表达式 进行 文件的匹配在本篇文章中,我们对Linux shell 中的正则表达式 做一个总结,方便之后的shell 编写。参考文章:shell编程之正则表达式...
  • 普通字符包括大小写字母、数字、标点符号及一些其他符号 元字符则是指那些在正则表达式中具有特殊意义的专用字符,可以用来规定其前导字符(即位于元字符前面的字符)在目标对象中的出现模式 1.2 正则表达式用途 ...
  • 正则表达式标志: g标志:全局搜索。 m标志:多行搜索。 正则表达式的方法 match方法:在字符串中执行查找匹配的String方法,它返回一个数组,在未匹配到时会返回 null。 正则表达式中的特殊字符: ^字符:...
  • 不少编程高手说计算机领域称得上伟大的发明技术不多,但正则表达式绝对算一个。我姑且相信一回,来准备精通一下。 第一章正则表达式介绍  正则表达式相当于一个我们要找的文本内容抽象集合模型,就是说我先建...
  • 由于工作中用到正则表达式不多,一直没有好好学习正则表达式。在网上找到了原版的精通正则表达式(第三版)电子版,抽时间详细学习,下面对最近学到的做个总结。 最近在进行安全检查漏洞修补,在做XSS攻击过滤器时,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,372
精华内容 40,948
关键字:

包含括号正则表达式