精华内容
下载资源
问答
  • 2022-04-15 09:50:23
    affected_entity := '受影响实体</span><span class="ant-table-column-sorter"></span></div></span></th></tr></thead><tbody class="ant-table-tbody"><tr data-row-key="0" class="ant-table-row ant-table-row-level-0"><td class="ant-table-row-cell-break-word" style="text-align:center;">1</td><td>CPE:/a:vim:vim:-:::</td></tr><tr data-row-key="1" class="ant-table-row ant-table-row-level-0"><td class="ant-table-row-cell-break-word" style="text-align:center;">2</td><td>CPE:/a:vim:vim:5.6:::</td></tr><tr data-row-key="2" class="ant-table-row ant-table-row-level-0"><td class="ant-table-row-cell-break-word" style="text-align:center;">3</td><td>CPE:/a:vim:vim:6.1:::</td></tr><tr data-row-key="3" class="ant-table-row ant-table-row-level-0"><td class="ant-table-row-cell-break-word" style="text-align:center;">4</td><td>CPE:/a:vim:vim:6.3:::</td></tr><tr data-row-key="4" class="ant-table-row ant-table-row-level-0"><td class="ant-table-row-cell-break-word" style="text-align:center;">5</td><td>CPE:/a:vim:vim:6.4:::</td></tr></tbody></table></div></div></div></div></div></div>'
    
    //这个只能匹配到一个
    compileRegex := regexp.MustCompile("</td><td>(.*?)</td></tr>")
    matchArr := compileRegex.FindStringSubmatch(affected_entity,-1)
    //这个可以匹配到所有
    compileRegex := regexp.MustCompile("</td><td>(.*?)</td></tr>")
    matchArr := compileRegex.FindAllString(affected_entity,-1)

    正则匹配测试界面

    Regex正则表达式在线测试、生成、解析工具 - GoRegex.cn

    更多相关内容
  • 标准的SQL模式匹配 SQL的模式匹配允许你使用“_”匹配任何单个字符,而“%”匹配任意数目字符(包括零个字符)。在 MySQL中,SQL的模式缺省是忽略大小写的。下面显示一些例子。注意在你使用SQL模式时,你不能使用=或!=...
  • 在labview中使用正则匹配模式很简单,难的就是使用正则表达式。很多人都搞不明白,查了很资料还是不太明白。实际上就是一些类似通配符在作怪和其他语言也差不多。附件带上了,可以研究研究,构造正则表达式的方法...
  • 在很文本编辑器里,正则表达式通常被用来检索、替换那些符合某个模式的文本。 写出匹配SQL语句中的所有表名,备忘记录 折磨了好久,正则表达式如下: 代码如下: \*\s+from\s+[\w\[\]]*\.?[\w\[\]]*\.?\[?(\b\w+...
  • 在JavaScript代码中使用正则表达式进行模式匹配经常会用到String对象和RegExp对象的一些方法,例如replace、match、search等方法,以下是对一些方法使用的总结。 String对象中支持正则表达式有4种方法,分别是:...
  • g修饰符用语规定正则表达式执行全局匹配,也就是在找到第一个匹配之后仍然会继续查找
  • 当我们用正则表达式去匹配一个标签的首尾的时候,比如匹配 <h1>hello world</h1> 中的 h1 的开始和闭合标签 可能很多人会这样写 /<.*h1>/g 但是这样真的可以吗? 因为 * 匹配符是匹配前面一个字符的零到个,...
  • javascript中正则匹配多个条件, 常用正则匹配正则表达式常用方法实现 准备工作 1, 汉字和unicode码的在线转换网址 http://tool.chinaz.com/tools/unicode.aspx 2, 正则在线生成地址 ...

    javascript中正则匹配多个条件, 常用正则匹配


    注意: 本篇文章是根据在下日常编码过程中逐渐丰富的, 越往后看, 收获越丰富, 收藏起来以后随时回顾

    准备工作
    	1, 汉字和unicode码的在线转换网址
    		http://tool.chinaz.com/tools/unicode.aspx
    	2, 正则在线生成地址
    		http://tools.jb51.net/regex/create_reg
    

    正则表达式常用方法

    截图来自:: https://www.w3school.com.cn/jsref/jsref_obj_regexp.asp
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    实现

    目标: 把 “2021年10月29日 12:43:46” 中, ‘年’和’月’替换为’-’, '日’替换为 ’ ’
    1, 常用替换方法实现

    let str= "2021年10月29日 12:43:46";
    str = str.replace("年","-")
    str = str.replace("月","-")
    str = str.replace("日","")
    console.log(str)// 2021-10-29 12:43:46
    

    2, 替换为 js正则 + unicode编码 实现

    let str= "2021年10月29日 12:43:46";
    str = str.replace(/[\u5e74]/g,"-")
    str = str.replace(/[\u6708]/g,"-")
    str = str.replace(/[\u65e5]/g,"")
    console.log(str)// 2021-10-29 12:43:46
    

    3, 简略写法, 一行搞定

    //  第一种写法
    let str= "2021年10月29日 12:43:46";
    str = str.replace(/[\u5e74]|[\u6708]/g, "-").replace(/[\u65e5]/g, "")
    //  第二种写法
    "2021年10月29日 12:43:46".replace(/[\u5e74]|[\u6708]/g, "-").replace(/[\u65e5]/g, "")
    console.log(str)// 2021-10-29 12:43:46
    // 第三种写法
    str = '2021年11月12日';
    str = str.replace(/[\u5e74\u6708\u65e5]/g,function(a){
        switch(a){
        case '年':
            return '-';
        case '月':
            return '-';
        case '日':
            return '';
        }
    });
    console.log(str);// 2021-11-12
    // 感觉还有更高级更牛叉的写法, 我找了半天没找出来, 希望大家有更高级写法的留言, 我会及时更新让大家少走弯路
    

    其他的常用正则匹配

    // 匹配国内手机号
    /0?(13|14|15|18)[0-9]{9}/.test('13233333333')
    
    // 匹配国内电话号
    /[0-9-()()]{7,18}/.test('4908595')
    
    // 匹配email
    /\w[-\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\.)+[A-Za-z]{2,14}/.test('21111111111@qq.com')
    
    // 匹配日期
    /\d{4}(\-|\/|.)\d{1,2}\1\d{1,2}/.test('2011-11-11')
    
    // 匹配邮政编码
    /\d{6}/.test('100000')
    
    // 匹配身份证号
    /\d{17}[\d|x]|\d{15}/.test('14152320111111503X')
    
    // 是否存在中文字符
    /[\u4e00-\u9fa5]/.test('文字文字')
    
    // 是否所有文字全是中文字符
    /^[\u4e00-\u9fa5]+$/i.test("中文中文")
    
    /* 验证数字:*/ ^[0-9]*$ 
    /* 验证n位的数字:*/ ^\d{n}$ 
    /* 验证至少n位数字:*/ ^\d{n,}$ 
    /* 验证m*/ -n位的数字:^\d{m,n}$ 
    /* 验证零和非零开头的数字:*/ ^(0|[1-9][0-9]*)$ 
    /* 验证有两位小数的正实数:*/ ^[0-9]+(.[0-9]{2})?$ 
    /* 验证有1*/ -3位小数的正实数:^[0-9]+(.[0-9]{1,3})?$ 
    /* 验证非零的正整数:*/ ^\+?[1-9][0-9]*$ 
    /* 验证非零的负整数:*/ ^\-[1-9][0-9]*$ 
    /* 验证非负整数(正整数*/  + 0^\d+$ 
    /* 验证非正整数(负整数*/  + 0^((-\d+)|(0+))$ 
    /* 验证长度为3的字符:*/ ^.{3}$ 
    /* 验证由26个英文字母组成的字符串:*/ ^[A-Za-z]+$ 
    /* 验证由26个大写英文字母组成的字符串:*/ ^[A-Z]+$ 
    /* 验证由26个小写英文字母组成的字符串:*/ ^[a-z]+$ 
    /* 验证由数字和26个英文字母组成的字符串:*/ ^[A-Za-z0-9]+$ 
    /* 验证由数字、26个英文字母或者下划线组成的字符串:*/ ^\w+$ 
    /* 验证用户密码*/ :^[a-zA-Z]\w{5,17}$ 正确格式为:以字母开头,长度在6-18之间,只能包含字符、数字和下划线。 
    /* 验证是否含有*/  ^%&',;=?$\" 等字符:[^%&',;=?$\x22]+ 
    /* 验证汉字:*/ ^[\u4e00-\u9fa5],{0,}$ 
    /* 验证身份证号(15位或18位数字):*/ ^\d{15}|\d{}18$ 
    /* 验证一年的12个月:*/ ^(0?[1-9]|1[0-2])$ 正确格式为:“01-09”和“1”“12/* 验证一个月的31天:*/ ^((0?[1-9])|((1|2)[0-9])|30|31)$ 正确格式为:0109131/* 整数:*/ ^-?\d+$ 
    /* 非负浮点数(正浮点数*/  + 0):^\d+(\.\d+)?$ 
    /* 正浮点数*/  ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$ 
    /* 非正浮点数(负浮点数*/  + 0^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 
    /* 负浮点数*/  ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$ 
    /* 浮点数*/  ^(-?\d+)(\.\d+)?$
    

    详解

    1, 正则方法

    	// ①, 替换 replace 
    		// 把字符串 '123' 中的 '1' 替换为 '2'
    			'123'.replace(/1/,"2");// '223'
    		// 多个替换 把字符串 '123' 中的 '1' 替换为 '2', '3' 替换为 '4'
    			123'.replace(/1/,"2").replace(/3/,"4");// '224'
    	// ②, 判断 test
    		// 第一位是否数字
    			/[0-9]/.test('23')  或者  /^[0-9]/.test('23')
    		// 结尾是否数字
    			/[0-9]$/.test('23')
    		// 整体是否数字
    			/^[0-9]+$/.test('23')// 中间 '+' 表示至少有一位数字
    	// ③, 查找 match
    		// 把字符串中 <b>单个数字</b> 找出来并分割成数组
    		'1abcd12----123'.match(/[1-9]/g)// ['1', '1', '2', '1', '2', '3']
    		// 把字符串中所有的 数字 查找出来并分割成数组
    		'1abcd12....123----1234'.match(/[1-9]+/g)//  ['1', '12', '123', '1234']
    		// 把字符串中所有的 字母 查找出来并分割成数组
    		'a1234aB....abC----Abcd'.match(/[a-zA-Z]+/g)//  ['a', 'aB', 'abC', 'Abcd']
    	// split 不做解释
    

    2, 正则判断和替换

    // 判断
    	// ①, 单字符匹配 (最简单的正则匹配)
    		/1/.test('1') // 判断字符串中是否包含 '1' true
    		/123/.test('123') // 判断字符串中是否包含 '123' true
    		/*
    			同理 /abc/.test('abc')  /文字/.test('文字')  /.../.test('...') 均可使用
    				tips: 使用特殊字符的时候需要加转义字符 \
    					例如: /\/\/\//.test('///') // 判断字符串中是否含有'///'
    		*/
    	// ②, 常用字符串判断
    		// 数字, 且不为空
    			/^[0-9]+$/.test('23') // true
    		// 字母, 且不为空
    			/^[a-zA-Z]+$/.test('ABCabc')// true
    		// 字母, 小写, 且不为空
    			/^[a-z]+$/.test('abc')// true
    		// 字母, 大写, 且不为空
    			/^[A-Z]+$/.test('ABC')// true
    // 替换
    	// ①, 常用字符串替换
    		/* 整体替换 字符串中只要出现与正则匹配到的字符, 立即替换 */
    			// 数字, 替换为 ""
    				'23'.replace(/[0-9]/g,"") // ""
    			// 字母, 替换为 ""
    				'abcdABCD'.replace(/[a-zA-Z]/g,"") // ""
    			// 字母, 小写, 替换为 ""
    				'abcd'.replace(/[a-z]/g,"") // ""
    			// 字母, 大写, 替换为 ""
    				'ABC'.replace(/[A-Z]/g,"") // ""
    		/* 小部分替换 ( 把字符串中 前两次 出现的数字替换为 '-' )*/
    			var i = 0;
    			'123456789'.replace(/[1-9]/g, a=> { return (i++ < 2) ? "-" : a; }) // --3456789
    // 查找
    	// ①, 字符 个数 查找 ( 学会这个细节即可解锁许多骚操作 )
    		// 0 个 或 1 个 '?'
    			'12abcd23'.match(/[1-9]?/g)// ['1', '2', '', '', '', '', '2', '3', '']
    		// 0 个 或 多 个 '*'
    			'12abcd23'.match(/[1-9]*/g)// ['12', '', '', '', '', '23', '']
    		// 多 个 '+'
    			'12abcd23'.match(/[1-9]+/g)// ['12', '23']
    		// n 个 在下方例子中 n=2 , '{}'
    		  //'12abcd23'.match(/[1-9]{n}/g) // n = 2
    			'12abcd23'.match(/[1-9]{2}/g)// ['12', '23']
    
    展开全文
  • 正则表达式的模式匹配

    千次阅读 2022-03-14 17:41:47
    JavaScript 的 RegExp 类表示正则表达式,String 和 RegExp 都定义了方法,后者使用正则表达式进行强大的模式匹配和文本检索与替换功能。 正则表达式的定义 正则表达式可以使用 RegExp() 构造函数来创建 RegExp 对象...

    正则表达式是一个描述字符模式的对象。JavaScript 的 RegExp 类表示正则表达式,String 和 RegExp 都定义了方法,后者使用正则表达式进行强大的模式匹配和文本检索与替换功能。

    正则表达式的定义
    正则表达式可以使用 RegExp() 构造函数来创建 RegExp 对象,更多的是通过一种特殊的直接量语法来创建。

    var pattern = new RegExp('s$');
    var pattern = / s$ /;
    

    RegExp对象

    RegExp() 构造函数带有两个字符串参数,其中第二个参数是可选的,RegExp() 用以创建新的 RegExp 对象。第一个参数包含正则表达式的主体部分,也就是正则表达式直接量中两条斜线之间的文本。RegExp() 的第二个参数是可选的,如果提供第二个参数,它就指定正则表达式的修饰符。

    let zipCode = new RegExp('\\d{5}', 'g');
    

    RegExp的属性:

    1. 属性 source 是一个只读的字符串,包含正则表达式的文本。
    2. 属性 global 是一个只读的布尔值,用以说明这个正则表达式是否带有修饰符 g 。
    3. ignoreCase 也是一个只读的布尔值,用以说明是否带有修饰符 i。
    4. multiline 是一个只读的布尔值,用以说明正则表达式是否带有修饰符 m。
    5. lastIndex 是一个可读/写的整数。

    RegExp的方法:

    1. test

    它的参数是一个字符串,用 test() 对某个字符串进行检测,如果包含正则表达式的一个匹配结果,则返回 true。

    let pattern = /java/i;
    pattern.test('JavaScript'); //true
    
    let pattern = /java/ig;
    pattern.test('JavaScript'); //true
    
    let pattern = /java/ig;
    pattern.test('JavaScript JavaScript'); //true
    

    2. exec

    let pattern = /Java/;
    let text = 'JavaScript is more fun than Java!';
    console.log(pattern.exec(text));
    console.log('lastIndex ', pattern.lastIndex);
    //['Java', index: 0, input: 'JavaScript is more fun than Java!]
    //lastIndex 0
    
    let pattern = /Java/g;
    let text = 'JavaScript is more fun than Java!';
    let result;
    while( (result = pattern.exec(text)) !== null){
    	console.log(result);
    	console.log('lastIndex ', pattern.lastIndex);
    }
    // ['Java', index:0, input: 'JavaScript is more fun than Java!']
    //lastIndex 4
    // ['Java', index:28, input: 'JavaScript is more fun than Java!']
    //lastIndex 32
    

    用于模式匹配的 String 方法

    1. search

    它的参数是一个正则表达式,返回第一个与之匹配的子串的起始位置,如果找不到匹配的子串,它将返回 -1。如果 search() 的参数不是正则表达式,则首先会通过 RegExp 构造函数将它转换成正则表达式,search 方法不支持全局搜索,因为它忽略正则表达式参数中的修饰符 g。

    console.log('JavaScript'.search(/javascript/i)); //0
    console.log('JavaScript'.search(/script/i)); //4
    
    console.log('JavaScript'.search('javascript')); //-1
    console.log('JavaScript'.search('script')); //-1
    console.log('JavaScript'.search('JavaScript')); //0
    console.log('JavaScript'.search('Script')); //4
    

    2. replace

    replace() 方法用以执行检索和替换操作。其中第一个参数是一个正则表达式,第二个参数是要进行替换的字符串。这个方法会对调用它的字符串进行检索,使用指定的模式来匹配。如果 replace() 第一个参数是字符串而不是正则表达式,则 replace() 将直接搜索这个字符串。

    console.log('JavaScript javascript'.replace(/javascript/gi, 'JavaScript')); //JavaScript JavaScript
    console.log('JavaScript javascript'.replace(/javascript/i, 'JavaScript')); //JavaScript javascript
    
    console.log('JavaScript javascript'.replace('javascript', 'JavaScript')); //JavaScript Javascript
    console.log('javascript javascript'.replace('javascript', 'JavaScript')); //JavaScript javascript
    

    3. match

    它的唯一参数就是一个正则表达式(或通过 RegExp() 构造函数将其转换为正则表达式),返回的是一个由匹配结果组成的数组。

    如果 match() 执行的不是全局检索,在这种情况下,数组的第一个元素就是匹配的字符串,余下的元素则是正则表达式中用圆括号括起来的子表达式。除了这些常规数组元素,这个返回的数组还有两个额外的对象属性。其中 index 属性指明了匹配文本在字符串中的开始位置;input属性则是对该字符串的引用。

    console.log('1 plus 2 equals 3'.match(/\d+/));// [1, index: 0, input: '1 plus 2 equals 3']
    console.log('1 plus 2 equals 3'.match(/\d+/g));// [1, 2, 3]
    
    console.log('111 plus 21 equals 31'.match(/(\d)+\1/));// [111, index: 0, input: '111 plus 21 equals 31']
    console.log('111 plus 21 equals 31'.match(/(\d)+\1/g));// [111]
    console.log('111 plus 11 equals 11'.match(/(\d)+\1/g));// [111, 11, 11]
    

    注意对于全局匹配,match() 不会提供关于圆括号子表达式的信息,也不会有 index, input 属性。如果希望在全局搜索时取得这些信息,可以使用 RegExp.exec()。

    4. split
    将一个字符串切分为一个由字符串组成的数组。split() 接收两个参数,第一个参数为切分处的字符串或正则表达式(分隔符),第二个为可选参数,指定返回数组的最大长度。

    split() 方法返回的数组的元素是这样创建的:从字符串的开头搜索到结尾,在所有匹配 分隔符的文本的前方及后方断开。

    1.如果分隔符匹配给定字符串的开头内容,则返回数组的第一个元素将是空字符串。类似地,如果分隔符匹配改字符串的末尾,则返回数组的最后一个元素将是空字符串。
    2.如果没有指定分隔符的,则字符串将不会切分,返回的数组将只包含一个未切分的字符串元素。
    3.如果分隔符为空字符串或是一个匹配空字符串的正则表达式,则字符串将在每个字符之间断开。
    4.split() 方法返回的数组中的子串不包含用来切分改字符串的分隔文本。不过,如果分隔符是一个圆括号表达式的正则表达式,则匹配这些圆括号表达式的子串将包含在返回的数组中。

    console.log('1:2:3:4:5'.split(':'));//['1','2','3','4','5']
    console.log('1:2:3:4:5'.split(':', 3));//['1','2','3']
    
    //1
    console.log(':1:2:3:4:5'.split(':'));//['','1','2','3','4','5']
    console.log('1:2:3:4:5:'.split(':'));//['1','2','3','4','5','']
    //2
    console.log('1:2:3:4:5'.split());//['1:2:3:4:5']
    console.log('1:2:3:4:5'.split(' '));//['1:2:3:4:5']
    console.log('1:2:3:4:5'.split(/\s+/));//['1:2:3:4:5']
    //3
    console.log('1:2:3:4:5'.split(''));//['','1','2','3','4','5']
    //4
    console.log('hello <b>world</b>'.split(/<[^>]*>/));// ['hello ', 'world', '']
    console.log('hello <b>world</b>'.split(/(<[^>]*>)/));// ['hello ', '<b>', 'world', '</b>', '']
    

    正则表达式中的所有字母和数字都是按照字面含义进行匹配的。JavaScript 正则表达式语法也支持非字母的字符匹配,这些字符需要通过反斜线(\)作为前缀转义。

    1.直接量字符

    表 1-1

    字符匹配
    字母和数字字符自身
    \oNUL 字符(\u0000)
    \t水平制表符(\u0009)
    \v垂直制表符(\u000B)
    \r回车符(\u000D)
    \n换行符(\u000A)
    \xnn由十六进制数 nn 指定的拉丁字符,例如,\x0A 等价于 \n
    \uxxxx由十六进制数 xxxx 指定的 Unicode 字符,例如 \u0009 等价于 \t
    \cX控制字符 ^X,例如,\cJ 等价于换行符 \n

    2.字符类

    将直接量字符单独放进方括号内就组成了字符类。一个字符类可以匹配它所包含的任意字符。

    表 2-1

    字符匹配
    […]方括号内的任意字符
    [^…]不在方括号内的任意字符
    .除换行符和其他 Unicode 行终止符之外的任意字符
    \w任何 ASCII 字符组组成的单词,等价于 [ a-zA-Z0-9 ]
    \W任何不是 ASCII 字符组成的单词,等价于 [ ^a-zA-Z0-9 ]
    \s任何 Unicode 空白符
    \S任何非 Unicode 空白符的字符,注意 \w 和 \S 不同
    \d任何 ASCII 数字,等价于 [^0-9]
    \D除了 ASCII 数字之外的任何字符,等价于 [^0-9]
    [\b]退格直接量(特例)

    重复字符语法

    在正则模式之后跟随用以指定字符重复的标记。由于某些重复种类非常有用,因此就有一些专门用于表示这种情况的特殊字符。

    表 3-1

    字符含义
    {n,m}匹配前一项至少 n 次,但不能超过 m 次
    {n,}匹配前一项至少 n 次或者更多次
    {n}匹配前一项 n 次
    ?匹配前一项 0 次或者 1 次,也就是说前一项是可选的,等价于 {0,1}
    *匹配前一项 0 次或 多次,等价于 {0,}
    +匹配前一项 1 次或 多次,等价于 {1,}

    表 3-1 列出的匹配重复字符是尽可能多地匹配,而且允许后续的正则表达式继续匹配。因此,我们称之为 “贪婪的” 匹配。我们同样可以使用正则表达式进行非贪婪匹配。只须在待匹配的字符后跟随一个问号即可。

    console.log('aaa'.match(/a+/)); ['aaa']
    console.log('aaa'.match(/a+?/)); ['a']
    
    console.log('aaab'.match(/a+b/)); ['aaab']
    console.log('aaab'.match(/a+?b/)); ['aaab']
    

    正则表达式的模式匹配总是会寻找字符串中第一个可能匹配的位置。 由于该匹配是从字符串第一个字符开始的,因此在这里不考虑它的子串更短的匹配。

    选择、分组和引用字符
    正则表达式的语法还包括指定选择项、子表达式分组和引用前一子表达式的特殊字符。

    // |
    console.log('ab'.match(/ab|cd|ef/)); // ['ab']
    console.log('cd'.match(/ab|cd|ef/)); // ['cd']
    console.log('ef'.match(/ab|cd|ef/)); // ['ef']
    // (...) \n
    console.log('ab'.match(/(ab|cd)+|ef/)); // ['ab', 'ab']
    console.log('cd'.match(/(ab|cd)+|ef/)); // ['cd', 'cd']
    console.log('ef'.match(/(ab|cd)+|ef/)); // ['ef']
    
    console.log('abab'.match(/(ab|cd)+|ef\1/)); // ['abab']
    console.log('cdab'.match(/(ab|cd)+|ef\1/)); // ['cdab', 'ab']
    console.log('efab'.match(/(ab|cd)+|ef\1/)); // ['ef']
    console.log('efab'.match(/(ab|cd)\1/)); // null
    

    表 4-1

    字符含义
    |选择,匹配的是该符号左边的子表达式或右边的子表达式
    (…)组合,将几个项组合为一个单元,这个单元可通过 ‘*’,‘+’,‘?’ 和 ‘|’ 等符号加以修饰,而且可以记住和这个组合相匹配的字符串以供此后的引用使用
    (?:…)只组合,把项组合到一个单元,但不记忆与改组相匹配的字符
    \n和第 n 个分组第一次匹配的字符相匹配,组是 圆括号 中的子表达式(也有可能是嵌套的),组索引是从左到右的左括号数,‘(?:’ 形式的分组不编码

    指定匹配位置

    像 \b 这样的元素不匹配某个可见字符,它们指定匹配发生的合法位置。有时我们称这些元素为正则表达式的锚,因为它们将模式定位在搜索字符串的特定位置上。

    //(?=p)
    console.log('JavaScript: The Definitive Guide'.match(/[Jj]ava([Ss]cript)?(?=\:)/)); //['JavaScript', 'Script']
    console.log('JavaScript The Definitive Guide'.match(/[Jj]ava([Ss]cript)?(?=\:)/)); //null
    
    //(?=p)
    console.log('JavaScript'.match(/Java(?!Script)([A-Z]\w*)/)); // null
    console.log('JavaScript'.match(/Java(?! Script)([A-Z]\w*)/)); // ['JavaScript', 'Script']
    console.log('Java Script'.match(/Java(?! Script)([A-Z]\w*)/)); // null
    

    表 5-1 正则表达式中的锚字符

    字符含义
    ^匹配字符串的开头,在多行检索中,匹配一行的开头
    $匹配字符串的结尾,在多行检索中,匹配一行的结尾
    \b匹配一个单词的边界,简言之,就是位于字符 \w 和 \W 之间的位置,或位于字符 \w 和 字符串的开头或者结尾的位置(但需要注意,[\b] 匹配的是退格符)
    \B匹配非单词边界的位置
    (?=p)零宽 正向 先行断言,要求接下来的字符都与 p 匹配,但不能包含匹配 p 的那些字符
    (?!p)零宽 负向 先行断言,要求接下来的字符不与 p 匹配

    修饰符

    正则表达式的修饰符,用以说明高级匹配模式的规则。修饰符是放在 / 符号之外的,也就是说,它们不是出现在两条斜线之间,而是第二条斜线之后。

    字符含义
    i执行不区分大小写的匹配
    g执行一个全局匹配,简言之,即找到所有的匹配,而不是在找到第一个之后就停止
    m多行匹配模式,^匹配一行的开头和字符串的开头,$匹配行的结束和字符串的结束
    展开全文
  • 前面我们知道正则表达式有很元字符表示匹配次数(量词),都是可以重复匹配前面出现的单个字符次数。有时候,我们可能需要匹配一组个字符一起出现的次数。这个时候,我们需要分组了。就是用小括号来括起这些字符...
  • 匹配中文字符的正则表达式: [\u4e00-\u9fa5] 评注:匹配中文还真是个头疼的事,有了这个表达式就好办了 匹配双字节字符(包括汉字在内):[^\x00-\xff] 评注:可以用来计算字符串的长度(一个双字节字符长度计2,...
  • i (PCRE_CASELESS) 如果设定此修正符,模式中的字符将同时匹配大小写字母。 m(PCRE_MULTILINE) 默认情况下,PCRE 将目标字符串作为单一的一“行”字符所组成的(甚至其中包含有换行符也是如此)。“行起始”元字符...
  • 面试题19:正则表达式匹配 题目:请实现一个函数用来匹配包含’.‘和’*‘的正则表达式。模式中的字符’.‘表示任意一个字符,而’*’表示它前面的字符可以出现任意次(含0次)。在本题中,匹配是指字符串的所有字符...
  • Java正则多匹配次组匹配

    千次阅读 2021-02-12 15:18:07
    关于正则表达式 , 可以学习下这篇介绍 : 正则表达式对于匹配, 正则表达式就需要讲究些技巧了.替换单文的匹配有以下几种方式 , 把a全匹配替换替换 a"aab".replaceAll("a{1}", "x"); //xxb"aba".replaceAll("a...

    关于正则表达式 , 可以学习下这篇介绍 : 正则表达式

    对于多次匹配, 正则表达式就需要讲究些技巧了.

    替换

    单文的多次匹配

    有以下几种方式 , 把a全匹配替换

    替换 a

    "aab".replaceAll("a{1}", "x"); //xxb

    "aba".replaceAll("a{1}", "x"); //xbx

    替换 aa

    "abaaabaaaba".replaceAll("a{2}", "x"); //abxabxaba

    "abaabaaaaba".replaceAll("a{2}", "x"); //abxbxxba

    replaceAll()方法会将所有匹配到的全部替换掉.

    提取

    提取就需要用到group了.

    提取 a

    Matcher matcher = Pattern.compile("(a)").matcher("ab");

    if(matcher.find()){

    System.out.println(matcher.group());

    }

    --------

    // 结果

    a

    提取多个 a

    group只有提取一次匹配到的 , 要多次提取 , 需要循环匹配.

    Matcher matcher = Pattern.compile("(a)").matcher("aba");

    int matcher_start = 0;

    while (matcher.find(matcher_start)){

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

    matcher_start = matcher.end();

    }

    ------------

    // 结果

    a

    a

    提取复杂内容

    示例在一个文本中提取多个xml标签

    String txt = "abc123这是root1这是root2";

    Matcher matcher = Pattern.compile("(.*?)").matcher(txt);

    int matcher_start = 0;

    while (matcher.find(matcher_start)){

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

    matcher_start = matcher.end();

    }

    ------

    // 结果

    这是root1

    这是root2

    group使用的注意点

    多匹配和少匹配

    上面的复杂示例中, 正则是 (.*?) , 中间的分组匹配是 (.*?) ,里面是有个问号?的 .

    正则默认是多匹配的, 尽可能多的匹配到文本.

    多匹配

    那么不加?时, 只能匹配到一个文本 , (.*) 匹配到的是: 这是root1这是root2 , 会把中间的全部匹配进去了. 这就是多匹配

    少匹配

    要尽可能少的匹配 , 就需要加上?,(.*?) 匹配到的是: 这是root1. 这个结果一般才是想要的.

    group 匹配的组的顺序

    matcher.group(1) // 这里是group序号1

    group匹配后得到是一个数组 , 数组0位置是全匹配文本 , 数组1位置才是第一个匹配到的分组.

    例如:

    上面的示例中, (.*?)得到的group(0) 是 这是root1 .

    序号不好识别的话, 可以用别名来识别 .

    String txt = "abc123这是root1这是root2";

    Matcher matcher = Pattern.compile("(?.*?)").matcher(txt);

    int matcher_start = 0;

    while (matcher.find(matcher_start)){

    System.out.println(matcher.group("element"));

    matcher_start = matcher.end();

    }

    ------

    // 结果

    这是root1

    这是root2

    element就是文本的别称 , 可以直接用别称提取内容.

    如果文章有帮助到您,请点个赞,您的反馈会让我感到文章是有价值的

    展开全文
  • php正则表达式中的非贪婪模式匹配
  • php(正则匹配)

    千次阅读 2020-09-16 13:30:37
    一、正则表达式基础内容 注: 1、通用原子: \d : 数字。 \D : 除了数字。 \w : 数字,字母,下划线。\W : 除了数字,字母,下划线。 \s : 空白符 。 \S : 除了空白符 。 2、元字符: . :除了换行以外的所有字符 ...
  • 然后,php也是类似的,c#,python等,一般调用正则表达式的匹配函数,都有一个另外选项的,设置模式。 单行、多行模式容易出现理解错误 为什么说,容易出现理解错误呢,它们英文对应说明是:SingleLine ,MultiLine...
  • C++使用正则匹配

    千次阅读 2020-08-12 20:26:31
    C/C++可以用正则表达式吗? 答案肯定是可以的,那么,今天一个简单的输入scanf带你走进正则的世界 #include<stdio.h> int main() { printf("input digate:"); char str[100]; scanf("%[0-9]", str); //输入...
  • python 正则匹配

    千次阅读 2019-06-01 16:15:13
    在python 中,正则匹配用到的还是挺的,下面总结一下常用的一些正则匹配: 精确匹配: \d可以匹配一个数字, \w可以匹配一个字母或数字, . 匹配任意的单个字符 \s可以匹配一个空格(也包括Tab等空白符) 变...
  • JavaScript正则匹配 多行内容

    千次阅读 2020-11-11 21:53:10
    需求: 通过正则匹配给定代码块中的链接和标题 刚开始是通过以下正则匹配的, 尝试之后匹配失败 let reg = /<a href="(.*?)" class="">.<span class="title">(.*?)<\/span><\/a>/igs 观察后...
  • 正则表达式,正则匹配冒号

    千次阅读 2020-12-20 13:36:42
    例如,“\\n”匹配\n。“\n”匹配换行符。序列“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。^匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性,^也匹配...
  • Java中的正则匹配

    千次阅读 2020-07-24 14:58:55
    正则匹配中常用的类为Pattern和Matcher类,前者表示匹配的模式串,后者表示匹配的结果。 常用的使用方法如下: // 待查找字符 String fileName = "workspace/test.apk"; // 构建模式,其中compile方法还可以
  • JavaScript 正则匹配的 Unicode 模式

    千次阅读 2019-09-28 09:28:11
    前两天室友正在看 js 关于正则表达式的博客,发现 js 正则表达式中有个 u,可以用于开启 unicode 模式,并且被博客举的两个例子搞懵了,例子如下: /^\uD83D/.test('\uD83D\uDC2A') // true /^\uD83D/u.test('\uD83D...
  • python 正则匹配 获取括号内字符

    千次阅读 2021-04-27 08:22:39
    原文件:生成后的结果:实现方式前言因为正则表达式语法很难读,因此本次程序以次的方式来讲解。一、提取【】内内容import rewith open("XDHYCD7th.txt","r",encoding="utf-8") as f:text = f.read()words = re....
  • 【python】正则表达式匹配多模式

    万次阅读 2018-11-13 09:44:03
    匹配多模式的时候,可以使用或表达式和多行匹配方法来实现。 #使用或表达式来实现 #patternA|patternB,模式A 或B两种匹配 import re text = 'This string1 is an example for match string2' text= text....
  • 将原始的字符串 正则匹配替换成指定的字符串类型 如以下的字符串: $str="<p>张三去吃饭喝酒</p><p><img src=\...
  • php正则匹配标点符号

    2021-05-05 05:50:40
    正则表达式通常被用来 检索或替换 符合某个模式的文本内容 许多程序设计语言都支持利用正则表达式进行字符串操作。例如: JavaScript、PHP、ASP、JAVA、Perl、C#、.NET、Co 正则表达式通常被用来 检索或替换 符合某个...
  • nginx location正则匹配规则

    千次阅读 2020-08-17 15:47:46
    示例: location = / { # 精确匹配 / ,主机名后面不能带任何字符串 [ configuration A ] } location / { ... # 但是正则和最长字符串会优先匹配 [ configuration B ] } location /documents/ { # 匹
  • 主要介绍了Java 正则表达式匹配模式(贪婪型、勉强型、占有型),需要的朋友可以参考下
  • 正则中常见的4种匹配模式

    千次阅读 2020-06-26 22:17:20
    正则中常见的四种匹配模式,分别是:不区分大小写、点号通配模式、多行模式和注释模式。 不区分大小写模式,它可以让整个正则正则中某一部分进行不区分大小写的匹配。 点号通配模式也叫单行匹配,改变的是点号的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 235,729
精华内容 94,291
关键字:

多模式正则匹配