正则表达式（各语言通用）

野生java研究僧

已于 2022-08-30 16:31:38 修改

阅读量2k

点赞数 4

分类专栏：前端文章标签：正则表达式

于 2020-05-21 20:36:01 首次发布

本文链接：https://blog.csdn.net/m0_46188681/article/details/106266862

版权

前端专栏收录该内容

24 篇文章 1 订阅

订阅专栏

文章目录

1.概述
2.使用对象创建
3.使用字面量创建
4.正则表达式中的特殊字符
5.支持正则表达式的 String 对象的方法
6.java正则
7.扩展
8.常见正则表达式

1.概述

正则表达式用于定义一些字符串的规则，计算机可以根据正则表达式，来检查一个字符串是否符合规则，获取将字符串中符合规则的内容提取出来。

使用typeof检查正则对象，会返回object。

2.使用对象创建

语法：var 变量名 = new RegExp(“正则表达式”,“匹配模式”);

匹配模式：

i:忽略大小写
g：全局匹配模式
ig：忽略大小写且全局匹配模式

案例演示：

			// 这个正则表达式可以来检查一个字符串中是否含有a
			var reg = new RegExp("a", "i");
			var str = "admin";
			var result = reg.test(str);
			console.log(result);

3.使用字面量创建

语法格式：var 变量名 = /正则表达式/匹配模式;

匹配模式：

元字符	含义
g	进行全局匹配
m	多行匹配
i	不区分大小写匹配
u	只匹配最近的一个字符串;不重复匹配;

注意：可以为一个正则表达式设置多个匹配模式，且顺序无所谓

简单案例:

			// 简单案例：匹配字符串中是否包含mi
			let reg = /a/g;
			let str = 'admin';
			let result = reg.test(str);
			console.log(result)

4.正则表达式中的特殊字符

4.1 边界符

正则表达式中的边界符（位置符）用来提示字符所处的位置，主要有两个字符。

元字符	含义
^	匹配字符串的开始位置，或多行匹配模式中（\m）每一行的开始位置
$	匹配字符串的结束位置，或多行匹配模式下（\m）每一行的结束位置
\b	匹配单词边界。这个元字符用于单词匹配。单词边界有4种形式： 1、当字符串第一个字符是单词字符时，位于第一个字符前面； 2、当字符串最后一个字符是单词字符时，位于最后一个字符后面； 3、在单词字符和非单词字符之间，紧跟在单词字符后面； 4、在非单词字符和单词字符之间，紧跟在非单词字符后面
\B	匹配非单词边界，这个元字符匹配\b不匹配的每一个位置
x(?=y)	正向前查匹配。也就是说，只有在x后面跟上y时，才匹配x成功。例如：使用正则表达式`/Hello(?=World)/`进行匹配时，只有Hello后面跟着World时匹配才算成功，所以，这个正则表达式匹配HelloWorld，但是不匹配Hello，也不匹配Hello123
x(?!y)	反向前查匹配。只有在x后面不跟着y时，才匹配x成功。例如：在使用正则表达式`/Hello(?!World)/`进行匹配时，只有Hello后面不跟着World时才匹配成功。所以这个正则表达式匹配Hello，也匹配Hello123（同时也匹配里面的Hello），但是不匹配HelloWorld

案例演示：

			// 简单案例：匹配的字符串中必须以a开始
			let reg = /^a/g;
			let str1 = 'admin';
			let str2 = 'root';	
			let result1 = reg.test(str1); //true
			let result2 = reg.test(str2); // false
			console.log(result1);
			console.log(result2);
			
			// 简单案例：匹配字符串是否以.txt进行结尾[可用于文件类型判断]
			let reg2 = /.txt$/g;
			let str3 = 'a.txt';
			let str4 = 'a.md';	
			let result3 = reg2.test(str3); //true
			let result4 = reg2.test(str4); // false
			console.log(result3);
			console.log(result4);

4.2 字符类

表示有有一系列字符可供选择，只要匹配其中一个就可以了，所有可供选择的字符都放在方括号内

