正则表达式笔记2：正则表达式语法基础（JavaScript）

最新推荐文章于 2022-01-05 20:23:35 发布

HaanLen

最新推荐文章于 2022-01-05 20:23:35 发布

阅读量180

点赞数

分类专栏： JavaScript-ECMAscript

本文链接：https://blog.csdn.net/weixin_40119412/article/details/103927519

版权

JavaScript-ECMAscript 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

字符描述

元字符

元字符	描述
.	查找单个字符，除了换行和行结束符
\w	查找单词字符
\W	查找非单词字符
\d	查找数字
\D	查找非数字字符
\s	查找空白字符
\S	查找非空白字符
\b	查找单词边界
\B	查找非单词边界
\0	查找NUL字符
\n	查找换行符
\f	查找换页符
\r	查找回车符
\f	查找制表符
\v	查找垂直制表符
\xxx	查找以八进制数XXX规定的字符
\xdd	查找以十六进制数dd规定的字符
\uxxxx	查找以十六进制数xxxx规定的Unicode字符

var r=/\x61/;
var s="javascript";
var a=s.match(r);
alert(a);//a

var r=/\s/;
var s="javascript Java";
var a=r.test(s);
alert(a);//true

var r=/\141/;//八进制
var s="javascript Java";
var a=s.match(r);
alert(a);//a

var r=/\u0061/;
var s="javascript Java";
var a=s.match(r);
alert(a);//a

字符范围

在正则表达式语法中，方括号表示用来查找特定范围内的字符，在方括号内仅指定起止字符，然后中间部分通过连字符（-）表示。如果方括号内添加脱字符（^）前缀，就表示定义除范围之外的字符。

[abc]：查找方括号之间的任何字符。
[^abc]：查找任何不在方括号之间的字符。
[0-9]：查找任何从0-9的数字，即查找任何数字。
[a-z]：查找任何从小写a到小写z字符，即查找任何小写字母。
[A-Z]：查找任何从大写A到大写Z字符，即查找任何大写字母。
[A-z]：查找任何从大写a到小写z字符，即查找任何形式字母。
[adgk]：查找给定集合内的任何字符。
[^adgk]：查找给定集合外的任何字符。

匹配任何ASCII字符

