浅谈正则表达式原理

正则表达式可能大部分人都用过，可是你们在使用的时候，有没有想过正则表达式背后的原理，又或者当我告诉你正则表达式可能存在性能问题致使线上挂掉，你会不会以为特别吃惊？

咱们先来看看7月初，由于一个正则表达式，致使线上事故的例子。

blog.cloudflare.com/details-of-…

简单来讲就是一个有性能问题的正则表达式，引发了灾难性回溯，致使cpu满载。

性能问题的正则

先看看出问题的正则

引发性能问题的关键部分是.*(?:.*=.*)，这里咱们先无论那个非捕获组，将性能问题的正则看作 .*.*=.* 。

其中. 表示匹配除了换行之外的任意字符（不少人把这里搞错，容易出bug），.* 表示贪婪匹配任意字符任意次。

什么是回溯

在使用贪婪匹配或者惰性匹配或者或匹配进入到匹配路径选择的时候，遇到失败的匹配路径，尝试走另一个匹配路径的这种行为，称做回溯。

能够理解为走迷宫，一条路走到底，发现无路可走就回到上一个三岔口选择另外的路。

回溯现象

// 性能问题正则
// 将下面代码粘贴到浏览器控制台运行试试
const regexp = `[A-Z]+\\d+(.*):(.*)+[A-Z]+\\d+`;
const str = `A1:B$1,C$1:D$1,E$1:F$1,G$1:H$1`
const reg = new RegExp(regexp);
start = Date.now();
const res = reg.test(str);
end = Date.now();
console.log('常规正则执行耗时:' + (end - start))
复制代码

如今来看看回溯到底是怎么一回事

假设咱们有一段正则(.*)+\d ，这个时候输入字符串为abcd ，注意这个时候仅仅输入了一个长度为4的字符串，咱们来分析一下匹配回溯的过程：

上面展现了一个回溯的匹配过程，大概描述一下前三轮匹配。

注意(.*)+ 这里能够先暂且当作屡次执行 .* 。 (.*){1,}

第一次匹配，由于.* 能够匹配任意个字符任意次，那么这里能够选择匹配空、a、ab、abc、abcd，由于* 的贪婪特性，因此.* 直接匹配了abcd 4个字符，+ 由于后面没有其余字符了，因此只看着.* 吃掉abcd 后就不匹配了，这里记录+ 的值为1，而后\d 没有东西可以匹配，因此匹配失败，进行第一次回溯。

第二次匹配，由于进行了回溯，因此回到上一个匹配路径选择的时候，上次.* 匹配的是abcd ，而且路不通，那么此次只能尝试匹配abc ，这个时候末尾还有一个d ，那么能够理解为.* 第一次匹配了abc ，而后由于(.*)+ 的缘由，.* 能够进行第二次匹配，这里.* 能够匹配d ，这里记录+ 的值为2，而后\d 没有东西可以匹配，因此匹配失败，进行第二次回溯。

第三次匹配，由于进行了回溯，因此回到上一个匹配路径选择的时候，上次第一个.* 匹配的是abc ，第二个.* 匹配的是d ，而且路不通，因此这里第二次的.* 不进行匹配，这个时候末尾还有一个d ，\d 和d 匹配失败，进行第三次回溯。

如何减小或避免回溯

• 优化正则表达式：时刻注意回溯形成的性能影响。
• 使用DFA正则引擎的正则表达式

什么是DFA正则引擎

传统正则引擎分为NFA（非肯定性有限状态自动机），和DFA（肯定性有限状态自动机）。

DFA

对于给定的任意一个状态和输入字符，DFA只会转移到一个肯定的状态。而且DFA不容许出现没有输入字符的状态转移。

好比状态0，在输入字符A的时候，终点只有1个，只能到状态1。

NFA

对于任意一个状态和输入字符，NFA所能转移的状态是一个非空集合。

好比状态0，在输入字符A的时候，终点能够是多个，即能到状态1，也能到状态0。

DFA和NFA的正则引擎的区别

那么讲了这么多以后，DFA和NFA正则引擎究竟有什么区别呢？或者说DFA和NFA是如何实现正则引擎的呢？

DFA

正则里面的DFA引擎实际上就是把正则表达式转换成一个图的邻接表，而后经过跳表的形式判断一个字符串是否匹配该正则。

// 大概模拟一下
function machine(input) {
    if (typeof input !== 'string') {
        console.log('输入有误');
        return;
    }
    // 好比正则：/abc/ 转换成DFA以后
    // 这里咱们定义了4种状态，分别是0,1,2,3，初始状态为0
    const reg = {
        0: {
            a: 1,
        },
        1: {
            b: 3,
        },
        2: {
            isEnd: true,
        },
        3: {
            c: 2,
        },
    };
    let status = 0;
    for (let i = 0; i < input.length; i++) {
        const inputChar = input[i];
        status = reg[status][inputChar];
        if (typeof status === 'undefined') {
            console.log('匹配失败');
            return false;
        }
    }
    const end = reg[status];
    if (end && end.isEnd === true) {
        console.log('匹配成功');
        return true;
    } else {
        console.log('匹配失败');
        return false;
    }
}

const input = 'abc';
machine(input);
复制代码

优势：无论正则表达式写的再烂，匹配速度都很快

缺点：高级功能好比捕获组和断言都不支持

NFA

正则里面NFA引擎实际上就是在语法解析的时候，构造出的一个有向图。而后经过深搜的方式，去一条路径一条路径的递归尝试。

优势：功能强大，能够拿到匹配的上下文信息，支持各类断言捕获组环视之类的功能

缺点：对开发正则功底要求较高，须要注意回溯形成的性能问题

总结

如今回到问题的开头，咱们再来看看为何他的正则会有性能问题

1. 首先他的正则使用的NFA的正则引擎（大部分语言的正则引擎都是NFA的，js也是，因此要注意性能问题产生的影响）
2. 他写出了有性能问题的正则表达式，容易形成灾难性回溯。

若是要避免此类的问题，要么提升开发对正则的性能问题的意识，要么改用DFA的正则引擎（速度快，功能弱，没有补货组断言等功能）。

注意事项

在日常写正则的时候，少写模糊匹配，越精确越好，模糊匹配、贪婪匹配、惰性匹配都会带来回溯问题，选一个影响尽量小的方式就好。写正则的时候有一个性能问题的概念在脑子里就行。

tips：以前我用js写了一个dfa的正则引擎，感兴趣的同窗能够看看：github.com/libertyzhao…