常见组合：

[a-z]：任意小写字母
[A-Z]：任意大写字母
[A-z]：任意字母
[0-9]：任意数字

	
	var rg = /[abc]/; //只要包含有a 或者b 或者c 都返回true
	console.log(rg.test('admin')) //true
	console.log(rg.test('color')) //true
	console.log(rg.test('blank')) //true
	console.log(rg.test('mysql')) //true
        
	var rg2 = /^[abc]/i //开始内容是 a,b,c其中一个才返回true
	console.log(rg2.test('admin')) //true
	console.log(rg2.test('borther')) //true
	console.log(rg2.test('color')) //true
	console.log(rg2.test('a')) //true
	console.log(rg2.test('root')) //false

除了使用[]的方式表示或者的意思还可以使用 | 表示或

例如：我想匹配上传的文件后缀名必须是以 .png .jpg .gif类型结尾的图片

	// 必须以 .png  .jpg .gif 等结尾的字符串才返回true
	var rg2 = / .png$|.jpg$|.gif$/i
	console.log(rg2.test('a.png')) //true
	console.log(rg2.test('a.jpg')) //true
	console.log(rg2.test('a.gif')) //true
	console.log(rg2.test('a.jepg')) //true
	console.log(rg2.test('a.txt')) //false

4.3量词

量词符用来设定某个模式出现的次数

