JavaScript的正则表达式

一、概念
二、修饰符
三、元字符
四、限定符
五、特殊符号
六、正则表达式的属性
七、正则表达式的方法
- 1. test
- 2. exec
八、常用的配合正则的字符串方法
九、常用的正则表达式

一、概念

正则表达式(Regular Expression, 规则表达式)：使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式，可用于文本搜索和文本替换。

简称：

Regex
RegExp
RE
Reg
Pattern
模式
正则

JavaScript的正则语法：/正则表达式主体/修饰符(可选)

JavaScript创建一个正则表达式

  const string = "123";
  //示例1 字面量创建
  const regex1 = /\d+/; // 正则表达式形式
  const regex2 = "12"; // 字符串形式
  console.log(string.match(regex1));  // 输出：["123"]
  console.log(string.match(regex2));  // 输出：["12"]
  //示例2 构造函数创建
  const regex3 = new RegExp(/\d+/); // 正则表达式形式
  const regex4 = new RegExp("12"); // 字符串形式
  console.log(string.match(regex3));  // 输出：["123"]
  console.log(string.match(regex4));  // 输出：["12"]

二、修饰符

1. g (global, 全局)

在字符串中查找所有匹配项，而不仅仅是第一个匹配项

  //示例
  const string = "AaAa";
  const regex1 = /a/;
  const regex2 = /a/g;
  console.log(string.match(regex1));  // 输出：["a"]
  console.log(string.match(regex2));  // 输出：["a", "a"]

2. i (ignore case, 不区分大小写)

在匹配时忽略大小写

  //示例
  const string = "A";
  const regex1 = /a/;
  const regex2 = /a/i;
  console.log(string.match(regex1));  // 输出：null
  console.log(string.match(regex2));  // 输出：["A"]

3. m (multi-line, 多行)

使元字符中开始标识符(^)和结束标识符($)可以在每一行的开始和结束处匹配，而不仅仅在整个字符串的开始和结束处，即可以同时匹配每一行的内容，而不仅仅是整个字符串

  const string = "a\nA";
  // 示例1
  const regex1 = /^A/;
  const regex2 = /^A/m;
  console.log(string.match(regex1));  // 输出：null
  console.log(string.match(regex2));  // 输出：["A"]
  // 示例2
  const regex3 = /a$/;
  const regex4 = /a$/m;
  console.log(string.match(regex3));  // 输出：null
  console.log(string.match(regex4));  // 输出：["a"]

4. s (single-line, 单行)

使元字符点号(.)可以匹配包括换行符在内的所有字符，默认情况下的元字符点号(.)不匹配换行符

  //示例
  const string = "a\nA";
  const regex1 = /.+/;
  const regex2 = /.+/s;
  console.log(string.match(regex1));  // 输出：["a"]
  console.log(string.match(regex2));  // 输出：["a\nA"]

5. u (Unicode, Unicode字符)

使正则表达式可以正确处理Unicode字符，\u{} 可以用来表示一个Unicode代码点

  //示例1
  const string1 = "😀";
  const regex1 = /\u{1F600}/u
  console.log(string1.match(regex1)); // 输出：["😀"]
  //示例2
  const string2 = "😀😃😊😇🙃🤔🙄😣😢😭";
  const regex2 = /[\u{1F600}-\u{1F64F}]/gu;
  console.log(regex2.test(string2)); // 输出：true

6. y (sticky, 粘性)

后一次匹配都从上一次匹配成功的下一个位置开始

  //示例
  const string = "aA";
  const regex1 = /[aA]/;
  const regex2 = /[aA]/y;
  console.log(string.match(regex1));  // 输出：["a"]
  console.log(string.match(regex1));  // 输出：["a"]，因为每次匹配的位置都是重新开始
  console.log(string.match(regex2));  // 输出：["a"]
  console.log(string.match(regex2));  // 输出：["A"]，因为这次匹配是从上次匹配后的位置开始
  console.log(regex1.sticky);  // 输出：false
  console.log(regex2.sticky);  // 输出：true

三、元字符

1. . (匹配非换行符\n的任意一个字符)

 //示例
  const string = "\nabc";
  const regex = /./;
  console.log(string.match(regex));  // 输出：["a"]

2. \d (匹配数字)

  //示例
  const string = "abc123";
  const regex = /\d/;
  console.log(string.match(regex));  // 输出：["1"]

3. \D (匹配除数字以外的所有字符)

  //示例
  const string = "123abc";
  const regex = /\D/;
  console.log(string.match(regex));  // 输出：["a"]

4. \w (匹配英文字母、数字和下划线_)

  //示例
  const string = "*_*_";
  const regex = /\w/;
  console.log(string.match(regex));  // 输出：["_"]

5. \W (匹配除英文字母、数字和下换线_以外的所有字符)

  //示例
  const string = "*_*_";
  const regex = /\W/;
  console.log(string.match(regex));  // 输出：["*"]

