正则表达式没你想的那么难

什么是正则表达式

• 正则表达式：（Regular Expression）用于匹配规律规则的表达式，正则表达式最初始科学家对人类神经系统的工作原理的早期研究，现在在编程语言中有广泛的应用。正则表通常被用来检索、替换那些符合某个模式（规则）的文本
• 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式的作用

• 给定的字符串是否符合正则表达式的过滤逻辑（匹配）
• 可以通过正则表达式，从字符串中获取我们想要的特定部分（提取）
• 强大的字符串替换能力（替换）

创建正则的方法

语法

• 在JS中，正则表达式也是对象，是一种索引类型
• 使用一个正则表达式字面量是最简单的方式。两个/是正则表达式的界定符。
• 可以通过下面两种方法创建正则表达式
  • 使用一个正则表达式字面量，如下所示：

    var reg = /abc/;
    

    • 正则表达式字面量在脚本加载后编译。若你的正则表达式是常量，使用这种方式可以获得更好地性能
  • 调用 RegExp 对象的构造函数，如下所示：

    var re = new RegExp("abc");
    

字符串方法与正则表达式方法

• 字符串方法：
  • split()：根据匹配字符串切割父字符串
  • match()：使用正则表达式与字符串相比较，返回一个包含匹配结果的数组
  • search()：对正则表达式或指定字符串进行搜索，返回第一个出现的匹配项的下标
  • replace()：用正则表达式和字符串直接比较，然后用新的子串来替换被匹配的字串
• 正则表达式方法：
  • exec()：在目标字符串中执行一次正则匹配操作
  • test()：测试当前正则是否匹配目标字符串

正则表达式的组成

• 由一些普通字符和一些特殊字符（又叫元字符 — metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义

• 特殊字符：JS中常用的特殊字符有() [] {} \ ^ & | ? * + .