量词	说明
*	重复0次或更多次
+	重复1次或更多次
？	重复0次或1次
{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('--------------------------------')

			var reg = /^a+$/
			console.log(reg.test('')) // false
			console.log(reg.test('a')) // true
			console.log(reg.test('aaa')) // true

			console.log('--------------------------------')

			var reg = /^a?$/
			console.log(reg.test('')) // true
			console.log(reg.test('a')) // true
			console.log(reg.test('aaa')) // false

			console.log('--------------------------------')

			var reg = /^a{3}$/
			console.log(reg.test('')) // false
			console.log(reg.test('a')) // false
			console.log(reg.test('aaa')) // true

			console.log('--------------------------------')

			var reg = /^a{3,}$/
			console.log(reg.test('')) // false
			console.log(reg.test('a')) // false
			console.log(reg.test('aaa')) // true
			console.log(reg.test('aaaaa')) // true

			console.log('--------------------------------')

			var reg = /^a{3,5}$/ //{3,5} 逗号后不要空格
			console.log(reg.test('')) // false
			console.log(reg.test('a')) // false
			console.log(reg.test('aaa')) // true
			console.log(reg.test('aaaaa')) // true

4.4 括号总结

大括号：量词符里面表示重复次数
中括号：字符集合。匹配方括号中的任意字符
小括号：表示优先级

			//中括号
			var reg = /^[abc]$/ //a||b||c

			//大括号
			var reg = /^a{3}|^b{3}$/ //让a或b开始并且重复3次以上
			console.log(reg.test('aaaqwe')) // true
			console.log(reg.test('aaqwe'))  // false
			
			//小括号
			var reg = /^(ab){2}/ //以ab开始并且重复2次以上
			
			console.log(reg.test('ababqwe')) // true
			console.log(reg.test('abqwe')) // true

4.5 预定义类

预定义类指的时候某些常见模式的简写方式

预定义类	说明
\d	匹配一个数字字符。等价于[0-9]。
\D	匹配一个非数字字符。等价于 [ ^0-9]
\w	匹配包括下划线的任何单词字符。等价于“`[A-Za-z0-9_]`”。
\W	匹配任何非单词字符。等价于“`[^A-Za-z0-9_]`”
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于[ ^ \f\n\r\t\v]。

我们在下面的表格中列出了JavaScript支持的元字符和元符号。

4.6 特殊字符

元字符	含义
\0	匹配null字符，对应的十六进制值为\x00
\b	匹配退格字符，对应的十六进制值为\x08
\n	匹配换行字符，对应的十六进制值为\x0A
\r	匹配回车字符，对应的十六进制值为\x0D
\f	匹配换页字符，对应的十六进制值为\x0C
\t	匹配制表(TAB)字符，同时对应于水平制表符\x09和垂直制表符\x0B
\xhh	匹配用2个十六进制数字表示的字符
\uhhhh	匹配用4个十六进制在数字表示的字符，这些字符是Unicode字符
\cchar	匹配命名的控制字符

提示：特殊字符是指那些不容易进行直接书面表达或不容易直接使用键盘输入的字符。

表2：字符类

元字符或元符号	含义
[…]	匹配列表中给出的任何字符。该列表可以是一个字符，也可以是多个字符，还可以是使用“-”表示的字符范围。例如[a]表示匹配单个字母a，[ab]表示匹配字母a或字母b，[a-z]表示匹配任何一个小写字母，[0-9]表示匹配任何单个的数字，[a-z0-9]表示匹配任何单个的小写字母或数字，等等
[^.]	匹配列表中没有给出的任何单个字符。该元字符与[…]的意义刚好相反。例如：[^{a]表示匹配任何不是字母a的字符，[}ab]表示任何不是字母a或字母b的字符，[^a-z]表示任何不是小写字母的任何字符，等等
.	匹配除了回车和换行符之外的任何字符
\w	元符号，相当于[a-zA-Z0-9_]，匹配任何字母、数字、下划线字符，这样的字符也称为单词字符
\W	元符号，相当于[^a-zA-Z0-9_]，匹配除了字母、数字、下划线字符之外的任何字符
\d	元符号，相当于[0-9]，匹配任何单个的数字字符
\D	元符号，相当于[^0-9]，匹配除了数字之外的任何单个字符
\s	元符号，匹配空白字符，空白字符是指空格、Tab字符和回车换行符
\S	元字符，匹配任何非空白字符

5.支持正则表达式的 String 对象的方法

search 检索与正则表达式相匹配的值。

match 找到一个或多个正则表达式的匹配。

replace 替换与正则表达式匹配的子串。

split 把字符串分割为字符串数组。

6.java正则

 public static void main(String[] args) {
        String str = "1998年12月8日，第二代Java平台的企业版J2EE发布。" +
                "1999年6月，Sun公司发布了第二代Java平台（简称为Java2）" +
                "的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型版）" +
                "，应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard " +
                "Edition，Java 2平台的标准版），应用于桌面环境；J2EE（" +
                "Java 2Enterprise Edition，Java 2平台的企业版），" +
                "应用于基于Java的应用服务器。Java 2平台的发布，是Java发展" +
                "过程中最重要的一个里程碑，标志着Java的应用开始普及。";
        //说明
        //1. \\d  表示一个任意的数字（0-9）
        String regStr = "\\d{4}";
        //2.创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3.创建匹配器
        //说明 ：创建匹配器 matcher ，按照正则表达式的规则，去匹配 str字符串
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }

        // 匹配某个字符串是否以某个字串开始
        boolean matches1 = "adminRoot".matches("^admin(?i)[a-z]+");
        // 匹配某个字符串是否以某个字串结束
        boolean matches2 = "Content.txt".matches("^(?i)[a-z]+.txt$");
        System.out.println(matches1);
        System.out.println(matches2);

    }

7.扩展

7.1 查询某个字符串

			let webText = 'He1lo，my name is Ben. Please visitmy website at http://www.forta.com /';
			let myReg = /my/igm; // my就是需要查询的字符串
			let myResult = webText.match(myReg);
			console.log(myResult)

7.2 替换任意单个字符

			let webText = 'cot,cat,admin,orgin,<p color="red">p文本</p>';
			// .类似于sql查询中的 _ 代表着任意一个字符,也可以匹配字符本身
			let myReg = /c.t/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.3 特色转义字符处理

假如我们现在想匹配一个字符串类是这种格式: .a.然后以.xls结尾的文件，那么就得使用 \ 进行转义处理,\ 可以对有特色含义的字符做转义

			let webText = 'na1.xls,nax.xls,kay.xls,<p color="red">p文本</p>';
			// .类似于sql查询中的 _ 代表着任意一个字符,也可以匹配字符本身
			let myReg = /.a.\.xls/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.4 匹配多个字符串中的其中一个