6. \s (匹配空格和tab制表符)

  //示例
  const string = "a a";
  const regex = /\s/;
  console.log(string.match(regex));  // 输出：[" "]

7. \S (匹配除空格和tab制表符以外的所有字符)

  //示例
  const string = " a ";
  const regex = /\S/;
  console.log(string.match(regex));  // 输出：["a"]

8. \b (匹配整个字符串的首尾边界)

  //示例
  const string = "abc";
  const regex1 = /\b/;
  const regex2 = /\b/g;
  console.log(string.replace(regex1, "!"));  // 输出：!abc
  console.log(string.replace(regex2, "!"));  // 输出：!abc!

9. \B (匹配整个字符串的除首尾边界以外的边界)

  //示例
  const string = "abc";
  const regex1 = /\B/;
  const regex2 = /\B/g;
  console.log(string.replace(regex1, "!"));  // 输出：a!bc
  console.log(string.replace(regex2, "!"));  // 输出：a!b!c

10. \ (转义字符，把有意义的符号转换成没有意义的符号，把没有意义的转换成有意义的)

其他有特殊含义的字符：

① \n (换行符)

② \f (换页符)

③ \r (回车符)

④ \t (制表符)

⑤ \v (垂直制表符符)

⑥ \xxx (以八进制数xxx规定的字符)

⑦ \xdd (以十六进制数dd规定的字符)

⑧\uxxxx (以十六进制数xxxx规定的Unicode字符)

  //示例
  const string1 = "a\\b";
  const string2 = "a.b";
  const string3 = "a*b";
  const string4 = "a^b";
  const string5 = "a$b";
  const string6 = "a\nb";
  const string7 = "a\fb";
  const string8 = "a\rb";
  const string9 = "a\tb";
  const string10 = "a\vb";
  const string11 = "ab";
  const string12 = "ab";
  const string13 = "ab";
  const regex1 = /\\/;
  const regex2 = /\./;
  const regex3 = /\*/;
  const regex4 = /\^/;
  const regex5 = /\$/;
  const regex6 = /\n/;
  const regex7 = /\f/;
  const regex8 = /\r/;
  const regex9 = /\t/;
  const regex10 = /\v/;
  const regex11 = /\141/;
  const regex12 = /\x61/;
  const regex13 = /\u0061/;
  console.log(string1.match(regex1));  // 输出：["\\"]
  console.log(string2.match(regex2));  // 输出：["."]
  console.log(string3.match(regex3));  // 输出：["*"]
  console.log(string4.match(regex4));  // 输出：["^"]
  console.log(string5.match(regex5));  // 输出：["$"]
  console.log(string6.match(regex6));  // 输出：["\n"]
  console.log(string7.match(regex7));  // 输出：["\f"]
  console.log(string8.match(regex8));  // 输出：["\r"]
  console.log(string9.match(regex9));  // 输出：["\t"]
  console.log(string10.match(regex10));  // 输出：["\v"]
  console.log(string11.match(regex11));  // 输出：["a"] a的ASCII值为97，转为八进制为141
  console.log(string12.match(regex12));  // 输出：["a"] a的ASCII值为97，转为十六进制为61
  console.log(string13.match(regex13));  // 输出：["a"] a的十六进制Unicode字符为U+0061

11. ^ (开始标识符，在集合字符[^{]里为取非的意义，如[}0-9]表示不包含0-9的数字)

  //示例
  const string1 = "ab";
  const string2 = "ba";
  const regex = /^a/;
  console.log(string1.match(regex));  // 输出：["a"]
  console.log(string2.match(regex));  // 输出：null

12. $ (结束标识符)

  //示例
  const string1 = "ab";
  const string2 = "ba";
  const regex = /a$/;
  console.log(string1.match(regex));  // 输出：null
  console.log(string2.match(regex));  // 输出：["a"]

13. \E (结束\L或\U转换)、\L (把\L到\E之间的字符全部转换为小写)、\U (把\U到\E之间的字符全部转换为大写) (JavaScript不支持)

  // 在JavaScript中，正则表达式本身并不支持\L到\E和\U到\E之间的字符全部转换为小写和大写，在其他实现中的一般效果如下（仅供参考）：
  /*  
    // 示例1 \L到\E实现字符小写
    const string1 = "HELLO";
    const regex1 = /(HE)(LLO)/;
    console.log(string1.replace(regex1, "\L$1\E$2" ));  // 输出：heLLO
  */
  /*  
    // 示例2 \U到\E实现字符大写
    const string2 = "hello";
    const regex2 = /(he)(llo)/;
    console.log(string2.replace(regex2, "\U$1\E$2" ));  // HEllo
  */

