正则表达式

嘧

于 2022-08-17 20:14:29 发布

阅读量83

点赞数

分类专栏： js入门学习文章标签：正则表达式 javascript ecmascript

本文链接：https://blog.csdn.net/qq_50748038/article/details/126353142

版权

js入门学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

正则表达式是由一个字符序列形成的搜索模式，可用于所有文本搜索和文本替换的操作。

1、正则表达式创建

（1）字面量形式

// var reg = /条件/匹配模式g i m
// '//'里面的内容不需要加引号 不管是数字型还是字符串型
var reg = /正则表达式/修饰符;
var reg = /hello/g

（2）构造函数创建正则表达式

// var reg = new RegExp('正则表达式','匹配模式')
var reg = new RegExp('hello','g')

（3）匹配模式m/i/g

i：ignoreCase，表示匹配时忽视大小写

m：multiline，表示多行匹配

g：global，表示全局匹配

字面量形式创建正则表达式时，模式修饰符写在一对反斜线之后

2、正则表达式实例方法

（1）exec

用于匹配字符串中符合正则表达式的字符串

语法：正则表达式.exec(str)

var str = 'hello world';
var reg = /hello/g;
var res = reg.exec(str);
console.log(res);//[ 'hello', index: 0, input: 'hello world', groups: undefined ]

返回值：a.没有匹配到，返回null b.匹配到，返回一个数组：[匹配内容，index:数组中匹配的起始位置，input:参数字符串，group:undefined]

注意：当匹配模式有'g'时，正则表达式的实例属性lastIndex会记录下一次开始的位置，在第二次执行exec时，将从lastIndex开始检索，直到为null，又重新从下标为0的位置开始检索；如果匹配模式没有'g'，则每次执行exec都会从开始的位置检索。

（2）test

用于检测字符串中是否有与正则表达式匹配的字符串，有则返回true，没有返回false

var str = 'hello world';
var str1 = 'good'
var reg = /hello/g;
var res = reg.test(str);
console.log(res);//true
console.log(reg.test(str1));//false

注意：匹配模式有/无'g'时，检索规则都与exec注意点相同

3、正则表达式语法

（1）字符集合

[abc] 查找方括号之间的任何字符，只要包含其一都返回true

var str = 'apple'
var reg = /[abc]/;
console.log(reg.test(str)); //true

[^abc] 反义/补充字符集匹配任意不在括号内的字符，只要有一个不是abc其中之一的都返回true

var str = 'a1'
var str1 = 'abc1'
var str2 = 'a'
var str3 = 'abc'
var reg = /[^abc]/;
console.log(reg.test(str)); //true
console.log(reg.test(str1)); //true
console.log(reg.test(str2)); //false
console.log(reg.test(str3)); //false

[0-9] 查找任何0至9之间的数字只要包含其中一个数字都返回true

（2）边界符(^,$,\b,\B)

^：匹配输入开始，定义要验证的字符串以谁开始

//必须以good开头的才满足正则表达式
var reg = /^good/;
console.log(reg.test('good123')); // true
console.log(reg.test('1good12')); // false
console.log(reg.test('g123ood')); // false
//必须满足至少以good其中一个字符开头
var reg = /^[good]/;
console.log(reg.test('123'));     // false
console.log(reg.test('oo3'));     // true
console.log(reg.test('good123')); // true
console.log(reg.test('1good12')); // false
console.log(reg.test('g123ood')); // true

$：匹配输入结束，定义要验证的字符串以谁结束

//必须满足至少以good其中一个字符结尾才满足正则表达式
var reg = /[good]$/
console.log(reg.test('3oo')); // true
console.log(reg.test('123good')); // false
console.log(reg.test('1good12')); // true
console.log(reg.test('g123ood')); // false
//必须以good结尾的才满足正则表达式
var reg = /good$/;
console.log(reg.test('3oo')); // false
console.log(reg.test('123good')); // true
console.log(reg.test('1good12')); // false
console.log(reg.test('g123ood')); // false

^&$同时使用，表示精确匹配

//要验证的字符串只能是good其中一个字符
var reg = /^[good]$/
console.log(reg.test('o')); // true
console.log(reg.test('good')); // false
console.log(reg.test('g')); // true
console.log(reg.test('gd')); // false
//精确匹配，要验证的字符串必须是good
var reg = /^good$/;
console.log(reg.test('o')); // false
console.log(reg.test('good')); // true
console.log(reg.test('g')); // false
console.log(reg.test('gd')); // false

\b：匹配一个零宽单词边界，单词边界即是单词和符号之间的边界，

\B：匹配一个零宽非单词边界，与\b相反

var reg1 = /\bgood\b/g;
console.log(reg1.test('I am good'));//true
console.log(reg1.test('I good am'));//false
console.log(reg1.test('good'));//true
console.log(reg1.test('good I am '));//false
console.log(reg1.test('Iamgood'));//false
console.log(reg1.test('good,I am'));//true

（3）字符类

.：匹配除换行符\n和回车符\r外的任何单个字符

. => [^\n\r]

var reg = /./g;
console.log(reg.exec('z1-\n'));//[ 'z', index: 0, input: 'zxl', groups: undefined ]
console.log(reg.exec('z1-\n'));//[ '1', index: 1, input: 'zxl', groups: undefined ]
console.log(reg.exec('z1-\n'));//[ '-', index: 2, input: 'zxl', groups: undefined ]
console.log(reg.exec('z1-\n'));//null

