精华内容
下载资源
问答
  • 一个正则表达式要如何书写才能同时匹配这两个数字呢?简单的字符表达式当然无法完成了,这个时候我们就可以定义一个字符集合(字符类)来进行匹配。这就是分组匹配
  • 本文给大家详细介绍了JavaScript正则表达式的分组匹配的概念以及具体的使用方法并附上了相关示例,有需要的小伙伴可以参考下。
  • js 正则 分组

    2019-11-24 21:21:10
    1. 分组: 用括号表示一个整体,如(ab)+,表示""两个字符连续出现多次; var regex = /(ab)+/g; var string = "ababa abbb ababab"; console.log( string.match(regex) );...使用一个正则匹配日期格式为yyyy-...

    1. 分组:

    用括号表示一个整体,如(ab)+,表示""两个字符连续出现多次;

    var regex = /(ab)+/g;
    var string = "ababa abbb ababab";
    console.log( string.match(regex) ); 
    // 结果为: ["abab", "ab", "ababab"]

     2. 引用分组:

    使用一个正则来匹配日期格式为yyyy-mm-dd 的日期:

    var regexp = /\d{4}-\d{2}-\d{2}/

     我们可以使用构造函数的全局属性$1至$9来获取

    var regex = /(\d{4})-(\d{2})-(\d{2})/;
    var string = "2019-11-24";
    
    regex.test(string); //先正则匹配一次,可以是test()、exec()、以及String.match的正则方式
    console.log(RegExp.$1); // 2019
    console.log(RegExp.$2); // 11
    console.log(RegExp.$3); // 24

    3.反向引用

    正则本身里可以引用分组,但只能引用之前出现的分组,即反向引用。

    如:写一个正则支持匹配如下三种格式:

    var str1 = '2019-11-24';
    vat str2 = '2019/11/24';
    var str3 = '2019.11.24';

    最容易写的正则是: 

    var regexp = /\d{4}(\.|-|\/)\d{2}(\.|-|\/)\d{2}/;
    var str1 = '2019-11-24';
    var str2 = '2019/11/24';
    var str3 = '2019.11.24';
    var str4 = '2019-11/24';
    console.log(regexp.test(str1)); // true
    console.log(regexp.test(str2)); // true
    console.log(regexp.test(str3)); // true
    console.log(regexp.test(str4)); // true

    注意第四个,我们如果想要分隔符前后一致怎么办,此时就需要利用反向引用了。

    var regexp = /\d{4}(\.|-|\/)\d{2}\1\d{2}/;
    var str1 = '2019-11-24';
    var str2 = '2019/11/24';
    var str3 = '2019.11.24';
    var str4 = '2019-11/24';
    console.log(regexp.test(str1)); // true
    console.log(regexp.test(str2)); // true
    console.log(regexp.test(str3)); // true
    console.log(regexp.test(str4)); // false

    我们可以利用 https://regexper.com工具,该够让正则表达式字符串以 Railroad 形式图形化,便于咱们阅读及理解。

     

    4.非捕获性分组

    如果只想要括号最原始的功能,但不会引用它,即,既不在API里引用,也不在正则里反向引用。此时可以使用非捕获分组(?:p)

     如字符串123abcd456,先看捕获性分组匹配会得到什么结果:

    var str = '123abc456';
    var regexp = /([a-z]+)(\d+)/;
    console.log(regexp.exec(str)); 
    // ["abc456", "abc", "456", index: 3, input: "123abc456", groups: undefined]
    

    发现子串也获取到了,这并不是我们想要的结果;

    再看下非捕获性分组:

    var str = '123abc456';
    var regexp = /(?:[a-z]+)(?:\d+)/;
    console.log(regexp.exec(str)); 
    // ["abc456", index: 3, input: "123abc456", groups: undefined]

    下面我们介绍下前瞻:(?=)和(?!)

    前瞻分为正向前瞻和反(负)向前瞻,正向前瞻(?=表达式)表示后面要有什么,反向前瞻(?!表达式)表示后面不能有什么。

    前瞻分组会作为匹配校验,但不出现在匹配结果字符里面,而且不作为子匹配返回。

    正向前瞻匹配一批图片格式:

    // 匹配.jpg后缀文件名
    var str = '123.jpg,456.gif,abc.jpg';
    var regexp = /\w+(?=\.jpg)/; // 正向前瞻匹配
    console.log(str.match(regexp)); // ["123", "abc"]

     处理数字的千位分隔符:

    如把"123456789"处理为"123,456,789"

    匹配的位置不能是开头,可以使用(?!^)

    var expreg = /(?!^)(?=(\d{3})+$)/g;
    '123456789'.replace(expreg,','); // "123,456,789"

     

     反向前瞻匹配一批字母加数字

    // 反向前瞻,匹配3个及以上的a,且后面不能有000的字符
    var str = 'aaa000 aaa111 aaaaaa222';
    var regexp = /a{3,}(?!000)/g;
    console.log(str.match(regexp)); // ["aaa", "aaaaaa"]

     es6中新增了正向后顾(?<表达式)和反(负)向后顾(?<!表达式),正向后顾(?<=表达式)表示前面要有什么,反向后顾(?<!表达式)表示前面不能有什么。

    'abcd'.replace(/(?<=abc)\w+/, '222') // abc222 表示前面需要有abc
    'abcd'.replace(/(?!=abc)\w+/, '222') // 222 前面不能有abc
    

    参考资料: JS正则表达式完整教程----分组

    JavaScript正则表达式分组模式:捕获性分组与非捕获性分组及前瞻后顾(断言)

     

    展开全文
  • 语法 元字符 (pattern) 作用用于反复匹配分组 属性 $1~$9 如果它 (们)存在用于得到对应分组匹配到的子串 \1 或 $1 用于匹配第一个分组中的内容 \2 或 $2 用于匹配第一个分组中的内容 . \9 或 $9 用于匹配第一个...
  • 今天别人问了个正则问题把我问住了,匹配半天没匹配出来,最终到处找资料搞定了,因为js正则匹配和其他语言有些区别,还有分组方面有些坑,特此记录下 js正则常用捕获符 必须先弄懂这个,基础就不说了,...

    前言

    • 今天别人问了个正则问题把我问住了,匹配半天没匹配出来,最终到处找资料搞定了,因为js的正则匹配和其他语言有些区别,还有分组方面有些坑,特此记录下

    js正则常用捕获符

    • 必须先弄懂这个,基础就不说了,里面还有些坑。
    • 小括号就是分组,分组里面有这样几种:
      (?=) positive lookahead 正向前瞻型捕获
      (?!) negative lookahead 负向前瞻型捕获
      (?<=) positive lookbehind 正向后顾型捕获
      (?<!) negative lookbehind 负向后顾型捕获
      (?:)非捕获分组
    • 只要使用上面的那几种模式,那么js返回给你的是不包括这个括号里的东西,这个有个特别大的好处,因为js使用正则分组有个坑,就是在全局匹配情况下分组,最后使用RegExp.$1只能出来最后一个匹配的分组,不能把所有匹配到的第一个分组拿出来。我百度了半天没发现全局拿所有分组的办法,如果有人知道怎么做可以留言给我。我百度到最好的解决方法除了这个就是利用lastIndex自己写循环匹配。
    • 于是因为js正则有这个捕获问题,所以上面的模式就变得特别常用。特别是在对全局匹配的情况下。

    起组名

    • 一般情况下都是不需要起名,用默认的$1,$2。python里面起名用?P<xxx>,js里起名用?<xxx>,js引用分组使用\k<组名>,默认分组使用\数字

    常用符号

    • \w 匹配字母或数字或下划线或汉字。与([0-9a-zA-Z_])等价。

    • \s 匹配任意的空白符

    • \d 匹配数字

    • \b 匹配单词的开始或结束

    • 点(.)表示匹配出换行符以外的任意一个字符串

    • 星号(*)表示匹配前面一个字符串0次或多次

    常见匹配需求

    一、匹配对象前后有固定字符串

    • 我们拉取了后台数据,是个嵌套好多层的json,但是我就想要所有元素的一个字段,并且提取出来,不使用循环,如果用循环太墨迹了,因为有好几层嵌套。比如:
    {"departmentId":1,
    "departmentName":"zzz",
    	"child":[{"departmentId":2,
    				"departmentName":"测试部门",
    				"child":[{"departmentId":5,
    						"departmentName":"试试"}
    						]},
    			{"departmentId":3,
    			"departmentName":"威风威风",
    			"child":[{"departmentId":6,"departmentName":"试试44"}]
    			},
    			{"departmentId":4,"departmentName":"测试部门2"}
    	]
    }
    
    • 需求:我们要把所有层级的departmentName拿出来
    • 思路:前面有个固定字符,后面固定是个引号,由于上面说的js分组无法取全局,所以借助捕获符直接提取目标。格式就是(?<=前面的字符串)(中间的内容)(?=后面的字符串)。这个分组就是前面说的前瞻后顾捕获。
    let reg = /(?<="departmentName"\:")(.*?)(?=")/g
    console.log(str.match(reg))
    

    [ ‘zzzz’, ‘测试部门’, ‘试试’, ‘威风威风’, ‘试试44’, ‘测试部门2’ ]

    • 代码里中间.*?就是懒惰匹配,就是尽可能短的匹配到中间字符,否则用.*结果就会一直匹配到最后一个部门。

    二、匹配页面元素

    • 很多时候,会提取页面标签正则判断。页面标签有个特点,就是会有个相同的闭合标签。
    • 比如:
    let str =`"<html><h1>www.yehuozhili.cn</h1></html><html><h1>www.yehuozhili.cn</h1></html>"`
    
    • 我们想按html分成2组
    let reg = /\<(\w*)\>.*?\<\/\1\>/g
    console.log(str.match(reg))
    //输出[
    //  '<html><h1>www.yehuozhili.cn</h1></html>',
    //  '<html><h1>www.yehuozhili.cn</h1></html>'
    //]
    
    • 其中\w表示任意英文,加个*表示多个,这个\1就表示默认的第一个分组了,就是第一个标签里提取的英文,这样可以保证左边是什么标签右边闭合是什么标签。
    • 如果想匹配h1标签呢?我们把\w*换成h1即可。
    let reg2 = /\<(\h1)\>.*?\<\/\1\>/g
    console.log(str.match(reg2))
    //输出 [ '<h1>www.yehuozhili.cn</h1>', '<h1>www.yehuozhili.cn</h1>' ]
    
    • 那么我想要标签里内容怎么做?如果是非全局匹配,那比较简单,如果全局匹配,就有点复杂。
    • 我们可以放弃原有的标签分组,直接写死,然后利用分组捕获提取。
    let reg2 = /(?<=\<\h1\>).*?(?=\<\/h1\>)/g
    console.log(str.match(reg2))
    //输出  [ 'www.yehuozhili.cn', 'www.yehuozhili.cn' ]
    

    三、路由匹配

    • 路由匹配有个特点,比如/user ,如果是精准匹配,那么/user/或者/user都是可以通的。但是/user/xxx是不能通的,/usersxxsd也不能通
    • 思路:前面没啥说的,主要是后面,可能有/,如果有/后面不能有东西,如果没/必须精准匹配字。所以使用括号分组但不包括,这个组可能有,可能没有就是问号,最终都是直接结束,所以$。如果有/,那么里面必须结尾没东西,用前瞻捕获来看。
    let str =`/user`
    let reg = /^\/user(?:\/(?=$))?$/g
    console.log(str.match(reg))
    
    • 这里介绍个生成路由的正则库path-to-regexp,使用它就可以生成路由正则,和上面那个一样。
    let pathToRegexp=require('path-to-regexp')
    let regexp = pathToRegexp('/user',[],{end:true});
    console.log(regexp)
    
    • 再介绍个正则查看网站。可以很清楚看见正则效果是什么样的。我实验了下,好像不支持js设置分组名。?P的python设置分组名也认不得。
    展开全文
  • 主要介绍了详解JavaScript正则表达式之分组匹配及反向引用 的相关资料,需要的朋友可以参考下
  • Javascript正则分组命名

    2019-09-23 22:32:38
    Javascript正则分组不支持命名,只好自己搞了一个。先把命名存入数组,然后匹配。 唉~~~有更好的解决方案么? 代码: var route = '/{controller}/{action}/{id}', url = '/home/index/2'; groupRE...

    Javascript的正则分组不支持命名,只好自己搞了一个。先把命名存入数组,然后匹配。

    唉~~~有更好的解决方案么?

    image

    代码:

    var route = '/{controller}/{action}/{id}',
        url = '/home/index/2';
    
    groupRE(route, url); // ==> {controller:'home', action:'index', id:'2'}
    
    /*
    * @re: string, e.g.: '/{controller}/{action}/{id}'
    * @s: string to match, e.g.: 'home/index/2'
    * @return: dict, e.g.: {controller:'home', action:'index', id:'2'}
    */
    function groupRE(re, s){
        var names = [], result = {}, cursor = 0;
        re = re.replace(/\{([^}]+)\}/g, function(m, g1){
            names.push(g1);
            return '(.+)';
        });
        re = new RegExp(re);
        var tmp = re.exec(s);
    	if(tmp){
    		for(var i=1; i<tmp.length; i++){
    			if(names[i-1]){
    				result[ names[i-1] ] = tmp[i];
    			}
    		}
    	}
        return result;
    }
    

    转载于:https://www.cnblogs.com/QLeelulu/archive/2011/03/16/1986158.html

    展开全文
  • 原文地址:JS正则表达式的分组匹配 什么是分组 通俗来说,我理解的分组就是在正则表达式中用()包起来的内容代表了一个分组,像这样的: var reg = /(\d{2})/ reg.test('12'); //true 这里reg中的(/d{2})就...

    原文地址: JS正则表达式的分组匹配

    什么是分组

    通俗来说,我理解的分组就是在正则表达式中用()包起来的内容代表了一个分组,像这样的:

    var reg = /(\d{2})/
    reg.test('12');  //true

    这里reg中的(/d{2})就表示一个分组,匹配两位数字

    分组内容的的形式

    一个分组中可以像上面这样有一个具体的表达式,这样可以优雅地表达一个重复的字符串

    /hahaha/
    /(ha){3}/

    这两个表达式是等效的,但有了分组之后可以更急简洁。

    体格分组中还可以有多个候选表达式,例如

    var reg = /I come from (hunan|hubei|zhejiang)/;
    reg.test('I come from hunan');   //true
    reg.test('I come from hubei'); //true

    也就是说在这个分组中,通过|隔开的几个候选表达式是并列的关系,所以可以把这个|理解为或的意思

    分组的分类

    分组有四种类型

    • 捕获型 ()
    • 非捕获型 (?:)
    • 正向前瞻型 (?=)
    • 反向前瞻型 (?!)
      我们使用的比较多的都是捕获型分组,只有这种分组才会暂存匹配到的串

    分组的应用

    分组在正则中还算使用的比较广泛的,我们常用的是捕获型分组

    • 捕获与引用
      • 被正则表达式捕获(匹配)到的字符串会被暂存起来,其中,由分组捕获到的字符串会从1开始编号,于是我们可以引用这些字符串:
      var reg = /(\d{4})-(\d{2})-(\d{2})/;
      var dateStr = '2018-04-18';
      reg.test(dateStr);  //true RegExp.$1 //2018 RegExp.$2 //04 RegExp.$3 //18
    • 结合replace方法做字符串自定义替换
      • String.prototype.replace方法的传参中可以直接引用被捕获的串,比如我们想开发中常见的日期格式替换,例如后台给你返回了一个2018/04/18,让你用正则替换为2018-04-18,就可以利用分组
      var dateStr = '2018/04/18';
      var reg = /(\d{4})\/(\d{2})\/(\d{2})/;
      dateStr = dateStr.replace(reg, '$1-$2-$3') //"2018-04-18"
      不过这里需要注意的是/是需要用\转义的
    • 反向引用
      • 正则表达式里也能进行引用,这称为反向引用:
      var reg = /(\w{3}) is \1/
      reg.test('kid is kid') // true
      reg.test('dik is dik') // true reg.test('kid is dik') // false reg.test('dik is kid') // false
      • 需要注意的是,如果引用了越界或者不存在的编号的话,就被被解析为普通的表达式
      var reg = /(\w{3}) is \6/;
      reg.test( 'kid is kid' ); // false
      reg.test( 'kid is \6' ); // true
    • 非捕获型分组
      • 有的时候只是为了分组并不需要捕获的情况下就可以使用非捕获型分组,例如
      var reg = /(?:\d{4})-(\d{2})-(\d{2})/
      var date = '2012-12-21'
      reg.test(date)
      RegExp.$1 // 12 RegExp.$2 // 21
    • 正向与反向前瞻型分组
      • 正向前瞻型分组:你站在原地往前看,如果前方是指定的东西就返回true,否则为false
      var reg = /kid is a (?=doubi)/
      reg.test('kid is a doubi') // true
      reg.test('kid is a shabi') // false
      • 反向前瞻型分组:你站在原地往前看,如果前方不是指定的东西则返回true,如果是则返回false
      var reg = /kid is a (?!doubi)/
      reg.test('kid is a doubi') // false
      reg.test('kid is a shabi') // true
    • 既然前瞻型分组和非捕获型分组都不会捕获,那他们有什么区别呢?先看例子:
    var reg, str = "kid is a doubi";
    reg = /(kid is a (?:doubi))/
    reg.test(str) RegExp.$1 // kid is a doubi reg = /(kid is a (?=doubi))/ reg.test(str) RegExp.$1 // kis is a

    也就是说非捕获型分组匹配到的字符串任然会被外层分组匹配到,而前瞻型不会,所以如果你希望在外层分组中不匹配里面分组的值的话就可以使用前瞻型分组了。

    转载于:https://www.cnblogs.com/liujinyu/p/11102977.html

    展开全文
  • JavaScript使用正则表达式获取全部分组内容的方法示例发布时间:2020-08-28 10:10:57来源:脚本之家阅读:115作者:ISaiSai... 需要循环DEMO示例:(如下代码将输出 8 , 9,两个匹配到的分组内容)JS正则demovar r ...
  • 本文主要讲解javascript正则表达式中的分组匹配与前瞻匹配的,需要对正则的有基本认识,本人一直对两种匹配模棱不清。所以在这里总结一下,如有不对,还望大神指点。 1.分组匹配:  1.1捕获性分组匹配 ()  2.2...
  • js正则里的分组匹配

    千次阅读 2019-02-25 12:08:55
    参考博文 ...var str = 'kid is kid' var reg = /(\w{3}) is \1/ reg.test(str) == true 这里的正则表达式里的'\1'相当于前面的 (\w{3}) =&gt;即一个分组;...表示匹配的第一个分组; var str = 'aaaab...
  • 以往我们只是习惯于通过数组下标来访问正则匹配到的分组,但分组达到4、5个时,标识起来就会非常麻烦。V8早已实现了正则命名分组提案,只是我们很少使用,本文将介绍JS正则命名分组
  • js正则,匹配字符串中第一个字符

    千次阅读 2019-03-01 10:56:34
    匹配第一个字符的正则表达式 :^. 注意:尖号后面有一个点,尖号代表行首,这个点代表除换行回车符外的任意字符。 js代码如下:
  • V8早已实现了正则命名分组提案,只是我们很少使用,本文将介绍JS正则命名分组。 以往的做法 假设要使用正则匹配一个日期的年月日,以往我们会这样做: const RE_DATE = /(\d{4})-(\d{2})-(\d{2})/; ...
  • 1、js截取两个字符串之间的内容: var str = "aaabbbcccdddeeefff"; str = str.match(/aaa(\S*)fff/)[1]; alert(str);//结果bbbcccdddeee 2、js截取某个字符串前面的内容: var str = "aaabbbcccdddeeefff"; tr ...
  • 语法:正则表达式中使用() 查找 代码: <script> //1、定义字符串对象,将来从页面获取,爬虫可以使用 var str = '<div>我是{{name}}</div>'; //2、定义正则,大写和小写字母,+ 等价于 ...
  • 本文主要讲解javascript正则表达式中的分组匹配与前瞻匹配的,需要对正则的有基本认识,本人一直对两种匹配模棱不清。所以在这里总结一下,如有不对,还望大神指点。 1.分组匹配: 1.1捕获性分组匹配 () 2.2非...
  • 正则表达式分组:如果想匹配3个数字,正则表达式可以用如下写法:\d{3}以上代码使用重复量词可以匹配3位数字。但是在实际应用中,往往需要重复多个字符,例如我想重复ab两个字符,使用以下代码就不合适了,代码如下:ab...
  • 正则表达式引入分组符“()”概念。其语法为“(pattern)”,即将“pattern”部分组合成一个可统一操作的组合项或字匹配。简单来讲就是用括号括起来一些字符、字符类或量词等,每个捕获的字匹配项按照其出现顺序...
  • js正则表达式分组

    2019-08-02 14:26:36
    1. 正则基础 2. 正则表达式中 分组理解与实例

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,895
精华内容 7,558
关键字:

js正则分组匹配