比现在我想匹配出所有的: a.txt,a.xml,a.xls 这样的字符串，那么我可以写下如下正则

		    let webText = 'a.xml,a.xls,a.txt,<p color="red">p文本</p>';
			// .类似于sql查询中的 _ 代表着任意一个字符,也可以匹配字符本身
			let myReg = /a.xml|a.xls|a.txt/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.5 利用字符区间集合

假设我们现在需要匹配的是 key[数字]开始结尾是 .xml或者.xls的字符串，需要注意的是区间使用 - 连字符的区间不能从大到小，否则会使整个匹配模式失效

			let webText = 'key1.xml,key2.xls,key3.xmk,keg.xml,<p color="red">p文本</p>';
			// .类似于sql查询中的 _ 代表着任意一个字符,也可以匹配字符本身
			let myReg = /key[0-9](.xml|.xls)/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.6 使用字符区间匹配合法16进制的颜色值

合法的16进制颜色值由 #开始6后面6位可以是数字，A-F大小写字母 {6}表示将前面的规则重复6次,如果不写成{6}的方式则需要将正则中的：[0-6A-Fa-f] 重复写6次

			let webText = 'color: #ffffff;color:#f0f0f0;#55ffff;,<p color="red">p文本</p>';
			let myReg = /#[0-6A-Fa-f]{6}/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.7 取非匹配

比如我不想某一位是数字那么可以使用如下正则进行过滤,我们的目标是取出： admin.xml,root.xml，也就是说匹配admi和root后疑问除数字之外的任何字符, 如果想要精确的取出 admin.xml,root.xml 则该正则还得进行改进

	    	let webText = 'admia.xml,admin2.xml,root1.xml,admin.xml,root.xml,<p color="red">p文本</p>';
			let myReg = /(admi|roo)[^0-9].xml/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.8 合理使用元字符

比如我们想在这个字符串 ‘let arr = []; let id = arr[0],name = arr[1];’ 中匹配中 arr[0]，那么正则写法如下

			let webText = 'let arr = []; let id = arr[0],name = arr[1];';
			let myReg = /arr\[0\]/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

那假设我不仅需要匹配arr[0]，我还想匹配arr[1]…arr[n]呢？我们利用上面所学的字符区间可以进行优化,这样我们就可以取出 arr[0] ~arr[9]

		   let webText = 'let arr = []; let id = arr[0],name = arr[1];';
			let myReg = /arr\[[0-9]\]/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.9 替换widows路径为linux路径

我们知道元字符可以进行转义,在linux下的路径表方式为/,二windows使用\进行表示,我们则可以进行统一替换为/表示

			let webText = 'd:\\user\\tp\\text\\font.txt';
			let myReg = /\\/igm;
			let myResult = webText.replace(myReg,'/');
			console.log(myResult)

7.10 匹配一个或多个

在以下文本中找出邮箱

			let webText = 'this some email tenx@qq.com;biadu@bd.com;aliyun@al.com';
			let myReg = /[\w.]+@[\w.]+\.\w+/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.11 匹配一个或0个字符

假设我们现在需要找出文本中的URL地址，？表示前面的字符出现0次或1次仅此而已。

let webText = 'The URL is http://www.forta.com/ , to connectsecurely use https://www.forta.com/ instead .';
			let myReg = /https?:\/\/[\w.]+/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.12 匹配回车和换行符

Linux中\n表示回车+换行；

Windows中\r\n表示回车+换行。

Mac中\r表示回车+换行。

		    let webText = `101:admin,102:root
			103:jack`;
			let myReg = /[\r]?\n/igm;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.13 获取html标签中的文本

		   let webText = `<p>文本</p>`;
			let myReg = /<[^<>]+>/igm;
			let myResult = webText.replace(myReg,'');
			console.log(myResult)