14. \l (把下一个字符转换为小写)、\u (把下一个字符转换为大写) (JavaScript不支持)

  // 在JavaScript中，正则表达式本身并不支持\l和\u的一个字符转换为小写和大写，在其他实现中的一般效果如下（仅供参考）：
  /*  
    // 示例1 \l实现字符小写
    const string1 = "HELLO";
    const regex1 = /(HE)(LLO)/;
    console.log(string1.replace(regex1, "\l$1$2" ));  // 输出：hELLO
  */
  /*  
    // 示例2 \u实现字符小写
    const string2 = "hello";
    const regex2 = /(he)(llo)/;
    console.log(string2.replace(regex2, "\u$1$2" ));  // Hello
  */

四、限定符

限定符性质：默认是贪婪性，如果可以的话尽可能多的匹配字符；在限定符后面加上?即为懒惰性，尽可能少的匹配字符。

1. * (重复0次或更多次，匹配失败了一次后就会停止)

  //示例
  const string1 = "a1234";
  const string2 = "1234";
  const string3 = "12a34";
  const regex = /\d*/;
  const regexLazy = /\d*?/;  // 开启懒惰性
  console.log(string1.match(regex));  // 输出：[""]，匹配失败了一次后就停止
  console.log(string1.match(regexLazy));  // 输出：[""]
  console.log(string2.match(regex));  // 输出：["1234"]
  console.log(string2.match(regexLazy));  // 输出：[""]
  console.log(string3.match(regex));  // 输出：["12"]
  console.log(string3.match(regexLazy));  // 输出：[""]

2. + (重复1次或更多次，只有成功匹配了一次后才会停止)

  //示例
  const string1 = "a1234";
  const string2 = "1234";
  const string3 = "12a34";
  const regex = /\d+/;
  const regexLazy = /\d+?/;  // 开启懒惰性
  console.log(string1.match(regex));  // 输出：["1234"]，匹配失败后不停止
  console.log(string1.match(regexLazy));  // 输出：["1"]
  console.log(string2.match(regex));  // 输出：["1234"]
  console.log(string2.match(regexLazy));  // 输出：["1"]
  console.log(string3.match(regex));  // 输出：["12"]，匹配成功了一次后就停止
  console.log(string3.match(regexLazy));  // 输出：["1"]

3. ? (重复0次或1次，匹配失败了一次后就会停止)

  //示例
  const string1 = "a1234";
  const string2 = "1234";
  const regex = /\d?/;
  const regexLazy = /\d??/;
  console.log(string1.match(regex));  // 输出：[""]，匹配失败了一次后就停止
  console.log(string1.match(regexLazy));  // 输出：[""]
  console.log(string2.match(regex));  // 输出：["1"]
  console.log(string2.match(regexLazy));  // 输出：[""]

4. {n} (必须重复n次)(开启懒惰性没有意义)

  //示例
  const string1 = "a1234";
  const string2 = "1234";
  const string3 = "1";
  const regex = /\d{2}/;
  console.log(string1.match(regex));  // 输出：["12"]
  console.log(string2.match(regex));  // 输出：["12"]
  console.log(string3.match(regex));  // 输出：null

5. {n,} (必须至少重复n次)

  //示例
  const string1 = "a1234";
  const string2 = "1234";
  const string3 = "123a45";
  const string4 = "12a345";
  const string5 = "1";
  const regex = /\d{2,}/;
  const regexLazy = /\d{2,}?/;
  console.log(string1.match(regex));  // 输出：["1234"]
  console.log(string1.match(regexLazy));  // 输出：["12"]
  console.log(string2.match(regex));  // 输出：["1234"]
  console.log(string2.match(regexLazy));  // 输出：["12"]
  console.log(string3.match(regex));  // 输出：["123"]
  console.log(string3.match(regexLazy));  // 输出：["12"]
  console.log(string4.match(regex));  // 输出：["12"]
  console.log(string4.match(regexLazy));  // 输出：["12"]
  console.log(string5.match(regex));  // 输出：null
  console.log(string5.match(regexLazy));  // 输出：null

6. {n, m} (必须至少重复n次，至多重复m次)

  //示例
  const string1 = "a1234";
  const string2 = "1234";
  const string3 = "1";
  const regex = /\d{2,3}/;
  const regexLazy = /\d{2,3}?/;
  console.log(string1.match(regex));  // 输出：["123"]
  console.log(string1.match(regexLazy));  // 输出：["12"]
  console.log(string2.match(regex));  // 输出：["123"]
  console.log(string2.match(regexLazy));  // 输出：["12"]
  console.log(string3.match(regex));  // 输出：null
  console.log(string3.match(regexLazy));  // 输出：null

五、特殊符号

1. () (视作一组整体的和连续的元素进行匹配，只有成功匹配了一次后才会停止)

① 常规捕获组

语法：(exp)
说明：