var r=/[\u0000-\u00ff\/g;

匹配任意双字节的汉字

var r=/[^\u0000-\u00ff\/g;

匹配任意大写字母

var r=/[\u0041-\u004A]/g;

匹配任意小写字母

var r=/[\u0061-\u007A]/g;

匹配任意大小写字母和数字

var r=/[a-zA-Z0-9]/g;

选择操作

使用竖线（|）描述，表示两个子模式的匹配结果中任选一个。

var s1="abc";
var s2="123";
var r=/\w+|\d+/;//选择重复字符类
var b1=r.test(s1);
var b2=r.test(s2);
alert(b1);//true
alert(b2);//true

var s1="abc";
var s2="123";
var s3="def";
var s4="456";
var r=/(abc)|(123)|(def)|(456)/;//选择重复字符类
var b1=r.test(s1);
var b2=r.test(s2);
var b3=r.test(s3);
var b4=r.test(s4);
alert(b1);//true
alert(b2);//true
alert(b3);//true
alert(b4);//true

var s="a'b?c&";
var r=/\'|\"|\?|\&/gi;//过滤敏感字符的正则表达式
function f(){
	return "&#"+arguments[0].charCodeAt(0)+";";
}
var a=s.replace(r,f);
document.write(a);//a'b?c&
alert(a);//a&#39;b&#63;c&#38;

重复类量词

重复类量词列表

量词	描述
n+	匹配任何包含至少一个n的字符串
n*	匹配任何包含零个或多个n的字符串
n?	匹配任何包含零个或一个n的字符串
n{x}	匹配包含x个n的序列的字符串
n{x,y}	匹配包含x或y个n的序列的字符串
n{x,}	匹配包含至少x个n的序列的字符串

var s="ggle gogle google gooogle gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go?gle/g;
var a=s.match(r);
alert(a);//ggle,gogle

var s="ggle gogle google gooogle gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go{0,1}gle/g;
var a=s.match(r);
alert(a);//ggle,gogle

var s="ggle gogle google gooogle gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go{3}gle/g;
var a=s.match(r);
alert(a);//gooogle,gooogle

var s="ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/gooogle/g;
var a=s.match(r);
alert(a);//gooogle

var s="ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go{3,5}gle/g;
var a=s.match(r);
alert(a);//gooogle,goooogle,gooooogle

var s="ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go*gle/g;
var a=s.match(r);
alert(a);//ggle,gogle,google,gooogle,goooogle,gooooogle,goooooogle,gooooooogle,goooooooogle

var s="ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go{0,}gle/g;
var a=s.match(r);
alert(a);//ggle,gogle,google,gooogle,goooogle,gooooogle,goooooogle,gooooooogle,goooooooogle

var s="ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go+gle/g;
var a=s.match(r);
alert(a);//gogle,google,gooogle,goooogle,gooooogle,goooooogle,gooooooogle,goooooooogle

var s="ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";
var r=/go{1,}gle/g;
var a=s.match(r);
alert(a);//gogle,google,gooogle,goooogle,gooooogle,goooooogle,gooooooogle,goooooooogle

惰性模式

重复类量词都具有贪婪性，在条件允许的前提下，会匹配尽可能多的字符。

？、{n}和{n,m}重复类量词具有贪婪性，表现为贪婪的有限性。
*、+和{n,}重复类量词具有强贪婪性，表现为贪婪的无限性。

越是排在左侧的重复类量词匹配优先级越高。

var s="<html><head><title></title></head><body></body></html>";
var r=/(<.*>)(<.*>)/;
var a=s.match(r);
alert(a[1]);//<html><head><title></title></head><body></body>
alert(a[2]);//</html>

与贪婪匹配相反，惰性匹配在满足条件的前提下，尽可能少地匹配字符。
定义惰性匹配方法，在重复类量词后面添加英文问号（?）后缀。

var s="<html><head><title></title></head><body></body></html>";
var r=/<.*?>/;
var a=s.match(r);
alert(a);//<html>

6种重复类的惰性匹配简单描述：

{n，m}?：尽量匹配n次，但是为了满足限定条件也可能最多重复m次。
{n}?：尽量匹配n次。
{n,}?：尽量匹配n次，但是为了满足限定条件也可能匹配任意次。
??：尽量匹配，但是为了满足限定条件也可能最多匹配1次，相当于{0,1}？。
+？：尽量匹配1次，但是为了满足限定条件也可能匹配任意次，相当于{1,}?。
*?：尽量不匹配，但是为了满足限定条件也可能匹配任意次，相当于{0,}?。

var s="<html><head><title></title></head><body></body></html>";
var r=/<.*>?/;
var a=s.match(r);
alert(a);//<html><head><title></title></head><body></body></html>

边界量词

边界就是确定匹配模式的位置，如字符串的头部和尾部。
JavaScript正则表达式支持的边界元字符

量词	说明
^	匹配开头，在多行检测中，会匹配一行的开头
$	匹配结尾，在多行检测中，会匹配一行的结尾

var s="how are you";
var r=/(?:\w+)$/;
var a=s.match(r);
alert(a);//you

var s="how are you";
var r=/^(?:\w+)/;
var a=s.match(r);
alert(a);//how

var s="how are you";
var r=/(?:\w+)/g;
var a=s.match(r);
alert(a);//how,are,you

声明量词

声明量词包括正向声明和反向声明两种模式。

正向声明：声明表示条件的意思，是指定匹配模式后面的字符必须被匹配，但不返回匹配结果，正向声明使用“?=匹配条件”表示。

var s="a:123 b=345";
var r=/\w*(?==)/;
var a=s.match(r);
alert(a);//b

反向声明：指定接下来的字符都不必匹配。反向声明“(?!匹配条件”来表示。

var s="a:123 b=345";
var r=/\w*(?!=)/;
var a=s.match(r);
alert(a);//a

说明：声明虽然包含在小括号，但不是分组。JavaScript仅支持正向声明，而不支持反向声明。

表达式分组

使用小括号操作符可以对正则表达式字符串进行任意分组，在小括号内的字符串表示子表达式，或者称为子模式，子表达式具有独立的匹配功能，匹配结果也具有独立性。同时跟随在小括号后的量词将会作用于整个子表达式。
在正则表达式中，表达式分组具有极高的应用价值。

var s="javascript is not java";
var r=/java(script)?/g;
var a=s.match(r);
alert(a);//javascript,java

var s="ab=21,bc=45,cd=43";
var r=/(\w+)=(\d*)/;
var a=s.match(r);
alert(a);//ab=21,ab,21

var s="<h1>title<h1><p>text<p>";
var r=/(<\/?\w+>).*\1/g;
var a=s.match(r);
alert(a);//<h1>title<h1>,<p>text<p>

var s="<h1>title<h1><p>text<p>";
var r=/((<\/?\w+>).*\2)/g;
var a=s.match(r);
alert(a);//<h1>title<h1>,<p>text<p>

var s="<h1>title</h1><p>text</p>";
var r=/((<\/?\w+>).*\2)/g;
var a=s.match(r);
alert(a);//null

var s="<h1>title</h1><p>text</p>";
var r=/((<\/?\w+>).*((<\/?\w+>)))/g;
var a=s.match(r);
alert(a);//<h1>title</h1><p>text</p>

子表达式引用

在正则表达式执行匹配运算时，表达式计算会自动把每个分组（子表达式）匹配的文本临时存储起来备将来使用。这些存储在分组中的特殊值，被称为反向引用。反向引用将遵循从左到右的顺序，根据表达式中的左括号字符的顺序进行创建和编号。

var s="abcdefghijklmn";
var r=/(a(b(c)))/;
var a=s.match(r);
alert(a);//abc,abc,bc,c

反向引用在应用开发中主要包含以下几种常规用法。

var s="abcdefghijklmn";
var r=/(\w)(\w)(\w)/;
r.test(s);
alert(RegExp.$1);//a
alert(RegExp.$2);//b
alert(RegExp.$3);//c

var s="abcbcacba";
var r=/(\w)(\w)(\w)\2\3\1\3\2\1/;
var b=r.test(s);
alert(b);//true

var s="aa11bb22c3d4e5f6";
var r=/(\w+?)(\d+)/g;
var b=s.replace(r,"$2$1");
alert(b);//11aa22bb3c4d5e6f

说明：正则表达式分组会占用一定的系统资源，在较长的正则表达式中，存储反向引用会降低匹配速度。但是很多时候使用分组仅是为了设置操作单元，而不是为了引用，这时候如果选用一种非引用分组，就不会创建反向引用。

var s1="abc";
var s2="123";
var r=/(?:\w*?)|(?:\d*?)/;//非引用型分组
var a=r.test(s1);
var b=r.test(s2);
alert(a);//true
alert(b);//true