7.14 惰性匹配

			let webText = `This offer is not available to customersliving in <B>AK</B> and <B>HI</B>.`;
			let myReg = /<[b]>.*<\/[b]>/igm; 
			let myResult = webText.match(myReg,'');
			console.log(myResult)

现在匹配的结果是： AK and HI，而我们想要的结果是 AK HI,那么可以使用惰性匹配

	         let webText = `This offer is not available to customersliving in <B>AK</B> and <B>HI</B>.`;
			let myReg = /<[b]>.*?<\/[b]>/igm;
			let myResult = webText.match(myReg,'');
			console.log(myResult)

7.15 单词边界

\b 匹配这样的位置：它的前一个字符和后一个字符不全是(一个是,一个不是或不存在) \w

	let webText = `The captain cape wore his cap and cape proudly ashe sat listening to the recap of how hiscrew saved the men from a capsized vessel.`;
			let myReg = /\bcape\b/igm;
			let myResult = webText.match(myReg,'');
			console.log(myResult)

7.16 匹配前后都不是单词边界的连字符

let webText = `The captain cape - wore his cap and cape proudly ashe sat listening to the recap of how hiscrew saved the men from a capsized vessel.`;
			let myReg = /\B-\B/igm;
			let myResult = webText.match(myReg,'');
			console.log(myResult)

7.17 找出单行注释和多行注释

比如我想找出代码中所有的单行注释和多行注释

		let webText = `
			let a = 5;
			let b = 10;
			// c=a+b
			let c = a+b;
			// print c
			console.log(c);`;
			let myReg = /\/\/.*|\/\*\*[\s\S]*\*\//g;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.18 子表达式

子表达式是一个更为强大的表达部分，把一个表达式划分为一些列子表达式的目的是将那些子表达式当做一个独立的元素来使用，子表达式必须使用(和)包裹起来。

let webText =	`Hello，my name is Ben&nbsp;Forta,and I amthe author of books on sQL,ColdFusion，WAP,windows&nbsp;&nbsp;2000,and other subjects.`;
			// let myReg = /(&nbsp;){2}/img;
			// 和上面等价
			let myReg = /&nbsp;&nbsp;/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

子表达式可以重复的前一个规则,比如我们想要提前如下的ip地址

			let webText =
				`Pinging hog.forta.com [12.159.46.200]with 32 bytes of data:`;
			let myReg = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

很容易就看出这个表达式的规则，但是可以看出重复的规则写了好几次，那么我们可以使用子表达式来简化

		let webText =
				`Pinging hog.forta.com [12.159.46.200]with 32 bytes of data:`;
			let myReg = /(\d{1,3}\.){3}\d{1,3}/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.19子表达式嵌套

很明显上面我们那样匹配的ip地址，会可能出现不合法的ip地址，比如：555.666.333.999 这样的ip根本没有，但是依据我们的正则依旧能匹配出来，我们现在跟换一下规则。