这个语法会捕获匹配的文本，也会给分组分配组号
exp：正则表达式

  //示例1
  const string1 = "ab";
  const string2 = "aaabbbabc";
  const regex = /(abc)/;
  console.log(string1.match(regex));  // 输出：null
  console.log(string2.match(regex));  // 输出：["abc", "abc"]，匹配失败不停止，匹配成功了一次后才停止
  //示例2 给分组分配组号
  const string3 = "aabb";
  const regex2 = /(aa)(bb)/;
  console.log(string3.match(regex2)[1]);  // 输出：aa
  console.log(string3.match(regex2)[2]);  // 输出：bb

② 非捕获组

语法：(?:exp)
说明：

这个语法不会捕获匹配的文本，也不会给分组分配组号
exp：正则表达式

  //示例1 与常规捕获组效果不相同，不会捕获匹配的文本
  const string1 = "aaabbb";
  const regex1 = /(?:a)/;
  console.log(string1.match(regex1));  // 输出：["a"]
  console.log(string1.match(regex1)[0]);  // 输出：a
  //示例2 给分组分配组号
  const string2 = "aabb";
  const regex2 = /(aa)(?:bb)/;
  console.log(string2.match(regex2)[1]);  // 输出：aa
  console.log(string2.match(regex2)[2]);  // 输出：undefined

③ 命名捕获组

语法：(?exp)
说明：

这个语法可以给一个捕获组分配一个名称，以便在后续操作中更容易地引用和访问该组匹配的内容
name：捕获组的名称，是一个标识符（即由英文字母、数字、下划线组成，且不能以数字开头）
exp：正则表达式

  //示例1 与常规捕获组效果相同，会捕获匹配的文本
  const string1 = "aaabbb";
  const regex1 = /(?<a>a)/;
  console.log(string1.match(regex1));  // 输出：["a", "a"]
  console.log(string1.match(regex1).groups);  // 输出：{a: "a"}
  console.log(string1.match(regex1).groups.a);  // 输出：a
  //示例2
  const string2 = "2023-12-30";
  const regex2 = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
  console.log(string2.match(regex2));  // 输出：["2023-12-30", "2023", "12", "30"]
  console.log(string2.match(regex2).groups);  // 输出：{year: '2023', month: '12', day: '30'}
  console.log(string2.match(regex2).groups.year);  // 输出：2023
  console.log(string2.match(regex2).groups.month);  // 输出：12
  console.log(string2.match(regex2).groups.day);  // 输出：30

④ 零宽正向先行断言

语法：(?=exp)
说明：

这个语法可以匹配(?=exp)前面的位置，这个位置符合(?=exp)中的exp正则
exp：正则表达式

  //示例
  const string = "12a3b";
  const regex = /\D(?=\d)/;
  console.log(string.match(regex));  // 输出：["a"]

⑤ 零宽正向后行断言

语法：(?<=exp)
说明：

这个语法可以匹配(?<=exp)后面的位置，这个位置符合(?<=exp)中的exp正则
exp：正则表达式

  //示例
  const string = "12a3b";
  const regex = /(?<=\d)\d/;
  console.log(string.match(regex));  // 输出：["2"]

⑥ 零宽负向先行断言

语法：(?!exp)
说明：

这个语法可以匹配(?!exp)前面的位置，这个位置不符合(?!exp)中的exp正则
exp：正则表达式

  //示例
  const string = "12a3b";
  const regex = /\d(?!\D)/;
  console.log(string.match(regex));  // 输出：["1"]

⑦ 零宽负向后行断言

语法：(?<!exp)
说明：

这个语法可以匹配(?<!exp)后面的位置，这个位置不符合(?<!exp)中的exp正则
exp：正则表达式

  //示例
  const string = "a12b";
  const regex = /(?<!\D)\d/;
  console.log(string.match(regex));  // 输出：["2"]

⑧ 回溯引用

 //示例1 \1类型回溯引用重复，其中1代表第1个子表达式
  const string1 = "aabbccaa aabbccbb";
  const regex1 = /(aa)(bb)(cc)\1/;
  const regex2 = /(aa)(bb)(cc)\2/;
  console.log(string1.match(regex1));  // 输出：["aabbccaa", "aa", "bb", "cc"]，去除的重复是第1个子表达式，即aa
  console.log(string1.match(regex2));  // 输出：["aabbccbb", "aa", "bb", "cc"]，去除的重复是第2个子表达式，即bb
 //示例2 $1类型回溯引用替换，其中1代表第1个子表达式
  const string2 = "aabbcc";
  const regex3 = /(aa)(bb)/;
  console.log(string2.replace(regex3, "$1"));  // 输出：aacc
  console.log(string2.replace(regex3, "$2"));  // 输出：bbcc

⑨ 回溯引用条件(?(backreference)true-regex|false-regex) (JavaScript不支持)

⑩ 前后查找条件(?(Search before and after)true-regex|false-regex) (JavaScript不支持)

