详述RegExp的使用

最新推荐文章于 2022-03-20 13:43:58 发布

转载最新推荐文章于 2022-03-20 13:43:58 发布 · 3.3k 阅读

文章标签：

#javascript #RegExp #正则

javascript 专栏收录该内容

12 篇文章

订阅专栏

本文深入解析JavaScript正则表达式的使用方法，涵盖基本语法、高级特性及应用场景，如匹配测试、子匹配、全局匹配等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

忘了从哪儿转的，这个页面详述了js正则使用的方方面面，遇到有疑惑的地方看一下这个页面就清楚了

<!DOCTYPE html>
<html>
<head>
    <title>正则表达式</title>
    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
    <script type="text/javascript">
        //test方法,测试字符串,符合模式时返回true,否则返回false
        var re = /he/;//最简单的正则表达式,将匹配he这个单词
        var str = "he";
        console.log(re.test(str));//true
        str = "we";
        console.log(re.test(str));//false
        str = "HE";
        console.log(re.test(str));//false,大写,如果要大小写都匹配可以指定i标志(i是ignoreCase或case-insensitive的表示)
        re = /he/i;
        console.log(re.test(str));//true
        str = "Certainly!He loves her!";
        console.log(re.test(str));//true,只要包含he(HE)就符合,如果要只是he或HE,不能有其它字符,则可使用^和$
        re = /^he/i;//脱字符(^)代表字符开始位置
        console.log(re.test(str));//false,因为he不在str最开始
        str = "He is a good boy!";
        console.log(re.test(str));//true,He是字符开始位置,还需要使用$
        re = /^he$/i;//$表示字符结束位置
        console.log(re.test(str));//false
        str = "He";
        console.log(re.test(str));//true
        //当然,这样不能发现正则表达式有多强大,因为我们完全可以在上面的例子中使用==或indexOf
        re = /\s/;// \s匹配任何空白字符，包括空格、制表符、换页符等等
        str = "user Name";//用户名包含空格
        console.log(re.test(str));//true
        str = "user		Name";//用户名包含制表符
        console.log(re.test(str));//true
        re = /^[a-z]/i;//[]匹配指定范围内的任意字符,这里将匹配英文字母,不区分大小写
        str = "variableName";//变量名必须以字母开头
        console.log(re.test(str));//true
        str = "123abc";
        console.log(re.test(str));//false

        // 当然,仅仅知道了字符串是否匹配模式还不够,我们还需要知道哪些字符匹配了模式
        var osVersion = "Ubuntu 8";//其中的8表示系统主版本号
       	var re = /^[a-z]+\s+\d+$/i; //+号表示字符至少要出现1次,\s表示空白字符,\d表示一个数字
       	console.log(re.test(osVersion));//true,但我们想知道主版本号
       	//另一个方法exec,返回一个数组,数组的第一个元素为完整的匹配内容
       	re=/^[a-z]+\s+\d+$/i;
       	arr = re.exec(osVersion);
       	console.log(arr[0]);//将osVersion完整输出,因为整个字符串刚好匹配re
       	//我只需要取出数字
       	re=/\d+/;
       	var arr = re.exec(osVersion);
       	console.log(arr[0]);//8

        // 更复杂的用法,使用子匹配
        // exec返回的数组第1到n元素中包含的是匹配中出现的任意一个子匹配
        re=/^[a-z]+\s+(\d+)$/i;//用()来创建子匹配
        arr =re.exec(osVersion);
        console.log(arr[0]);//整个osVersion,也就是正则表达式的完整匹配
        console.log(arr[1]);//8,第一个子匹配,事实也可以这样取出主版本号
        console.log(arr.length);//2
        osVersion = "Ubuntu 8.10";//取出主版本号和次版本号
        re = /^[a-z]+\s+(\d+)\.(\d+)$/i;//.是正则表达式元字符之一,若要用它的字面意义须转义
        arr = re.exec(osVersion);
        console.log(arr[0]);//完整的osVersion
        console.log(arr[1]);//8
        console.log(arr[2]);//10

        // 注意,当字符串不匹配re时,exec方法将返回null

        // replace方法,用于替换字符串
        var str ="some money";
        console.log(str.replace("some","much"));//much money
        //replace的第一个参数可以为正则表达式
        var re = /\s/;//空白字符
        console.log(str.replace(re,"%"));//some%money
        //在不知道字符串中有多少空白字符时,正则表达式极为方便
        str ="some some 			\tsome\t\f";
        re = /\s+/;
        console.log(str.replace(re,"#"));//但这样只会将第一次出现的一堆空白字符替换掉
        //因为一个正则表达式只能进行一次匹配,\s+匹配了第一个空格后就退出了
        re = /\s+/g;//g,全局标志,将使正则表达式匹配整个字符串
        console.log(str.replace(re,"@"));//some@some@some@
        //另一个与之相似的是split
        var str = "a-bd-c";
        var arr = str.split("-");//返回["a","bd","c"]
        //如果str是用户输入的,他可能输入a-bd-c也可能输入a bd c或a_bd_c,但不会是abdc(这样就说他输错了)
        str = "a_db-c";//用户以他喜欢的方式加分隔符s
        re=/[^a-z]/i;//前面我们说^表示字符开始,但在[]里它表示一个负字符集
        //匹配任何不在指定范围内的任意字符,这里将匹配除字母处的所有字符
        arr = str.split(re);//仍返回["a","bd","c"];
        //在字符串中查找时我们常用indexOf,与之对应用于正则查找的方法是search
        str = "My age is 18.Golden age!";//年龄不是一定的,我们用indexOf不能查找它的位置
        re = /\d+/;
        console.log(str.search(re));//返回查找到的字符串开始下标10
        //注意,因为查找本身就是出现第一次就立即返回,所以无需在search时使用g标志
        //下面的代码虽然不出错,但g标志是多余的
        re=/\d+/g;
        console.log(str.search(re));//仍然是10

        // 注意,当search方法没有找到匹配时,将返回-1
        // 类似于exec方法,String对象的match方法也用于将字符串与正则表达式进行匹配并返回结果数组
        var str = "My name is CJ.Hello everyone!";
       	var re = /[A-Z]/;//匹配所有大写字母
       	var arr = str.match(re);//返回数组
       	console.log(arr);//数组中只会包含一个M,因为我们没有使用全局匹配
       	re = /[A-Z]/g;
       	arr = str.match(re);
       	console.log(arr);//M,C,J,H
       	//从字符串中抽取单词
       	re = /\b[a-z]*\b/gi;//\b表示单词边界
       	str = "one two three four";
       	console.log(str.match(re));//one,two,three,four

        //RegExp对象实例的一些属性 
        var re = /[a-z]/i;
       	console.log(re.source);//将[a-z]字符串输出
       	//请注意,直接console.log(re)会将正则表达式连同前向斜线与标志输出,这是re.toString方法定义的

        // 每个RegExp对象的实例具有lastIndex属性,它是被查找字符串中下一次成功匹配的开始位置,默认值是-1。
        // lastIndex 属性被 RegExp 对象的 exec 和 test 方法修改.并且它是可写的.
        var re = /[A-Z]/;
       	//exec方法执行后,修改了re的lastIndex属性,
       	var str = "Hello,World!!!";
       	var arr = re.exec(str);
       	console.log(re.lastIndex);//0,因为没有设置全局标志
       	re = /[A-Z]/g;
       	arr = re.exec(str);
       	console.log(re.lastIndex);//1
       	arr = re.exec(str);
       	console.log(re.lastIndex);//7

        // 当匹配失败（后面没有匹配），或lastIndex值大于字符串长度时，再执行exec等方法会将lastIndex设为0(开始位置)
        var re = /[A-Z]/;
       	var str = "Hello,World!!!";
       	re.lastIndex = 120;
       	var arr = re.exec(str);
       	console.log(re.lastIndex);//0

        // RegExp对象的静态属性 
        // input 最后用于匹配的字符串（传递给test,exec方法的字符串）
        var re = /[A-Z]/;
        var str = "Hello,World!!!";
        var arr = re.exec(str);
        console.log(RegExp.input);//Hello,World!!!
        re.exec("tempstr");
        console.log(RegExp.input);//仍然是Hello,World!!!,因为tempstr不匹配
        //lastMatch 最后匹配的字符
        re = /[a-z]/g;
        str = "hi";
        re.test(str);
        console.log(RegExp.lastMatch);//h
        re.test(str);
        console.log(RegExp["$&"]);//i  ,$&是lastMatch的短名字，但由于它不是合法变量名，所以要。。
        //lastParen 最后匹配的分组
        re = /[a-z](\d+)/gi;
        str = "Class1 Class2 Class3";
        re.test(str);
        console.log(RegExp.lastParen);//1
        re.test(str);
        console.log(RegExp["$+"]);//2
        //leftContext  返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符
        //rigthContext 返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符
        re = /[A-Z]/g;
        str = "123ABC456";
        re.test(str);
        console.log(RegExp.leftContext);//123
        console.log(RegExp.rightContext);//BC456
        re.test(str);
        console.log(RegExp["$`"]);//123A
        console.log(RegExp["$'"]);//C456

        // multiline属性返回正则表达式是否使用多行模式,这个属性不针对某个正则表达式实例，而是针对所有正则表达式，并且这个属性可写.(IE与Opera不支持这个属性) 
        console.log(RegExp.multiline);
        //因为IE，Opera不支持这个属性，所以最好还是单独指定
        var re = /\w+/m;
        console.log(re.multiline);
        console.log(RegExp["$*"]);//RegExp对象的静态属性不会因为给RegExp某个对象实例指定了m标志而改变
        RegExp.multiline = true;//这将打开所有正则表达式实例的多行匹配模式
        console.log(RegExp.multiline);

        // 使用元字符注意事项:元字符是正则表达式的一部分，当我们要匹配正则表达式本身时，必须对这些元字符转义.
        // 下面是正则表达式用到的所有元字符
        // ( [ { \ ^ $ | ) ? * + .

        // 使用RegExp构造函数与使用正则表达式字面量创建正则表达式注意点
        var str = "\?";
       	console.log(str);//只会输出?
       	var re = /\?/;//将匹配?
       	console.log(re.test(str));//true
        try {
            re = new RegExp("\?");//出错,因为这相当于re = /\?/
        } catch (e) {}
       	re = new RegExp("\\?");//正确，将匹配？
       	console.log(re.test(str));//true

        //既然双重转义这么不友好，所以还是用正则表达式字面量的声明方式

        //如何在正则表达式中使用特殊字符？
        //ASCII方式用十六进制数来表示特殊字符
        var re = /^\x43\x4A$/;//将匹配CJ
        console.log(re.test("CJ"));//true
        //也可使用八进制方式
        re = /^\103\112$/;//将匹配CJ
        console.log(re.test("CJ"));//true
        //还可以使用Unicode编码
        re =/^\u0043\u004A$/;//使用 Unicode，必须使用u开头，接着是字符编码的四位16进制表现形式
        console.log(re.test("CJ"));