任何一个1位或2位数字。
任何一个以1开头的3位数字。
任何一个以2开头、第2位数字在0~4之间的3位数字。
任何一个以25开头、第3位数字在0~5之间的3位数字。

	let webText =
			`Pinging hog.forta.com [999.666.555.200]with 32 bytes of data:[192.168.75.33]`;
	let myReg = /(((\d{1,2})|(1\d{2})|(2[0-4]\d)|(25[0-5]))\.){3}((\d{1,2})|(1\d{2})|(2[0-4]\d)|(25[0-5]))/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.20 提取html字符串中的所有h标签

	let contentText =
				`
			 <div> 
			 <p>测试p1</p>
			 <div><h1 >1.标题1</h1></div>
			 <h2 >1.1标题1</h2>
			 <h2 >1.2标题1</h2>
			 <h2 >1.3标题1</h2>
			 <h3 >1.1.1标题1</h3>
			 <h3 >1.1.2标题1</h3>
			 <h3 >1.1.3标题1节流操作的单元是数据单元是8位的字节</h3>
			 <div/>
			 
			 <div> 
			  <p>测试p2</p>	
			   <div>  <h1 >2.标题2</h1> </div> 
			  <h2 >2.1标题2</h2>
			  <h2 >2.2标题2</h2>
			  <h2 >2.3标题2</h2>
			  <h3 >2.1.1标题2</h3>
			  <h3 >2.1.2标题2</h3>
			  <h3 >2.1.3标题2</h3>
			   <div/>
			   
			   <div>
			  <p>测试p3</p>	
			  <div> <h1 >3.标题3</h1></div>
			  <h2 >3.1标题3</h2>
			  <h2 >3.2标题3</h2>
			  <h2 > 3.3标题3</h2>
			  <h3 >3.1.1标题3</h3>
			  <h3 >3.1.2标题3</h3>
			  <h3 >3.1.3标题3</h3>
			   <div/>
			    <div>
				
			  <p>测试p4</p>	
			  <div><h1 >4.标题4</h1></div>
			  <h2 >4.1标题4</h2>
			  <h2 >4.2标题4</h2>
			  <h2 >4.3标题4</h2>
			  <h3 >4.1.1标题4</h3>
			  <h3 >4.1.2标题4</h3>
			  <h3 >4.1.3标题4</h3>
			    <div/>
		    `
			let reg = /(<h[1-6][\s\S]*?>)[\s\S]*?(<\/h[1-6]>)/igm;
			let resultList = contentText.match(reg);
			console.log(resultList)

我们现在修改一下需要匹配的内容再来匹配一下，可以看到就出现问题了,第一个h标签是h2结尾但是我们也匹配成功了。

			let contentText =
				`
			 <div> 
			  <h1 >2.标题2</h2>
			  <h2 >2.1标题2</h2>
			  <h2 >2.2标题2</h2>
			  <h2 >2.3标题2</h2>
			  <h3 >2.1.1标题2</h3>
			  <h3 >2.1.2标题2</h3>
			  <h3 >2.1.3标题2</h3>
			   <div/>
		    `
			let reg = /(<h[1-6][\s\S]*?>)[\s\S]*?(<\/h[1-6]>)/igm;
			let resultList = contentText.match(reg);
			console.log(resultList)

接下来让我们使用回溯引用匹配来进行解决

7.21 回溯引用

我们先来看一个简单的例子：我们现在想匹配出现两次重复的单次，并且前后有空白字符

			let webText =
				`This is a block of of text,several words here are arerepeated, and and they
should not be.
`;
			let myReg = /[\s](\w+)[\s]\1/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

这个表达式很简单，后面 \1 表示将前面的规则完全再次引用一次，相当于就是个变量 ,\1 表示第一个子表达式,\2 表示第二个子表达式,依次类推。

现在我们通过回溯引用,就可以解决这种问题的出现

let contentText =
				`
			 <div> 
			  <h1 >2.标题2</h2>
			  <h2 >2.1标题2</h2>
			  <h2 >2.2标题2</h2>
			  <h2 >2.3标题2</h2>
			  <h3 >2.1.1标题2</h3>
			  <h3 >2.1.2标题2</h3>
			  <h3 >2.1.3标题2</h3>
			   <div/>
		    `
			let reg = /<h([1-6])[\s\S]*?>[\s\S]*?<\/h\1>/igm
			let resultList = contentText.match(reg);
			console.log(resultList)

\0 :可以代表整个正在表达式

7.22 向前查找

向前查找指定了一个必须匹配但不在结果中返回的模式。向前查找实际就是一个子表达式，而且从格式上看也确实如此。从语法上看，-一-个向前查找模式其实就是一个以?=开头的子表达式，需要匹配的文本跟在=的后面。

比如我们现在想查询出这些地址的一个协议名称。

	        let webText = `
			http:// www.forta.com/
			https:// mail.forta.com/ 
			ftp://lftp.forta.com/`;
			let myReg = /.+[^\s](?=:)/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

7.23 向后查找