2. [] (字符集合，单写[]本身没有意义，匹配包含在[]里面的任意一个字符，没有匹配前后顺序之分，只有成功匹配了一次后才会停止)

  //示例
  const string1 = "21a";
  const string2 = "a1";
  const regex = /[1a]/;
  console.log(string1.match(regex));  // 输出：["1"]
  console.log(string2.match(regex));  // 输出：["a"]，没有匹配前后顺序之分

3. [^] (字符集合取非，匹配写在[]里面之外的任意一个字符，只有成功匹配了一次后才会停止)

  //示例
  const string1 = "ab12";
  const string2 = "a1";
  const regex = /[^1a]/;
  console.log(string1.match(regex));  // 输出：["b"]，匹配失败不停止，匹配成功了一次后才停止
  console.log(string2.match(regex));  // 输出：null，没有匹配前后顺序之分

4. - (范围，通常配合[]使用，如[0-9]、[a-z]、[A-Z]、[a-zA-Z0-9]、[A-z]，匹配包含在[]里面范围内的任意一个字符，只有成功匹配了一次后才会停止)

  //示例
  const string1 = "01234";
  const string2 = "abAB12";
  const string3 = "A1ab";
  const string4 = "_";
  const string5 = "@";
  const string6 = "@_1";
  const string7 = "Aa";

  const regex1 = /[0-9]/; // 匹配从0到9的任意一个数字
  const regex2 = /[a-z]/; // 匹配从a到z的任意一个小写英文字母
  const regex3 = /[A-Z]/; // 匹配从A到Z的任意一个大写英文字母
  const regex4 = /[a-zA-Z0-9]/; // 匹配从0到9的任意一个数字、从a到z的任意一个小写英文字母、从A到Z的任意一个大写英文字母
  const regex5 = /[A-z]/; // 匹配ASCII中从A到z中（65-122）的任意一个字符，包含除英文字母外的ASCII值为91-96的这六个字符，a的ASCII值为97

  // regex1
  console.log(string1.match(regex1));  // 输出：["0"]
  console.log(string2.match(regex1));  // 输出：["1"]，匹配失败不停止，匹配成功了一次后才停止
  console.log(string7.match(regex1));  // 输出：null

  // regex2
  console.log(string1.match(regex2));  // 输出：null
  console.log(string2.match(regex2));  // 输出：["a"]
  console.log(string3.match(regex2));  // 输出：["a"]，匹配失败不停止，匹配成功了一次后才停止

  // regex3
  console.log(string1.match(regex3));  // 输出：null
  console.log(string2.match(regex3));  // 输出：["A"]，匹配失败不停止，匹配成功了一次后才停止
  console.log(string3.match(regex3));  // 输出：["A"]

  // regex4
  console.log(string1.match(regex4));  // 输出：["0"]
  console.log(string2.match(regex4));  // 输出：["a"]
  console.log(string3.match(regex4));  // 输出：["A"]
  console.log(string4.match(regex4));  // 输出：null
  console.log(string6.match(regex4));  // 输出：["1"]，匹配失败不停止，匹配成功了一次后才停止

  // regex5
  console.log(string1.match(regex5));  // 输出：null
  console.log(string2.match(regex5));  // 输出：["a"]
  console.log(string3.match(regex5));  // 输出：["A"]
  console.log(string4.match(regex5));  // 输出：["_"]
  console.log(string5.match(regex5));  // 输出：null
  console.log(string6.match(regex5));  // 输出：["_"]，匹配失败不停止，匹配成功了一次后才停止

5. | (或，如a|A，表示匹配a|A，只有成功匹配了一次后才会停止，没有匹配前后顺序之分)

  //示例
  const string1 = "1bac";
  const string2 = "1dec";
  const regex1 = /a|b/;
  const regex2 = /c|d|e/;
  console.log(string1.match(regex1));  // 输出：["b"]，匹配失败不停止，匹配成功了一次后才停止，没有匹配前后顺序之分
  console.log(string2.match(regex2));  // 输出：["d"]，匹配失败不停止，匹配成功了一次后才停止，没有匹配前后顺序之分

六、正则表达式的属性

1. constructor

语法：RegExpObject.constructor
作用：返回一个函数，该函数是一个创建 RegExp 对象的原型

  //示例
  const regex = /\d/;
  console.log(regex.constructor);  // 输出：ƒ RegExp() { [native code] }

2. lastIndex