\d：匹配0-9之间的一个数字字符

\d => [0-9]

var reg = /\d/g;
console.log(reg.exec('z1-'));//[ '1', index: 1, input: 'z1-', groups: undefined ]
console.log(reg.exec('z1-'));//null

\D：匹配除了0-9外的字符

\D => [^0-9]

var reg = /\D/g;
console.log(reg.exec('z1-'));//[ '1', index: 0, input: 'z1-', groups: undefined ]
console.log(reg.exec('z1-'));//[ '-', index: 2, input: 'z1-', groups: undefined ]
console.log(reg.exec('z1-'));//null

\w：匹配包括下划线和[a-zA-Z0-9]的任何单个字符。 \w => [a-zA-Z0-9_]

\W：匹配除下划线和[a-zA-Z0-9]的任何单个字符。 [^a-zA-Z0-9_]

\s：匹配任何Unicode空白字符，包括空格、制表符、换页符等. \s => [\f\t\n\r]

\S：匹配除Unicode空白字符外的字符 \S => [^\f\t\n\r]

（4）数量词

字符	含义
*	>=0次
+	>=1次
？	0或1次
{n}	n次
{n,}	>=n次
{n,m}	n至m次

应用：

//* 允许出现至少0次
var reg = /^a*$/;
console.log(reg.test('a')); // true
console.log(reg.test('')); // true
//+ 允许出现至少一次
var reg = /^a+$/;
console.log(reg.test('a')); // true
console.log(reg.test('')); // false
//? 允许出现0次或1次
var reg = /^a?$/;
console.log(reg.test('a')); // true
console.log(reg.test('')); // true
console.log(reg.test('aa'));//false
//{n} 允许出现n次 n为非负整数
var reg = /^a{1}$/;
console.log(reg.test('a')); //true
console.log(reg.test('aa'));//false
//{n,} 至少出现n次 n为非负整数
var reg = /^a{1,}$/;
console.log(reg.test('')); // false
console.log(reg.test('a')); //true
console.log(reg.test('aa'));//true
//{n,m} 允许出现n到m次 n,m为非负整数
var reg = /^a{1,2}$/;
console.log(reg.test('aaa')); // false
console.log(reg.test('a')); //true
console.log(reg.test('aa'));//true

（5）重复方式

a.贪婪模式：尽可能多的匹配，最先取最大匹配数量为一组进行匹配，为默认模式

// 对字符串"12345"，匹配其中的数字1到3次：\d{1,3}，先匹配数字出现3次的字符串（123），然后再从剩余字符串（45）中匹配出现数字2次的情况，在到出现数字一次的情况，匹配完则返回null
var str = "12345";
var reg = /\d{1,3}/g;
console.log(reg.exec(str)); //[ '123', index: 0, input: '12345', groups: undefined ]
console.log(reg.exec(str)); // [ '45', index: 3, input: '12345', groups: undefined ]
console.log(reg.exec(str)); // null

b.非贪婪模式：于贪婪模式相反，每次取最少匹配的数量为一组进行匹配，直到匹配完不到。

//非贪婪模式使用方法：在数量词后加上?
var str = "12345";
var reg = /\d{2,3}?/g;
console.log(reg.exec(str)); //[ '12', index: 0, input: '12345678', groups: undefined ]
console.log(reg.exec(str)); // [ '34', index: 2, input: '123456789', groups: undefined ]
console.log(reg.exec(str)); // null

4、选择，分组，引用

（1）选择 '|'

"|"用于分隔选择项，匹配次序是从左到右，直到发现了匹配项，如果左边的选择项匹配，就忽略右边的匹配项，下一次执行exec将从上次匹配结束的地方为起始位置开始进行匹配。

var str = "helloworldhellohtml";
var reg = /hello|world|html/g;
console.log(reg.exec(str)); //[ 'hello', index: 0, input: 'helloworldhellohtml', groups: undefined ]
console.log(reg.exec(str)); // [ 'world', index: 5, input: 'helloworldhellohtml', groups: undefined ]
console.log(reg.exec(str)); // [ 'hello', index: 10, input: 'helloworldhellohtml', groups: undefined ]

（2）分组

var reg = /hellohellohello/ 等效于 var reg = /(hello){3}/ 圆括号包裹的内容作为一个整体成为分组。一个分组中可以有多个候选表达式，用'|'分隔开：

var reg = /I have a (pen|apple|applepen)/;
console.log(reg.test('I have a pen')); //true
console.log(reg.test('Ihave a apple')); //true
console.log(reg.test('I have a applepen')); //true

（3）引用

正则表达式里可以进行引用，称为反向引用：

var reg = /(\w{3}) is \1/
console.log(reg.test('abc is abc')); // true
console.log(reg.test('bca is bca')); // true
console.log(reg.test('abc is bca')); // false
console.log(reg.test('abc is \1')); // false
//注意：这里\1编号不能越界，不然会被当作普通的字符
var reg = /(\w{3}) is \6/;
reg.test( 'kid is kid' ); // false
reg.test( 'kid is \6' );  // true