//        另处，还有一些其它的预定义特殊字符，如下表所示:
//
//        字符    描述
//        \n      换行符
//        \r      回车符
//        \t      制表符
//        \f      换页符（Tab）
//        \cX     与X对应的控制字符
//        \b      退格符(BackSpace)
//        \v      垂直制表符
//        \0      空字符("")
//
//        字符类 ---〉简单类，反向类，范围类，组合类，预定义类
//        下面是正则表达式中的预定义类
//
//
//        代码  等同于                  匹配
//        .     IE下[^\n]，其它[^\n\r]  匹配除换行符之外的任何一个字符
//        \d    [0-9]                   匹配数字
//        \D    [^0-9]                  匹配非数字字符
//        \s    [ \n\r\t\f\x0B]         匹配一个空白字符
//        \S    [^ \n\r\t\f\x0B]        匹配一个非空白字符
//        \w    [a-zA-Z0-9_]            匹配字母数字和下划线
//        \W    [^a-zA-Z0-9_]           匹配除字母数字下划线之外的字符

        //多行模式
        var re = /[a-z]$/;
        var str = "ab\ncdef";
        console.log(str.replace(re,"#"));//ab\ncde#
        re =/[a-z]$/m;
        console.log(str.replace(re,"#"));//a#\ncde#

        // 分组与非捕获性分组
        re = /abc{2}/;//将匹配abcc
       	re = /(abc){2}/;//将匹配abcabc
       	//上面的分组都是捕获性分组
       	str = "abcabc ###";
       	arr = re.exec(str);
       	console.log(arr[1]);//abc
       	//非捕获性分组 (?:)
       	re = /(?:abc){2}/;
       	arr = re.exec(str);
       	console.log(arr[1]);//undefined

        //候选（也就是所说的“或”）
        re = /^a|bc$/;//将匹配开始位置的a或结束位置的bc
        str ="add";
        console.log(re.test(str));//true
        re = /^(a|bc)$/;//将匹配a或bc
        str ="bc";
        console.log(re.test(str));//true

        // 当包含分组的正则表达式进行过test,match,search这些方法之后，每个分组都被放在一个特殊的地方以备将来使用，
        // 这些存储是分组中的特殊值，我们称之为反向引用
        var re = /(A?(B?(C?)))/;
        /*上面的正则表达式将依次产生三个分组
        (A?(B?(C?))) 最外面的
        (B?(C?))
        (C?)*/
        str = "ABC";
        re.test(str);//反向引用被存储在RegExp对象的静态属性$1—$9中
        console.log(RegExp.$1+"\n"+RegExp.$2+"\n"+RegExp.$3);
        //反向引用也可以在正则表达式中使用\1 ,\2...这类的形式使用
        re = /\d+(\D)\d+\1\d+/;
        str = "2008-1-1";
        console.log(re.test(str));//true
        str = "2008-4_3";
        console.log(re.test(str));//false

        // 使用反向引用可以要求字符串中某几个位置上的字符必须相同.另外，在replace这类方法中可用特殊字符序列来表示反向引用
        re = /(\d)\s(\d)/;
        str = "1234 5678";
        console.log(str.replace(re,"$2 $1"));//在这个里面$1表示第一个分组1234,$2则表示5678

        /*其它——〉正向前瞻,用来捕获出现在特定字符之前的字符,只有当字符后面跟着某个特定字符才去捕获它。
        与正向前瞻对应的有负向前瞻，它用匹配只有当字符后面不跟着某个特定字符时才去匹配它。在执行前瞻和负向前瞻之类的运算时，
        正则表达式引擎会留意字符串后面的部分，然而却不移动index */
    	//正向前瞻
        re = /([a-z]+(?=\d))/i;
        //我们要匹配后面跟一个数字的单词，然后将单词返回，而不要返回数字
        str = "abc every1 abc";
        console.log(re.test(str));//true
        console.log(RegExp.$1);//every
        console.log(re.lastIndex);//使用前瞻的好处是,前瞻的内容(?=\d)并不会当成一次匹配，下次匹配仍从它开始
        //负向前瞻(?!)
        re = /([a-z](?!\d))/i;
        //将匹配后面不包含数字的字母,并且不会返回(?!\d)中的内容
        str = "abc1 one";
        console.log(re.test(str));
        console.log(RegExp.$1);//one

        /* 构建一个验证电子邮箱地址有效性的正则表达式。电子邮箱地址有效性要求(我们姑且这样定义)：
        用户名只能包含字母数字以及下划线，最少一位，最多25位，用户名后面紧跟@，
        后面是域名，域名名称要求只能包含字母数字和减号（-），并且不能以减号开头或结尾，
        然后后面是域名后缀（可以有多个），域名后缀必须是点号连上2-4位英文字母 */
        var re = /^\w{1,15}(?:@(?!-))(?:(?:[a-z0-9-]*)(?:[a-z0-9](?!-))(?:\.(?!-)))+[a-z]{2,4}$/;


    </script>
</head>
<body>

</body>
</html>