语法：RegExpObject.lastIndex
作用：用于规定下次匹配的起始位置，默认是0，搭配RegExp对象上正则表达式有全局修饰符g的test和exec方法使用，没有全局修饰符g，lastIndex不会起任何作用（可读写）
特性：如果test()或exec()没有找到匹配项，lastIndex会被重置为0，如果找到了一个匹配项，lastIndex会被更新为匹配到的子串之后的第一个字符的位置

  //示例1
  const regex1 = /\d/;
  console.log(regex1.lastIndex);  // 输出：0
  //示例2
  const string2 = "a1b";
  const regex2 = /\d/g;
  regex2.lastIndex = 2
  console.log(regex2.lastIndex);  // 输出：2
  console.log(regex2.test(string2));  // 输出：false
  console.log(regex2.lastIndex);  // 输出：0
  console.log(regex2.test(string2));  // 输出：true
  console.log(regex2.lastIndex);  // 输出：2
  console.log(regex2.test(string2));  // 输出：false
  console.log(regex2.lastIndex);  // 输出：0
  //示例3
  const string3 = "a1b";
  const regex3 = /\d/g;
  regex3.lastIndex = 2
  console.log(regex3.lastIndex);  // 输出：2
  console.log(regex3.exec(string3));  // 输出：null
  console.log(regex3.lastIndex);  // 输出：0
  console.log(regex3.exec(string3));  // 输出：["1"]
  console.log(regex3.lastIndex);  // 输出：2
  console.log(regex3.exec(string3));  // 输出：null
  console.log(regex3.lastIndex);  // 输出：0

3. source

语法：RegExpObject.source
作用：返回正则表达式的匹配模式（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /[0-9]+/;
  console.log(regex1.source);  // 输出：\d
  console.log(regex2.source);  // 输出：[0-9]+

4. flags

语法：RegExpObject.flags
作用：返回一个包含所有启用的修饰符的字符串（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/gim;
  console.log(regex1.flags);  // 输出：
  console.log(regex2.flags);  // 输出：gim

5. global

语法：RegExpObject.global
作用：判断是否设置了 "g" 修饰符（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/g;
  console.log(regex1.global);  // 输出：false
  console.log(regex2.global);  // 输出：true

6. ignoreCase

语法：RegExpObject.ignoreCase
作用：判断是否设置了 "i" 修饰符（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/i;
  console.log(regex1.ignoreCase);  // 输出：false
  console.log(regex2.ignoreCase);  // 输出：true

7. multiline

语法：RegExpObject.multiline
作用：判断是否设置了 "m" 修饰符（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/m;
  console.log(regex1.multiline);  // 输出：false
  console.log(regex2.multiline);  // 输出：true

8. dotAll

语法：RegExpObject.dotAll
作用：判断是否设置了 "s" 修饰符（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/s;
  console.log(regex1.dotAll);  // 输出：false
  console.log(regex2.dotAll);  // 输出：true

9. unicode

语法：RegExpObject.unicode
作用：判断是否设置了 "u" 修饰符（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/u;
  console.log(regex1.unicode);  // 输出：false
  console.log(regex2.unicode);  // 输出：true

10. sticky

语法：RegExpObject.sticky
作用：判断是否设置了 "y" 修饰符（只读）

  //示例
  const regex1 = /\d/;
  const regex2 = /\d/y;
  console.log(regex1.sticky);  // 输出：false
  console.log(regex2.sticky);  // 输出：true

七、正则表达式的方法

1. test

语法：RegExpObject.test(string)
作用：检测一个字符串是否匹配某个正则模式，如果字符串中有匹配的值返回true，否则返回false

  //示例
  const string = "ab12";
  const regex = /\d/;
  console.log(regex.test(string));  // 输出：true

2. exec

语法：RegExpObject.exec(string)
作用：检测一个字符串是否匹配某个正则模式，如果字符串中有匹配的值返回该匹配值（只返回第一项匹配的值），否则返回null

  //示例1
  const string1 = "ab12";
  const regex1 = /\d/;
  console.log(regex1.exec(string1));  // 输出：["1"]
  //示例2
  const string2 = "ab12";
  const regex2 = /\d+/;
  console.log(regex2.exec(string2));  // 输出：["12"]
  //示例3
  const string3 = "a1b2";
  const regex3 = /\d+/;
  console.log(regex3.exec(string3));  // 输出：["1"]
  //示例4
  const string4 = "ab";
  const regex4 = /\d/;
  console.log(regex4.exec(string4));  // 输出：null

八、常用的配合正则的字符串方法

1. search

语法：string.search(RegExpObject | string)
作用：检测一个字符串是否匹配某个正则模式或字符串，如果字符串中有匹配的值返回第一个匹配元素的索引（索引从0开始），否则返回-1

  //示例1
  const string1 = "ab12";
  const regex1 = /\d/;
  console.log(string1.search(regex1));  // 输出：2
  //示例2
  const string2 = "ab12";
  const regex2 = /\d+/;
  console.log(string2.search(regex2));  // 输出：2
  //示例3
  const string3 = "a1b2";
  const regex3 = /\d/;
  console.log(string3.search(regex3));  // 输出：1
  //示例4 匹配字符串
  const string4 = "a1b2";
  const stringSearch1= "a1b2";
  const stringSearch2= "b2";
  const stringSearch3= "c";
  console.log(string4.search(stringSearch1));  // 输出：0
  console.log(string4.search(stringSearch2));  // 输出：2
  console.log(string4.search(stringSearch3));  // 输出：-1