• 若想匹配这类字符必须用常用特殊符合 \ 如：\(,\^,\\

• 预定义字符：

  • \t：/\t/
  • \n：/\n/
  • \f：/\f/
  • \b：/\b/

字符集

字符集：使用[]表示的可能的字符的集合，集合内部可以排列多个匹配字符串的可能性，整个字符集需要匹配的是字符串中的一个字符
[] ————> 字符串中的一个字符，多选一的效果，有一个满足就算匹配成功

• 简单类：正则的多个字符对应一个字符，我们可以用[]把他们括起来，让[]这个整体对应一个字符[abc]
  • 例子：o[usb]t——————obt、ost、out
• 范围类：有时匹配的东西过多，而且类型又相同，全部输入太麻烦，我们可以在中间加了个横线。[a-z]、[0-9]、[A-Z]
  • 例子：id[0-9]——————id0、id5
• 负向类：[]前面加个元字符进行取反，表示匹配不能为括号里面的字符。[^a]
  • 例子：o[^0-9]t——————oat、o?t、o t
• 组合类：允许用中括号匹配不同类型的单个字符。[0-9a-b]
  • 例子：o[0-9a-b]t——————oat、o?t、o

        // 字符集：使用 [] 表示的可能的字符的集合，集合内部可以排列多个匹配字符串的可能性，整个字符集需要匹配的是字符串中的一个字符。
        // [] --> 字符串中的一个字符，多选一的效果，有一个满足就算匹配成功

        // 简单类：多个可能匹配的字符连续书写在一起，只要其中一个匹配成功即可
        // var reg = /[abc]/;
        // console.log(reg.test("eeeb"));

        // 范围类：将匹配同一类型且连续在一起的字符写到集合中，中间使用 - 连接
        // var reg = /[0-9]/;
        // var reg = /[a-z]/;
        // var reg = /[A-Q]/;
        // console.log(reg.test("A123456"));

        // 负向类：取反的意思，不包含字符集内部书写的字符
        // var reg = /[^A-Q]/;
        // console.log(reg.test("A"));

        // 组合类：单一类型或者简单类不能匹配所有结果，可以将多个写法连在一起书写
        // 特殊的：如果数字、大写字母、小写字母，按照这种顺序写的完整的范围，可以缩写
        // var reg = /[0-9a-z]/;
        // var reg = /[0-9A-Z]/;
        var reg = /[0-z]/;
        console.log(reg.test("a"));

修饰符

需要书写在正则表达式字面量之外

• g 修饰符用于执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）
• i 修饰符用于执行对大小写不敏感的匹配。

        // g 修饰符：可以实现全局查找 
        // var str = "aabblsdddbbbdlBBdllbbbbb";
        // var reg = /b+/g;
        // console.log(str.match(reg));

        // i 修饰符：字母大小写可以不敏感，a 可以匹配 a 或 A
        var str = "aabblsdddbbbdlBBdllbbbbb";
        var reg = /A/ig;
        console.log(str.match(reg));

边界

• ^ 开头 注意不能紧跟与左中括号的后面（不然就是取反）
• $ 结尾

        // 边界
        // ^  表示限制开头，后面的正则内容匹配的结果必须出现在字符串开始
        var str = "hello ll Javascript";
        console.log(/^hello/.test(str));
        console.log(/^hhello/.test(str));

        // $ 表示限制结尾，前面的正则内容匹配的结果必须出现在字符串结尾
        console.log(/script$/.test(str));
        console.log(/scripthaha$/.test(str));

        // 实际应用中，会同时限制开头和结尾
        console.log(/^hello\s+Javascript$/.test(str));

预定义类

—	—	—
.	[^\n\r]	除了换行和回车之外的任意字符
\d	[0-9]	数字字符
\D	[^0-9]	非数字字符
\s	[\t\n\x0B\f\r]	空白字符
\S	[^\t\n\x0B\f\r]	非空白字符
\w	[a-zA-Z_0-9]	单词字符（所有的字母/数字/下划线）
\W	[^a-zA-Z_0-9]	非单词字符

        // 非回车非换行字符 .
        // console.log(/^.+$/.test(`asldjf2830&*^`));
        // console.log(/^.+$/.test(`asldjf
        // 2830&*^`));

        // \d 数字字符 \D 非数字字符
        // console.log(/^\d+$/.test(`0123456789`));
        // console.log(/^\d+$/.test(`01234z56789`));
        // console.log(/^\D+$/.test(`askdAK  *&^`));
        // console.log(/^\D+$/.test(`askdAK  *&^7`));

        // \s 空白字符 \S 非空白字符
        // console.log(/^\s+$/.test(`  1    
        // `));
        // console.log(/^\s+$/.test(`      
        // `));
        // console.log(/^\S+$/.test(`AJO456`));
        // console.log(/^\S+$/.test(`AJO  456`));

        // \w 单词字符 \W 非单词字符
        console.log(/^\w+$/.test(`abc09_A`));
        console.log(/^\w+$/.test(`abc*09_A`));
        console.log(/^\W+$/.test(`*&^%$ *`));
        console.log(/^\W+$/.test(`a*&^%$ *`));

量词

• {n}：硬性量词：对应0次或者n次
• {n, m}：软性量词：至少出现n次但不超过m次（中间不能有空格）
• {n,}：软性量词：至少出现n次（+的升级版）
• ?：软性量词：出现0次或1次
• *：软性量词：出现0次或多次（任意次）
• +：软性量词：出现1次或多次（至少一次）

        // 量词
        // {n}  硬性量词   对应前面的内容必须在字符串中出现 n 次连续
        // var reg = /^\d{5}$/;
        // console.log(reg.test("1234"));
        // console.log(reg.test("12345"));
        // console.log(reg.test("123456"));

        // {n,m}  软性量词  对应前面的内容必须在字符串中出现 n-m 次连续
        // var reg = /^\d{5,7}$/;
        // console.log(reg.test("1234"));
        // console.log(reg.test("12345"));
        // console.log(reg.test("123456"));
        // console.log(reg.test("1234567"));
        // console.log(reg.test("12345678"));

        // {n,}  软性量词  对应前面的内容必须在字符串中出现至少 n 次连续
        // var reg = /^\d{5,}$/;
        // console.log(reg.test("1234"));
        // console.log(reg.test("12345"));
        // console.log(reg.test("123456"));
        // console.log(reg.test("1234567"));
        // console.log(reg.test("123456789101112"));

        // ?  软性量词  {0,1} 表示前面的内容出现 0 次或 1次
        // var reg = /^\d?$/;
        // console.log(reg.test("1"));
        // console.log(reg.test(""));
        // console.log(reg.test("12345"));

        // *  软性量词  {0,} 表示前面的内容出现 0 次或 任意次
        // var reg = /^\d*$/;
        // console.log(reg.test("1"));
        // console.log(reg.test(""));
        // console.log(reg.test("12345"));

        // +  软性量词  {1,} 表示前面的内容出现 1 次或 以上
        var reg = /^\d+$/;
        console.log(reg.test(""));
        console.log(reg.test("1"));
        console.log(reg.test("12345"));

分组和或操作符

分组

虽然量词的出现，能帮助我们处理一排紧密相连的同类型字符串。但这是不够的，我们用中括号表示范围内选择，大括号表示重复次数。如果想获取重复多个字符，我们就要用小括号进行分组了

/(bye){2}/.test('byebye')   // true

/(bye){
    
    2}/.test('bye')  // false

或操作符

可以使用竖线 | 字符表示或者的关系

/a|bcd/     匹配a或者bcd字符

/(ab)+|(cd)+/   匹配出现一次或多次的 ab 或者 cd

分组的反向引用

反向引用标识是对正则表达式中的匹配组捕获的子字符串进行编号，通过“\编号(在表达式中)”，"$编号(在表达式外)"进行引用。从1开始计数。

        // 正则中通过分组匹配到的字符串，会被进行编号，从 1 开始
        // 在正则内部可以通过 \1 方式，去对字符串进行反向引用
        // console.log(/^([a-z]{3})\1$/.test("byebye"));
        // console.log(/^([a-z]{3})\1$/.test("byelie"));

        // 正则表达式以外通过 $1 ,进行字符串的引用
        // var str = "123*456".replace(/^(\d{3})\*(\d{3})$/,"$2*$1");
        // 第二个参数可以是一个函数
        var str = "123*456".replace(/^(\d{3})\*(\d{3})$/,function (match,$1,$2) {
    
    
            return $1 * 3 + "/" + $2 * 2;
        });
        console.log(str);

中文字符

匹配中文：[\u4e00-\u9fa5]

        // 匹配中文字符
        var reg = /^[a-z\u4e00-\u9fa5]+$/;
        console.log(reg.test("只有中文的文字内容"));
        console.log(reg.test("只有中文的文 字内容"));
        console.log(reg.test("只有中文的文a字内容"));