如何检测正则表达式是否存在无限匹配及规避该问题

这个问题挺常见的——用户自定义的正则很容易因为贪婪量词和零宽结构的组合导致无限匹配（或者说灾难性回溯），比如你举的/\b(.*)\b/gi就是典型案例。我来拆解下怎么检测和规避：

你示例里的正则/\b(.*)\b/gi之所以有风险，核心问题在于：

• .*是贪婪匹配任意字符，包括空字符串
• \b是单词边界，空字符串的前后也可能符合边界规则
  当正则引擎尝试匹配时，会陷入「.*匹配空 → \b匹配空位置 → 再次尝试.*匹配空」的循环，最终导致超长回溯甚至页面卡死。

可以从静态结构分析和动态超时测试两个维度入手：

1. 静态分析正则结构 #

核心是识别「被无限量词修饰、且自身可匹配空的表达式」，这类结构很容易触发无限回溯。你可以写一个基础检测函数：

function hasInfiniteMatchRisk(regexStr) {
  // 先去除正则的前后分隔符和修饰符（比如 /xxx/gi → xxx）
  const cleanedPattern = regexStr.replace(/^\/|\/[gimuy]*$/g, '');
  
  // 定义常见的风险模式
  const riskyPatterns = [
    /\.\*\\b/,      // .* 紧跟单词边界
    /(\(\.\*\))\+/, // (.*)+ 嵌套贪婪量词
    /\\b.*?\\*\\b/, // \b 搭配 * 量词的结构
    /\{0,.*?\\b/    // {0,} 无限量词搭配边界
  ];
  
  // 检查是否命中风险模式
  return riskyPatterns.some(pattern => pattern.test(cleanedPattern));
}

注意：这只是基础检测，复杂正则（比如带嵌套分组、零宽断言的）需要更完善的语法解析逻辑。

2. 动态超时测试 #

静态分析可能漏检，所以可以结合动态测试——用空字符串或短字符串尝试匹配，设置超时阈值，超时则判定有风险：

async function regexHasInfiniteRisk(regexStr) {
  try {
    // 提取正则模式和修饰符
    const matchResult = regexStr.match(/^\/(.*)\/([gimuy]*)$/);
    if (!matchResult) throw new Error("无效的正则格式");
    
    const [_, pattern, modifiers] = matchResult;
    // 去掉全局修饰符g，避免匹配时无限循环
    const safeModifiers = modifiers.replace('g', '');
    const regex = new RegExp(pattern, safeModifiers);
    
    // 用Promiserace实现超时控制
    const matchPromise = Promise.resolve(regex.test(''));
    const timeoutPromise = new Promise((_, reject) => {
      setTimeout(() => reject(new Error("正则匹配超时")), 100); // 100ms阈值可调整
    });
    
    await Promise.race([matchPromise, timeoutPromise]);
    return false;
  } catch (e) {
    return true;
  }
}

针对你的场景和通用情况，有这些靠谱的解决办法：

1. 限定匹配范围，避免无限制的.*/.+ #

如果你的需求是匹配单词，把.*改成[^\s]+（匹配非空白字符），正则变成/\b([^\s]+)\b/gi——这样就不会匹配空字符串，从根源上避免无限回溯。

2. 模拟原子组（防止不必要的回溯） #

JS原生不支持原子组(?>...)（一旦匹配就不会回溯的分组），但可以用正向预查模拟：比如把(.*)改成(?=(.*))\1，这样匹配后不会回溯，不过这个方法需要根据具体场景调整。

3. 给正则匹配加超时保护 #

在你的代码里整合前面的检测逻辑，确保只有安全的正则才会被编译和使用：

async function safeCompileRegex(userRegex) {
  // 先做静态风险检测
  if (hasInfiniteMatchRisk(userRegex)) {
    throw new Error("正则表达式存在无限匹配风险");
  }
  
  // 再做动态超时检测
  if (await regexHasInfiniteRisk(userRegex)) {
    throw new Error("正则匹配超时，可能存在无限匹配风险");
  }
  
  // 编译安全的正则
  const [_, pattern, modifiers] = userRegex.match(/^\/(.*)\/([gimuy]*)$/);
  return new RegExp(pattern, modifiers);
}

// 使用示例
(async () => {
  try {
    const user_regex = "/\\b(.*)\\b/gi";
    const regex = await safeCompileRegex(user_regex);
    // 后续正常使用正则
  } catch(e) {
    console.error(e);
  }
})();

内容的提问来源于stack exchange，提问作者DhivinX