2. match

语法：string.match(RegExpObject | string)
作用：检测一个字符串是否匹配某个正则模式或字符串，如果字符串中有匹配的值返回该匹配值（如果没有全局修饰符g只返回第一项匹配的值，如果有全局修饰符g则返回匹配的每一项），否则返回null

  //示例1 没有全局标识符g，返回的值与exec完全一样
  const string1 = "ab12";
  const regex1 = /\d/;
  console.log(string1.match(regex1));  // 输出：["1"]
  //示例2 没有全局标识符g，返回的值与exec完全一样
  const string2 = "ab12";
  const regex2 = /\d+/;
  console.log(string2.match(regex2));  // 输出：["12"]
  //示例3 没有全局标识符g，返回的值与exec完全一样
  const string3 = "a1b2";
  const regex3 = /\d+/;
  console.log(string3.match(regex3));  // 输出：["1"]
  //示例4 没有全局标识符g，返回的值与exec完全一样
  const string4 = "ab";
  const regex4 = /\d/;
  console.log(string4.match(regex4));  // 输出：null
  //示例5 匹配字符串
  const string5 = "a1b2";
  const stringSearch1 = "a1b2";
  const stringSearch2 = "b2";
  const stringSearch3 = "c";
  console.log(string5.match(stringSearch1));  // 输出：["a1b2"]
  console.log(string5.match(stringSearch2));  // 输出：["b2"]
  console.log(string5.match(stringSearch3));  // 输出：null
  //示例6 有全局标识符g
  const string6 = "ab12";
  const regex6 = /\d/g;
  console.log(string6.match(regex6));  // 输出：["1", "2"]
  //示例7 有全局标识符g
  const string7 = "ab12";
  const regex7 = /\d+/g;
  console.log(string7.match(regex7));  // 输出：["12"]
  //示例8 有全局标识符g
  const string8 = "a1b2";
  const regex8 = /\d+/g;
  console.log(string8.match(regex8));  // 输出：["1", "2"]
  //示例9 有全局标识符g
  const string9 = "a1b2";
  const regex9 = /\d/g;
  console.log(string9.match(regex9));  // 输出：["1", "2"]
  //示例10 有全局标识符g
  const string10 = "ab";
  const regex10 = /\d/g;
  console.log(string10.match(regex10));  // 输出：null

3. replace

语法：string.replace(RegExpObject | string, newvalue)
作用：检测一个字符串是否匹配某个正则模式或字符串，如果字符串中有匹配的值返回该匹配值被替换后的整个字符串（如果没有全局修饰符g只返回第一项匹配的值被替换后的整个字符串，如果有全局修饰符g则返回匹配的每一项被替换后的整个字符串），否则返回null，该方法不改变原始字符串

  //示例1 没有全局标识符g，要替换的值与match方法没有全局标识符g匹配到的值一样
  const string1 = "ab12";
  const regex1 = /\d/;
  console.log(string1.replace(regex1, "☆"));  // 输出：ab☆2
  //示例2 没有全局标识符g，要替换的值与match方法没有全局标识符g匹配到的值一样
  const string2 = "ab12";
  const regex2 = /\d+/;
  console.log(string2.replace(regex2, "☆"));  // 输出：ab☆
  //示例3 没有全局标识符g，要替换的值与match方法没有全局标识符g匹配到的值一样
  const string3 = "a1b2";
  const regex3 = /\d+/;
  console.log(string3.replace(regex3, "☆"));  // 输出：a☆b2
  //示例4 没有全局标识符g，要替换的值与match方法没有全局标识符g匹配到的值一样
  const string4 = "ab";
  const regex4 = /\d/;
  console.log(string4.replace(regex4, "☆"));  // 输出：ab
  //示例5 匹配字符串
  const string5 = "a1b2";
  const stringSearch1 = "a1b2";
  const stringSearch2 = "b2";
  const stringSearch3 = "c";
  console.log(string5.replace(stringSearch1, "☆"));  // 输出：☆
  console.log(string5.replace(stringSearch2, "☆"));  // 输出：a1☆
  console.log(string5.replace(stringSearch3, "☆"));  // 输出：a1b2
  //示例6 有全局标识符g，要替换的值与match方法有全局标识符g匹配到的值一样
  const string6 = "ab12";
  const regex6 = /\d/g;
  console.log(string6.replace(regex6, "☆"));  // 输出：ab☆☆
  //示例7 有全局标识符g，要替换的值与match方法有全局标识符g匹配到的值一样
  const string7 = "ab12";
  const regex7 = /\d+/g;
  console.log(string7.replace(regex7, "☆"));  // 输出：ab☆
  //示例8 有全局标识符g，要替换的值与match方法有全局标识符g匹配到的值一样
  const string8 = "a1b2";
  const regex8 = /\d+/g;
  console.log(string8.replace(regex8, "☆"));  // 输出：a☆b☆
  //示例9 有全局标识符g，要替换的值与match方法有全局标识符g匹配到的值一样
  const string9 = "a1b2";
  const regex9 = /\d/g;
  console.log(string9.replace(regex9, "☆"));  // 输出：a☆b☆
  //示例10 有全局标识符g，要替换的值与match方法有全局标识符g匹配到的值一样
  const string10 = "ab";
  const regex10 = /\d/g;
  console.log(string10.replace(regex10, "☆"));  // 输出：ab