正如你刚看到的那样，?=将向前查找（查找出现在被匹配文本之后的字符，但不消费那个字符)。因此，?=被称为向前查找操作符。除了向前查找，许多正则表达式实现还支持向后查找，也就是查找出现在被匹配文本之前的字符（但不消费它)，向后查找操作符是?<=。

比如提取出下面的价格：

		let webText = `
			ABC01 : $23.45
			HGG42:$5.31
			CFMX1: $899.oo
			xTC99: $69.96
     		Total items found: 4
`;
			let myReg = /(?<=\$)[0-9.]+/img;
			let myResult = webText.match(myReg);
			console.log(myResult)

8.常见正则表达式

	一、校验数字的表达式
 1. 数字：^[0-9]*$
 2. n位的数字：^\d{n}$
 3. 至少n位的数字：^\d{n,}$
 4. m-n位的数字：^\d{m,n}$
 5. 零和非零开头的数字：^(0|[1-9][0-9]*)$
 6. 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$
 7. 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$
 8. 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
 9. 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
 10. 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
 11. 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
 12. 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
 13. 非负整数：^\d+$ 或 ^[1-9]\d*|0$
 14. 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
 15. 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
 16. 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
 17. 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
 18. 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
 19. 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
 
 
二、校验字符的表达式
 1. 汉字：^[\u4e00-\u9fa5]{0,}$
 2. 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
 3. 长度为3-20的所有字符：^.{3,20}$
 4. 由26个英文字母组成的字符串：^[A-Za-z]+$
 5. 由26个大写英文字母组成的字符串：^[A-Z]+$
 6. 由26个小写英文字母组成的字符串：^[a-z]+$
 7. 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
 8. 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
 9. 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
 10. 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
 11. 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+12 禁止输入含有~的字符：[^~\x22]+
 
 

三、特殊需求表达式
 1. Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
 2. 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
 3. InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
 4. 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
 5. 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
 6. 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
 7. 身份证号(15位、18位数字)：^\d{15}|\d{18}$
 8. 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
 9. 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
 10. 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
 11. 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$?
 12. 日期格式：^\d{4}-\d{1,2}-\d{1,2}
 13. 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
 14. 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$
 15. 钱的输入格式：
  1） 有四种钱的表示形式我们可以接受:"10000.00"?和?"10,000.00", 和没有?"分"?的?"10000"?和?"10,000"：^[1-9][0-9]*$
  2） 这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$
  3） 一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$
  4） 这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$
  5） 必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是?"10"?和?"10.2"?是通过的：^[0-9]+(.[0-9]{2})?$
  6） 这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$
  7） 这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
  8） 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
   备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
 16. xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
 17. 中文字符的正则表达式：[\u4e00-\u9fa5]
 18. 双字节字符：[^\x00-\xff]??? (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
 19. 空白行的正则表达式：\n\s*\r??? (可以用来删除空白行)
 20. HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? />??? (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
 21. 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$)??? (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
 22. 腾讯QQ号：[1-9][0-9]{4,}??? (腾讯QQ号从10000开始)
 23. 中国邮政编码：[1-9]\d{5}(?!\d)??? (中国邮政编码为6位数字)
 24. IP地址：\d+\.\d+\.\d+\.\d+??? (提取IP地址时有用)
 25. IP地址：((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)

更多详细内容请参考：https://www.jq22.com/chm/jquery/regexp.html

野生java研究僧

关注

4
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
正则表达式（各语言通用）

正则表达式修饰符正则表达式是程序员必备的一个知识点，不管是做数据处理，还是前端的表单验证都是非常好用的，掌握好正则表达式是非常必须的，下面为大家介绍了正则表达式的用法和一些技巧。正则表达式修饰符i 执行对大小写不敏感的匹配。g 执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。m 执行多行匹配。正则表达式模式括号用于查找一定范围的字符串：[abc] 查找方括号之间的任何字符。[0-9] 查找任何从 0 至 9 的数字。(x|y) 查找由 | 分隔的任何选项。元字符（Metacha
复制链接

扫一扫