4. split

语法：string.split(RegExpObject(可选) | string(可选), limit(可选))
作用：检测一个字符串是否匹配某个正则模式或字符串，如果字符串中有匹配的值则以该值作为分割线，分割线两边作为返回的数组的元素，该方法不改变原始字符串

  //示例1
  const string1 = "ab12";
  const regex1 = /\d/;
  console.log(string1.split(regex1));  // 输出：["ab", "", ""]
  //示例2
  const string2 = "ab12";
  const regex2 = /\d+/;
  console.log(string2.split(regex2));  // 输出：["ab", ""]
  //示例3
  const string3 = "a1b2";
  const regex3 = /\d+/;
  console.log(string3.split(regex3));  // 输出：["a", "b", ""]
  //示例4
  const string4 = "a1b2";
  const regex4 = /\d/;
  console.log(string4.split(regex4));  // 输出：["a", "b", ""]
  //示例5
  const string5 = "ab";
  const regex5 = /\d/;
  console.log(string5.split(regex5));  // 输出：["ab"]
  //示例6 匹配字符串
  const string6 = "a1b2";
  const stringSearch1 = "a1b2";
  const stringSearch2 = "b2";
  const stringSearch3 = "c";
  console.log(string6.split(stringSearch1));  // 输出：["", ""]
  console.log(string6.split(stringSearch2));  // 输出：["a1", ""]
  console.log(string6.split(stringSearch3));  // 输出：["a1b2"]
  //示例7 split为空
  const string7 = "abc";
  console.log(string7.split());  // 输出：["abc"]
  console.log(string7.split(null));  // 输出：["abc"]
  console.log(string7.split(undefined));  // 输出：["abc"]
  console.log(string7.split(" "));  // 输出：["abc"]
  console.log(string7.split(""));  // 输出：["a", "b", "c"]
  //示例8 limit参数限制返回的数组元素必须≤limit的值
  const string8 = "a1b2c3";
  const regex8 = /\d/;
  console.log(string8.split(regex8));  // 输出：["a", "b", "c", ""]
  console.log(string8.split(regex8, 0));  // 输出：[]
  console.log(string8.split(regex8, 2));  // 输出：["a", "b"]
  console.log(string8.split(regex8, 5));  // 输出：["a", "b", "c", ""]

九、常用的正则表达式

只能输入正的整数或者正的小数(位数不限)

^[0-9]+\.{0,1}[0-9]{0,}$

只能输入0-9的数字

^[0-9]*$

只能输入1位的0-9数字

^\d{1}$

只能输入1~3位的0-9数字

^\d{1,3}$

只能输入至少2位的0-9数字

^\d{2,}$

只能输入长度为3的字符(除了换行符外)

^.{3}$

只能输入由26个英文字母组成的字符串

^[A-Za-z]+$

只能输入由26个小写英文字母组成的字符串

^[a-z]+$

只能输入由26个大写英文字母组成的字符串

^[A-Z]+$

只能输入由数字和26个大小写英文字母组成的字符串

^[A-Za-z0-9]+$

只能输入由数字、26个大小写英文字母和下划线组成的字符串

^\w+$

只能输入由汉字组成的字符串

^[\u4e00-\u9fa5]{0,}$

匹配首尾空白字符

(^\s*)|(\s*$)

验证Email地址

^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

验证https和http地址

^(https?:\/\/(?:www\.)?[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,}(?:\/[\w\.-]*)*\/?)$

验证中国大陆18位居民身份证号码

^[1-9][0-9]{5}(18|19|20)[0-9]{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])[0-9]{3}([0-9]|X)$

验证中国大陆11位手机号码

^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\d{8}$

验证中国邮政编码

^[1-9]\d{5}$

验证IPv4地址

^(((\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]))$

验证IPv6地址

^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$

验证16进制颜色

^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$

posted @ 2024-02-06 11:26 伍嘉源阅读(86) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· JavaScript函数柯里化

· JavaScript移动端的手指触摸touch事件

· JavaScript 正则表达式功能用法运用详解

· 正则表达式从入门到入坑

· JavaScript正则表达式

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 25岁的心里话
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现

公告

昵称：伍嘉源
园龄： 1年1个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2024年2月(12)

wjy-javascript