正则表达式完整知识体系

一、基础核心概念（完整进阶版｜本质+特性+原理+适用边界）

1. 定义

**正则表达式（Regex/RegExp，Regular Expression）：**一种用于匹配、校验、处理字符串的轻量化语法规则，通过特殊元字符、量词、逻辑符号组合，定义一套字符串匹配模式，可精准描述「文本格式、字符规则、匹配范围」。

核心定位： 不属于编程语言，是通用文本处理标准，兼容JS/Java/Python/PHP/SQL/IDE编辑器等几乎所有开发工具与语言，是文本校验、数据清洗、格式解析的底层通用能力。

核心本质 ：正则不是"精确相等匹配"，而是模式模糊匹配，通过规则匹配一类符合特征的字符串，而非单一固定字符串，这是正则能高效处理批量文本的核心原因。

2. 核心用途与业务场景细分

2.1 表单格式校验（前端/后端核心风控场景）

业务定位： 属于项目基础数据风控第一道屏障，用于统一用户输入格式、拦截非法脏数据，避免不规范数据入库导致数据库异常、业务逻辑报错、接口解析失败。是所有ToC/ToB项目必备能力，覆盖注册、登录、资料完善、表单提交等全流程。

细分校验场景：中国大陆手机号、国内外邮箱、18位身份证号、银行卡号、统一社会信用代码、IP地址、域名、账号昵称、强弱密码、验证码、邮编、日期格式、电话号码（座机）、文件后缀名校验。

落地价值：替代冗长的字符串截取、判断、遍历逻辑，代码极简、规则统一、容错性高，大幅降低表单校验代码维护成本。

2.2 批量文本清洗与数据治理（后端/大数据核心场景）

业务定位： 用于结构化脏数据规整、非结构化文本提纯，是日志分析、爬虫抓取、内容审核、数据迁移、批量数据修复的核心手段，广泛应用于后端服务、数据中台、ETL数据清洗流程。

细分清洗场景：清除全文空白行/全半角空格/零宽隐形字符、过滤特殊符号与乱码、批量剔除Emoji表情、文本去重、换行符统一、脏字符过滤、脱敏预处理、文本首尾规整。

落地价值：批量标准化海量文本数据，解决数据杂乱、格式不统一、脏数据干扰业务统计、数据分析失效等问题。

2.3 精准内容提取与解析（爬虫/日志/接口场景）

业务定位： 从超长混杂文本、富文本、日志报文、接口返回字符串中精准截取目标字段，是结构化提取非结构化数据的最优方案。

细分提取场景：批量提取文本中所有手机号/邮箱/URL/图片链接/数字价格、提取日志中的时间戳、错误码、请求参数、从富文本中提取纯文字、截取接口自定义参数、解析简易报文格式。

落地价值：无需逐字符遍历匹配，一条正则完成批量提取，性能远高于手写循环判断，适配海量日志、批量内容解析场景。

2.4 代码工程与开发提效（IDE/脚本/工程重构）

业务定位： 属于研发提效工具能力，贯穿日常开发、代码重构、批量改代码、脚本处理、配置替换等工程场景。

细分工程场景：IDE全局批量查找替换、批量修改变量命名、批量删除注释、批量剔除无效代码、格式化代码文本、Shell/Python脚本文本处理、配置文件解析、路由规则匹配、接口参数统一校验。

落地价值 ：解决人工逐条修改低效问题，实现秒级批量工程处理，极大提升重构、代码规整、脚本开发效率。

2.5 内容风控与敏感过滤（社区/内容平台场景）

业务定位： 社区平台、评论系统、内容发布系统的基础内容风控能力，用于拦截违规内容、脱敏隐私信息、过滤非法关键词。

细分风控场景：敏感词匹配与替换、广告垃圾内容过滤、手机号/邮箱/微信号隐私脱敏、批量屏蔽违规特殊字符、特殊格式内容拦截。

2.6 数据格式化与脱敏展示（前台展示/数据输出）

**业务定位：**用于用户展示层数据美化、隐私保护、统一输出格式，是前端展示、后端数据输出的通用能力。

细分格式化场景：手机号/身份证/邮箱脱敏、金额千分位格式化、日期格式统一转换、字符串首尾去空格、文本换行规整、超长内容截断匹配。

2.7 数据库筛选与匹配（SQL正则检索）

业务定位： MySQL等数据库支持简易正则匹配，用于复杂模糊查询、批量筛选脏数据、规则化数据筛选，弥补like模糊查询能力不足的缺陷。

细分数据库场景：批量筛选含中文/数字/特殊后缀的字段、筛选格式非法数据、批量匹配规整字段、清洗历史脏数据。

3. 正则两种书写形式（底层原理+完整差异+高频坑点+落地场景）

主流编程语言（JS/Java/Python）的正则表达式仅有两种书写范式：字面量静态正则 、构造函数动态正则 。二者绝非简单语法写法区别，在编译时机、内存缓存机制、转义规则、运行性能、动态拓展能力、循环复用表现、安全风险上存在本质底层差异，是开发中出现「本地正常、线上异常、偶尔匹配失效、循环校验错乱」等隐性BUG的核心诱因。

工程开发核心原则：固定规则用字面量，动态规则用构造函数，严格区分场景，禁止混用。

3.1 字面量形式 /pattern/flags（静态正则）

标准语法 ：/正则匹配规则/修饰符

实战示例 ：/^1[3-9]\d{9}$/g（全局匹配中国大陆手机号）

底层编译原理（核心）

字面量正则属于编译期静态解析 ：代码在预解析、语法扫描阶段，引擎直接识别斜杠包裹的正则规则，完成语法校验、编译字节码、生成固定匹配指令，并全局常驻缓存。程序运行阶段不再二次解析、二次编译，直接复用缓存后的编译结果，属于常量级性能，无任何运行时开销。

完整核心优势

• 性能极致最优：预编译+全局缓存，循环高频校验、海量文本批量处理场景，性能远超构造函数；

• 转义逻辑简洁无坑 ：无需字符串二次转义，\d、\s、\w、\b 等正则元字符可直接书写，无转义冲突；

• 语法绝对稳定：规则硬编码固定，无法被字符串拼接篡改、不会出现语法断裂、符号缺失问题；

• 可读性与维护性高：规则直观简洁，适合统一封装全局通用正则模板。

核心局限性（唯一短板）

• 完全不支持动态规则拼接：正则规则固定写死，无法通过变量、用户输入、接口返回值、后台配置、数据库数据动态生成或修改；

• 程序运行期间无法动态变更匹配逻辑，适配性固定单一。

精准落地适用场景

• 全局通用固定校验规则：手机号、邮箱、身份证、密码、URL、日期、文件后缀等表单校验；

• 通用文本处理规则：空白清洗、符号过滤、Emoji剔除、格式统一等固定清洗逻辑；

• 循环遍历、高频重复调用、海量数据批量处理等对性能敏感场景；

• 长期不变、全局复用的公共正则工具方法。

3.2 构造函数形式 new RegExp()（动态正则）

标准语法 ：new RegExp(规则字符串, 修饰符字符串)

实战示例 ：new RegExp('^1[3-9]\\d{9}$', 'g')

底层编译原理（核心）

构造函数正则属于运行时动态解析 ：代码预解析阶段仅识别函数声明，不做正则编译；仅当代码运行到当前行时，才接收字符串参数、实时校验语法、动态编译正则实例、生成匹配指令。默认无全局缓存，每次执行 new RegExp 都会生成全新独立实例对象。

完整核心优势

• 支持全量动态拼接：可通过变量、if条件判断、接口数据、后台配置、用户自定义内容，动态组合、生成正则匹配规则；

• 业务灵活度极高：可根据不同业务场景、不同用户权限、不同配置参数，实时切换正则匹配逻辑；

• 适配配置化业务：完美适配「后台配置敏感词、自定义过滤规则、动态校验字段」等动态业务。

核心缺陷与高频致命坑点（工程重点）

• 致命坑1：二次转义强制要求（最高频报错源） 普通字符串中 \是字符串转义符 ，会被字符串引擎提前解析消耗，无法传递给正则引擎。所有正则元字符必须双层转义 ：正则原生 \d 必须写为 \\d，\s 写为 \\s，少写一层会直接导致规则失效、语法报错。

• 致命坑2：默认无缓存，性能损耗严重循环、高频定时器、批量处理逻辑内频繁 new RegExp，会反复创建实例、重复编译、产生大量临时内存对象，造成内存抖动、CPU占用升高、性能断崖式下降。

• 致命坑3：字符串拼接容错率极低动态拼接极易出现空格缺失、括号不匹配、符号截断、空字符注入等问题，导致正则语法异常、匹配错乱、匹配范围失控。

• 致命坑4：存在正则注入风险直接使用用户输入、前端传参拼接正则，会被恶意用户注入正则元字符，篡改匹配规则、绕过校验逻辑，引发业务风控漏洞。

精准落地适用场景

• 动态配置化场景：后台自定义敏感词、数据库存储校验规则、接口返回匹配逻辑；

• 变量拼接场景：根据业务参数动态修改匹配长度、匹配范围、过滤关键词；

• 用户自定义场景：用户自主设置过滤规则、自定义格式校验逻辑；

• 多场景差异化适配：同一接口根据不同场景切换不同正则校验规则。

3.3 动态正则配套解决方案（工程落地必备）

针对构造函数正则的转义坑、注入坑、性能坑，提供生产级通用工具方法：

// 正则特殊字符转义工具（防止正则注入+语法报错）
function escapeRegExp(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

// 动态正则缓存封装（避免重复编译）
function getDynamicReg(pattern, flags = 'g') {
  // 可全局缓存已编译正则，提升高频性能
  const key = pattern + flags;
  if(!window.__REG_CACHE__) window.__REG_CACHE__ = {};
  if(!window.__REG_CACHE__[key]) {
    window.__REG_CACHE__[key] = new RegExp(pattern, flags);
  }
  return window.__REG_CACHE__[key];
}

// 实战使用
const keyWord = "测试关键词";
const reg = getDynamicReg(escapeRegExp(keyWord), 'g');

3.4 两种写法核心差异对照表（工程必背）

对比维度	字面量正则（静态）	构造函数正则（动态）
编译时机	代码预编译阶段，提前编译缓存	代码运行阶段，实时动态编译
转义规则	单次转义，简洁零坑	必须二次转义，极易出错
动态拓展能力	不支持变量拼接、规则固定	支持全量动态拼接、灵活可配置
运行性能	极高，全局缓存复用，无开销	偏低，无缓存则重复编译
语法稳定性	绝对稳定，无匹配错乱	拼接不当极易语法异常
循环高频适配	最优推荐，性能无损耗	需手动缓存实例，否则性能极差
安全风险	无注入风险	存在正则注入风险，需手动转义
典型业务用途	固定通用校验、文本清洗模板	动态配置、变量拼接、自定义规则

3.5 工程强制选型规范（生产落地标准）

1. 固定规则优先字面量：所有长期不变的校验、清洗、提取规则，一律使用字面量，保障性能与稳定性；

2. 动态规则仅用构造函数：仅规则需要动态拼接、后台配置、用户自定义时，才使用 new RegExp；

3. 动态正则必须缓存：高频调用的动态正则统一封装缓存，禁止循环内重复 new；

4. 动态输入必须转义：所有用户输入、外部传入的动态规则，必须先转义特殊字符，杜绝正则注入漏洞；

5. 禁止混合书写：同一业务逻辑禁止混用两种写法，避免规则混乱、维护成本升高。

4. 正则核心底层特性（必懂基础｜原理+误区+实战坑点）

正则所有匹配行为、报错问题、匹配错乱、结果不符合预期的根源，全部来自四大底层核心特性。这部分属于正则底层运行机制，不属于语法，但决定了你能不能写出精准、无BUG、高性能的正则，是区分新手和熟练使用者的关键。

4.1 零宽特性（最核心、最高频考点）

(1) 底层原理 ：零宽字符（也叫零宽断言/定位符）包含 ^ $ \b \B (?=) (?!) (?<=) (?<!) 一类字符。这类字符只做位置判断、校验边界条件、不消耗任何文本字符，匹配完成后指针不后移、不占用匹配结果长度，仅用于"定位筛选"。

(2) 通俗解释：普通元字符（\d、\w）是"吃掉字符"，零宽字符是"站在原地判断条件"。

(3) 经典误区与报错案例

误区：认为断言会占用字符，导致多删、错删内容。 示例需求：提取"价格：123元"中的数字 正确正则：(?<=价格：)\d+(?=元) 错误理解：前后断言会匹配文字 → 实际完全不消耗，只会精准取出中间数字。

(4) 工程价值 ：实现精准截取、不破坏原文本、无多余字符，是脱敏、字段提取、精准过滤的底层支撑。

4.2 贪婪匹配优先特性（90%匹配错乱根源）

(1) 底层原理 ：NFA正则引擎默认优先贪婪模式 。所有量词 + * ? {n,} 默认尽可能匹配最长文本，引擎会先吞完所有可匹配字符，再逐步回溯释放字符尝试匹配后续规则。

( 2 )核心机制：先最大匹配 → 不满足则回溯释放 → 尝试最小匹配。

( 3 )实战BUG场景 ：短标签正常、长文本批量匹配错乱 需求：匹配单个HTML标签 <任意内容> 贪婪写法：<.+>，对文本 <div>123</div> 会一次性匹配整段内容，造成跨标签贪婪吞噬 。 ( 4 )解决方案： 量词后加 ? 开启非贪婪 <.+?>。

( 5 )核心总结 ：批量截取、多段匹配、分段解析必须手动关闭贪婪，固定长度校验可保留贪婪提升性能。

4.3 就近作用特性（新手语法重灾区）

(1)底层原理 ：所有量词、修饰符、限定规则，仅作用于紧邻的前一个最小单元。

( 2 **)最小单元可以是：**单个字符、单个转义元字符、一个完整分组。不会全局生效、不会向前穿透、不会批量生效。

( 3 )高频错误案例（全网最高频写错）

需求： 匹配多个ab重复 错误写法：ab+ ------ 仅 b 重复，匹配 ab、abb、abbb，完全不符合预期 正确写法： (ab)+ ------ 分组整体重复，匹配 ab、abab、ababab

延伸误区 ：123? 仅3可选，不是整体123可选。

( 4 )解决方案：多字符重复、多规则复用，必须用括号分组锁定作用域。

4.4 分支最低优先级特性（逻辑错乱根源）

(1)底层原理 ：正则所有符号中，| 或逻辑的优先级全局最低。引擎会先解析前后所有字符、量词、边界，最后再执行或逻辑判断，极易出现"分支截断、规则跑偏"。

( 2 )致命错误案例

需求：匹配后缀 jpg / png / gif 错误写法：jpg|png|gif$

底层解析逻辑：等价于 (jpg)|(png)|(gif$)，仅gif会校验结尾，jpg、png任意位置都能匹配，造成脏数据误判。

正确规范 ：分支逻辑必须整体包裹分组 ，统一作用域：(jpg|png|gif)$。

( 3 )工程规范：所有或逻辑分支，无论长短，一律括号包裹，杜绝优先级错乱BUG。

4.5 正则从左至右单向扫描特性（底层运行逻辑）

底层原理 ：NFA正则引擎严格从左至右单向扫描文本，不会反向匹配、不会跳跃匹配，匹配成功即推进指针，失败则触发回溯。

实战意义 ：精准理解匹配顺序，可手动前置严格规则、快速失败，大幅优化正则性能；复杂正则必须把高概率失败规则前置，减少无效扫描。

4.6 优先匹配特性（分支命中即终止）

底层原理 ：多分支或逻辑中，左侧分支优先命中，一旦左侧匹配成功，直接终止右侧分支校验，不会择优匹配。

误区案例 ：(12|123) 匹配 123 文本，只会命中左侧 12，不会匹配更长的123。

最佳实践 ：多长度分支，长规则放左侧，短规则放右侧。

5. 正则适用边界与局限性（工程取舍核心｜精准判断用与不用）

正则是线性文本规则匹配神器 ，但并非万能文本处理工具。所有线上BUG、性能卡顿、匹配异常，很多源于「强行用正则处理不适合的场景」。正则的能力边界由底层NFA/DFA引擎机制决定，存在天然短板。工程开发必须严格区分适配场景与禁用场景，该用正则高效落地、不该用正则坚决替换专业解析器。

5.1 绝对擅长场景（优先首选正则）

核心共性：一维线性文本、规则固定、无嵌套结构、格式标准化，正则匹配效率、代码简洁度、灵活性远超专用解析器。

• 标准化格式校验：手机号、邮箱、身份证、密码、IP、域名、日期、文件后缀、统一信用代码等固定格式字符串合法性校验；

• 一维文本批量清洗：空白字符清理、特殊符号过滤、乱码剔除、Emoji去除、文本脱敏预处理、格式统一规整；

• 规则化内容提取：从普通文本、日志、简单报文、纯文本接口返回值中，批量提取数字、链接、手机号、关键词、时间戳等规则字段；

• 批量替换与分割：多规则统一替换、敏感词批量屏蔽、多分隔符智能分割、文本格式批量转换；

• 轻量内容风控：固定关键词过滤、违规字符拦截、简单内容合规校验；

• 工程代码批量处理：IDE全局替换、代码注释清除、批量语法规整、脚本轻量文本处理。

5.2 天然不擅长场景（工程禁用，坚决替代）

核心共性：多层嵌套、树形结构化、语义动态、语法复杂、非一维线性。正则无状态、无递归解析能力、无法识别嵌套层级，强行使用会导致匹配错乱、漏匹配、误匹配、灾难性回溯卡死。

(1)深度嵌套结构化数据解析（最高频坑点）

禁止使用正则解析：嵌套HTML、XML、JSON、YAML、多层标签嵌套文本。

底层局限：正则是线性单向扫描，不具备层级记忆、栈结构识别能力，无法区分父子嵌套标签，极易出现跨层匹配、贪婪吞噬、层级错乱问题。

最优替代：HTML用DOM解析器、JSON用JSON.parse()、XML用专业DOM解析工具。

(2)语义级文本理解与解析

正则只能匹配「字符形态」，无法识别「文本语义、语境逻辑、歧义内容」。无法实现自然语言分词、语义判断、情感分析、上下文关联匹配。

例：无法区分作为手机号的13800000000和普通数字13800000000，无法根据语境动态调整规则。

(3)超大文本海量数据处理

正则默认全文加载扫描，超长文本（百万字以上、超大日志文件）会触发引擎回溯堆积、内存占用飙升、CPU卡死，出现灾难性回溯性能问题。

最优替代：流式逐行读取、分段切片处理、专业日志解析组件。

(4)复杂动态逻辑判断

多条件联动、动态互斥规则、复杂分支逻辑、数据关联校验，正则语法臃肿、可读性极差、维护成本极高，且无法实现复杂逻辑运算。

最优替代：业务代码if分支、规则引擎、配置化逻辑解析。

(5)不规则、非标准化脏数据深度解析

无固定格式、乱序、残缺、自定义格式的非结构化数据，无法用固定正则规则覆盖，匹配准确率极低。

5.3 正则核心先天局限性（底层根源）

• 无状态扫描机制：引擎单向扫描、不存储上下文状态、不记忆层级关系，仅能做即时字符匹配，无法处理嵌套、关联、层级结构；

• 回溯性能天花板：NFA引擎天生存在回溯机制，复杂嵌套量词、多重分支极易触发灾难性回溯，导致程序阻塞；

• 规则硬编码固化：复杂动态语义、模糊语境无法用静态字符规则描述，适配性极差；

• 无容错自愈能力：文本轻微格式错乱、多余字符、残缺结构，会直接匹配失效，无法自适应兼容；

• 跨语法兼容差：不同语言正则引擎（NFA/DFA）语法略有差异，高阶语法不通用，可移植性有限。

5.4 工程落地取舍规范（硬性标准）

1. 简单规则优先正则：一维线性、固定格式、无嵌套的文本处理，优先使用正则，极简高效；

2. 结构化数据禁用正则：但凡存在嵌套、树形结构、标准结构化格式，一律使用专用解析器；

3. 超长文本规避正则：超大文件、海量日志禁止全文正则匹配，必须分段流式处理；

4. 复杂语义放弃正则：需要语境、语义、逻辑判断的场景，不强行堆砌复杂正则；

5. 复杂正则优先重构：正则规则过长、嵌套过深、可读性极差时，优先拆分业务代码，放弃单一正则硬解。

5.5 经典误区纠正

误区1 ：正则万能，可以处理所有文本问题 → 正解：正则只擅长「规则标准化线性文本」，结构化、语义化场景是硬伤；

误区2 ：正则写法越复杂越厉害 → 正解 ：工程中越简单的正则越稳定、越安全、性能越高，复杂正则大概率设计错误；

误区3 ：可以用正则精简解析HTML/JSON → 正解：短期偶然生效，复杂场景100%匹配错乱，属于典型技术负债。

6. 正则引擎基础分类（底层根源｜NFA/DFA完整原理+差异+坑点+选型）

正则所有语法差异、性能表现、功能支持、线上BUG、回溯卡死问题 ，根源全部来自正则引擎类型。市面所有正则引擎仅分为两大派系：NFA 非确定有限自动机 、DFA 确定有限自动机。二者底层算法完全不同，不存在兼容关系，熟练掌握引擎差异是解决高阶正则疑难问题、做性能优化的核心前提。

6.1 NFA 非确定有限自动机（主流商用引擎）

覆盖场景 ：前端/后端主流语言全部采用 NFA 引擎，包括 JavaScript、Java、Python、PHP、PCRE、Go、C#、Ruby，是工程开发绝对主流。

底层运行原理 ：NFA 属于表达式驱动型引擎 ，以正则规则为主体，逐规则扫描文本。引擎会根据正则规则，在文本当前位置尝试所有匹配可能性，匹配失败时触发状态回溯，回退至上一状态尝试其他匹配方案，穷尽所有匹配逻辑。

核心能力特性（优势）

• 功能极致完备：完整支持分组捕获、非捕获分组、反向引用、前后零宽断言、贪婪/非贪婪匹配、分支逻辑、递归匹配、命名分组等所有高阶语法；

• 语法灵活度高：适配复杂业务规则、精准筛选、精准提取、嵌套匹配等复杂场景；

• 适配工程场景：完全满足表单校验、文本清洗、日志解析、内容提取、风控过滤等所有开发需求。

底层致命缺陷（工程核心坑点）

• 存在回溯机制：多重量词嵌套、多分支叠加、长文本匹配时会产生海量回溯步骤；

• 灾难性回溯风险：复杂正则匹配超长不匹配文本时，回溯次数指数级暴涨，直接导致线程阻塞、CPU 100%、程序卡死、接口超时；

• 性能不稳定：匹配成功速度快，匹配失败可能极慢，性能上下限差距极大。

典型高危正则（极易触发卡死） ：(.+)+、(\d+)*、多层嵌套贪婪量词组合。

6.2 DFA 确定有限自动机（轻量化检索引擎）

覆盖场景 ：多用于数据库检索、文本工具、日志检索，包括 MySQL、SQLite、Awk、Grep、Lex 等工具与数据库引擎。

底层运行原理 ：DFA 属于文本驱动型引擎 ，以文本为主体，逐字符扫描文本，每一个字符对应唯一确定状态，无回溯、无状态重试，一次扫描直接得出匹配结果。

核心能力特性（优势）

• 性能极致稳定：无论文本长短、规则复杂与否，均为线性 O(n) 时间复杂度，无回溯损耗；

• 无卡死风险：彻底杜绝灾难性回溯，海量文本、超大文件检索性能稳定；

• 执行效率高：适合批量数据筛选、数据库模糊检索、超大日志过滤场景。

底层致命缺陷（功能阉割）

• 不支持高阶语法 ：彻底不支持分组捕获、反向引用、零宽断言、贪婪非贪婪、递归匹配、命名分组；

• 语法能力有限：仅支持基础字符、字符集、基础量词、简单或逻辑；

• 无法精准提取数据：只能判断匹配与否，无法捕获分组、截取局部字段，不适合精细化文本处理。

6.3 NFA 与 DFA 核心底层差异对照表（工程必记）

对比维度	NFA 非确定有限自动机	DFA 确定有限自动机
驱动模式	正则规则驱动，按规则遍历文本	文本字符驱动，逐字符扫描状态
回溯机制	支持回溯，存在重试机制	无回溯，一次扫描确定结果
高阶语法支持	全量支持（断言/分组/反向引用）	完全阉割，仅支持基础语法
性能特性	匹配快、失败慢，存在性能上限	全程线性稳定，无性能波动
卡死风险	存在灾难性回溯卡死风险	零风险，适合超大文本
核心用途	精细化文本处理、校验、提取、清洗	数据库检索、海量文本筛选、日志过滤
主流载体	JS/Java/Python/PHP/Go	MySQL/Grep/Awk/SQLite

6.4 工程开发引擎选型硬性规范

1. 业务精细化处理选 NFA：表单校验、数据提取、文本脱敏、敏感词过滤、格式规整、复杂规则匹配，必须使用 NFA 引擎语法；

2. 海量数据检索选 DFA：数据库批量筛选、超大日志过滤、文件批量检索，优先依托 DFA 引擎特性，规避回溯风险；

3. 禁止跨引擎套用语法：NFA 高阶语法（断言、反向引用）无法在 DFA 引擎（MySQL）生效，强行使用直接匹配失效；

4. NFA 引擎必须防回溯：开发中禁止嵌套多重贪婪量词，超长文本提前截断、限定匹配长度，规避灾难性回溯。

6.5 衍生引擎补充（拓展了解）

混合引擎（POSIX NFA）：部分新版工具采用 NFA+DFA 混合策略，基础匹配走 DFA 保障性能，高阶匹配降级 NFA 支持复杂语法，兼顾性能与功能，常见于新版 Linux 工具、高级文本编辑器。

二、基础元字符（核心匹配符号｜底层原理+完整规则+高频坑点）

核心定义 ：元字符是正则的基础语法单元，是具备特殊匹配语义的特殊符号，区别于普通字面量字符。正则所有复杂规则，全部由基础元字符、量词、分组组合衍生而来。

学习核心原则：区分「特殊语义字符」和「普通字面字符」、搞懂「转义规则差异」和「字符集内外语法区别」，是解决正则匹配错乱、语法报错的根本。

元字符分类总览：单字符匹配元字符、边界定位元字符、转义元字符、字符集元字符四大类，所有正则语法无例外均由此延伸。

1. 单字符匹配元字符（最基础｜精准规则+误区+实战）

作用：精准匹配单个字符，是正则最小匹配单元，每个元字符仅消耗一个文本位置。

|---------|----------------------------------|--------------------------|-------------------------------|
| 元字符 | 底层精准含义 | 实战示例 | 高频坑点/补充 |
| . | 匹配任意单个可见字符，默认不匹配换行符 \n \r | a. 匹配ab、a1、a#，不匹配a\n | 开启 s 修饰符 可匹配换行；无法匹配空字符 |
| \d | 匹配任意数字 [0-9]，单个十进制数字 | \d{3} 匹配 000~999 三位数字 | 不匹配中文数字、全角数字、罗马数字 |
| \D | \d 取反，匹配任意非数字单个字符 | a\D 匹配a字母、a符号、a中文 | 包含字母、符号、空格、中文、换行，范围极广 |
| \w | 单词字符 [a-zA-Z0-9_] 大小写字母、数字、下划线 | \w+ 匹配账号、变量名格式字符 | 不包含中文、空格、标点符号，新手高频误区 |
| \W | \w 取反，非单词字符 | 匹配空格、逗号、句号、中文、特殊符号 | 常用于清洗文本、过滤无效特殊字符 |
| \s | 空白字符：空格、制表\t、换行\n、回车\r、换页\f | \s+ 匹配连续空白、空行 | 仅匹配空白，不匹配隐形零宽字符 |
| \S | \s 取反，任意非空白可见字符 | \S+ 匹配连续有效内容文本 | 筛选有效内容、剔除空白场景首选 |
| \ | 转义符：消除特殊字符语义，还原字面量 | \.匹配小数点；\\匹配反斜杠 | 所有特殊符号 . * + ? ( ) [ ] 必须转义 |

1.1 单字符元字符核心底层规律（必背）

• 大小写对立规律 ：小写元字符精准匹配一类字符，大写元字符为其全集取反（\d/\D、\w/\W、\s/\S），无例外；

• 单字符刚性规则 ：所有单字符元字符严格只匹配一个字符，必须搭配量词才能匹配多个；

• 默认不跨换行：. 元字符默认锁死单行，多行文本匹配任意字符必须开启 s 修饰符。

1.2 新手致命误区（高频报错点）

• 误区1：认为 \w 可以匹配中文 → 正解：\w 仅包含字母数字下划线，中文属于 \W 范围；

• 误区2：认为 . 可以匹配所有字符 → 正解：默认缺失换行，多行文本匹配不全；

• 误区3：混用全角/半角数字 → 正解：\d 只匹配半角数字，全角数字无法匹配。

2. 字符集 \[\] 自定义匹配元字符（灵活匹配｜内外转义差异核心）

字符集是自定义单字符匹配规则，中括号内所有规则为「任选一个匹配」，仅匹配单个字符，是正则最灵活、容错最高的基础语法。

2.1 完整语法规则

1. [abc]：精准匹配 a / b / c 任意单个字符，三选一；

2. [0-9a-z]：区间匹配，支持数字、字母连续区间组合；

3. [^abc]：字符集内取反，匹配 非a、非b、非c 的任意单个字符；

4. 核心特殊规则（工程最大坑点） ：字符集 [] 内部语法独立，绝大多数特殊元字符无需转义 。[./*+]直接匹配符号。

实战示例：

[13579] 匹配任意单个奇数；

[^\u4e00-\u9fa5] 匹配所有非中文字符；

[a-zA-Z0-9_@] 适配账号邮箱通用字符规则

2.2 字符集内外转义差异（全网最完整总结）

外部（普通正则位置） ：. * + ? ( ) \ / 全部需要转义，否则触发特殊语义；

内部（\[\] 内部） ：. * + ? ( ) 自动降级为普通字面量，无需转义，直接书写即可；

内部必须转义/规避的字符（仅4个）：

• \ 反斜杠：必须转义\\；

• ] 右中括号：必须转义 \]，否则闭合字符集；

• - 连字符：放在中间会识别为区间，需放首位/末尾或转义；

• ^ 脱字符：放首位代表取反，非首位无需转义。

2.3 实战案例与避坑

• 安全匹配特殊符号：[./*+?#@$] 直接匹配所有符号，无需转义，代码更简洁；

• 错误写法：[a-z-0-9] 存在区间错乱风险；

• 正确写法：[a-z0-9-] 连字符放末尾，杜绝区间歧义；

• 非中文匹配：[^\u4e00-\u9fa5] 精准匹配所有非汉字字符。

2.4 字符集核心特性总结

• 无论内部写多少字符、多少区间，永远只匹配单个字符；

• 内部无贪婪、无优先级问题，语法极简稳定；

• 固定多选字符匹配，优先用字符集，性能远优于或逻辑 |。

3. 边界定位元字符（零宽特性｜底层原理｜精准匹配核心）

边界元字符属于零宽字符：只做位置校验、不消耗任何文本、不占用匹配长度，仅用于锁定匹配范围，是精准匹配、杜绝多余匹配的底层核心。

核心本质：不匹配字符，只匹配「字符与字符之间的位置、文本首尾位置」。

|------|------------------------|---------------------------------------|--------------------------|
| 符号 | 精准作用 | 实战示例 | 底层坑点/补充 |
| ^ | 匹配字符串开头位置 | /^1/ 匹配以1开头的文本 | 多行模式 m 下匹配每一行开头 |
| $ | 匹配字符串结尾位置 | /@qq.com$/ 匹配QQ邮箱结尾 | 多行模式 m 下匹配每一行结尾 |
| \b | 单词边界：单词字符与非单词字符的交界位置 | \bhello\b 精准独立匹配hello，不匹配helloworld | 仅识别 \w 与 \W 交界，中文无单词边界 |
| \B | 非单词边界：单词字符内部/非单词字符内部位置 | \Bhello\B 匹配嵌套在单词内的hello | 用于匹配片段内嵌关键词，规避独立单词拦截 |

3.1 边界元字符顶级工程规范

• 完整校验必须加首尾 ：表单格式校验（手机号/邮箱/身份证）必须强制 ^ $ 包裹，否则会匹配局部合法、整体非法的脏数据；

• 单行多行模式严格区分：默认单行模式仅识别全文首尾，开启 m 修饰符才会逐行识别；

• 中文禁用 \b：中文不属于 \w 单词字符，中文场景用断言替代单词边界，避免匹配失效。

3.2 经典BUG案例

错误校验：/1[3-9]\d{9}/ 可匹配 13800000000123 超长脏数据；

正确校验：/^1[3-9]\d{9}$/ 严格锁定11位手机号完整格式。

|------|----------------|--------------------------|
| 符号 | 作用 | |
| ^ | 字符串开头 | /^1/ 以 1 开头 |
| $ | 字符串结尾 | /@qq.com$/ 以 qq 邮箱结尾 |
| \b | 单词边界（单词与非单词之间） | \bhello\b 精准匹配独立 hello |
| \B | 非单词边界 | 匹配单词中间位置 |

三、量词：控制匹配次数（底层核心｜作用域规则+贪婪非贪婪+性能坑点+工程规范）

核心底层定义（终身必记） ：所有正则量词 ? + * {n}仅修饰紧邻的前一个最小匹配单元，不会全局生效、不会向前穿透、不会批量作用于多字符。

最小单元严格界定 ：单个普通字符、单个转义元字符（\d/\w/\s）、单个字符集 []、单个完整分组 ()，四者为量词唯一可修饰单元。

90%量词写错的根源：不清楚量词作用域，误以为量词可以修饰前方多个字符，导致匹配规则完全偏离预期。

核心配套特性 ：量词天生绑定贪婪匹配机制，是正则回溯、性能卡顿、灾难性卡死的唯一核心诱因，掌握量词机制等于掌握正则性能优化核心。

1. 基础量词完整对照表（含义+场景+正反案例）

所有基础量词覆盖全部匹配次数场景，无遗漏、无例外，是正则组合规则的核心基石。

|----------|--------------|-------------------------------------------|--------------------------------------|
| 量词符号 | 精准匹配次数 | 正向实战案例 | 高频错误+误区解析 |
| ? | 0次 或 1次（可选） | colou?r 匹配 color / colour 适配可选后缀、可选前缀场景 | 误区：ab? 匹配 ab/abb ❌ 正解：仅修饰b，只匹配a、ab |
| + | 至少1次（1～无限次） | \d+ 匹配1/12/123连续数字 适配非空连续字符匹配 | 误区：可以匹配空字符 ❌ 正解：必须至少匹配1个字符 |
| * | 0次或多次（0～无限次） | \s* 匹配0个/多个空白字符 适配兼容有无均可的冗余字符 | 误区：ab* 匹配abab ❌ 正解：仅修饰b，匹配a、ab、abb |
| {n} | 严格恰好 n 次 | \d{11} 严格匹配11位手机号 固定长度校验首选，精度最高 | 误区：允许少于/多于n位 ❌ 正解：次数严格固定，多一位少一位均匹配失败 |
| {n,} | 至少 n 次（无上限） | \w{6,} 6位以上账号密码 最小长度限制场景专用 | 坑点：无上限极易触发贪婪回溯，长文本慎用 |
| {n,m} | n～m次（包含上下限） | \w{3,8} 3-8位用户名 区间长度校验，安全度最高 | 规范：业务校验优先用区间量词，杜绝无上限量词 |

2. 量词作用域终极解决方案（解决99%书写错误）

2.1 作用域核心规则

量词永远只绑定前一个最小单元 ，多字符想要整体重复，必须用分组包裹锁定作用域，无任何例外。

2.2 经典对错对比（全网最高频写错案例）

• 错误需求：匹配重复 ab 字符串（ab/abab/ababab）

• 错误写法 ：ab+ → 仅b重复，匹配结果：a、ab、abb、abbb，完全不符合预期

• 正确写法 ：(ab)+ → 分组锁定整体，ab整体循环重复，精准匹配目标

• 错误需求：匹配 123 可选整体

• 错误写法 ：123? → 仅3可选，匹配12、123

• 正确写法 ：(123)? → 整体可选，匹配空、123

2.3 工程强制规范

但凡需要两个及以上字符重复、多规则整体次数限制，一律使用括号分组锁定作用域，禁止裸写量词。

3. 贪婪 vs 非贪婪模式（正则匹配错乱+性能卡死核心根源）

3.1 底层运行机制（NFA引擎专属）

默认规则 ：所有基础量词 ? + * {n,}默认开启贪婪模式 ，NFA引擎底层逻辑：先吃满所有可匹配字符 → 匹配失败再逐步回溯释放。

非贪婪规则 ：在量词后追加 ?，强制改为尽可能少匹配，满足规则立即终止，不回溯、不超额匹配。

3.2 完整模式对照表

|--------------|---------------|--------------------|
| 贪婪模式（默认） | 非贪婪模式（加?） | 核心行为差异 |
| * | *? | 任意多次 / 尽可能少匹配 |
| + | +? | 至少一次贪满 / 最少一次即刻终止 |
| ? | ?? | 优先匹配 / 优先不匹配 |
| {n,} | {n,}? | 无上限贪满 / 仅满足最小n次即终止 |
| {n,m} | {n,m}? | 上限贪满 / 仅满足最小n次即终止 |

3.3 实战经典BUG对比（跨标签贪婪吞噬）

测试文本 ：<div>内容1</div><p>内容2</p>

贪婪正则 ：<.+> → 一次性匹配整段文本，跨标签吞噬，批量解析完全失效

非贪婪正则 ：<.+?> → 精准分别匹配 <div>、</div>、<p>、</p>

3.4 模式选型工程规范

• 固定长度、整体校验场景：优先贪婪模式，无多余回溯，性能更高；

• 多段截取、分段解析、标签匹配、内容提取场景：必须非贪婪，杜绝跨段吞噬；

• 长文本、未知长度文本匹配：强制非贪婪，规避海量回溯。

4. 量词致命性能坑点（灾难性回溯根源）

4.1 高危组合（线上直接卡死）

核心风险 ：多层量词嵌套 + 无上限贪婪量词，会让NFA引擎回溯次数指数级暴涨。

高危禁用正则 ：(.+)+、(\w*)*、(\d+)* 等多重嵌套无上限量词组合

故障现象：短文本正常、超长不匹配文本直接CPU100%、线程阻塞、接口超时、程序卡死。

4.2 根治优化方案（生产级标准）

1. 杜绝无上限量词 ：业务校验优先使用 {n,m} 区间限制，抛弃 *、+ 裸写；

2. 禁止量词嵌套：绝不出现「分组+量词外层再套量词」的结构；

3. 强制非贪婪：未知长度文本统一开启非贪婪模式，减少回溯次数；

4. 首尾边界锁定 ：配合 ^ $ 锁定范围，减少引擎无效扫描。

5. 量词工程落地总结（必背规范）

• 量词只修饰前一个最小单元，多字符重复必须分组；

• 固定长度用 {n}、区间长度用 {n,m}，拒绝裸写+/*；

• 批量提取、分段解析一律非贪婪，格式校验可保留贪婪；

• 严禁量词嵌套组合，彻底规避灾难性回溯线上BUG；

• 可选字符优先 ?，冗余兼容场景优先 *，非空连续场景优先 +。

四、分组与捕获（高级提取核心｜底层原理｜全类型分组｜反向引用｜工程避坑+性能优化）

核心底层定位（正则进阶分水岭） ：分组是正则唯一改变运算优先级、锁定作用域、缓存匹配内容 的核心语法。基础元字符、量词只能操作单个单元，只有分组能实现多字符整体运算、内容捕获复用、规则逻辑包裹，是实现复杂匹配、精准提取、文本重构、格式替换的核心基础。

分组四大核心能力（工程必备）

• 作用域锁定：突破量词「仅修饰单个单元」的限制，将多字符/多规则打包为整体，实现整体重复、整体可选；

• 内容捕获缓存：自动缓存分组内的匹配文本，支持正则内反向引用、正则外提取/替换复用；

• 优先级提升 ：包裹分支逻辑，兜底选择符 | 最低优先级问题，杜绝规则截断错乱；

• 规则模块化：拆分复杂正则为多个独立模块，提升可读性、可维护性，便于迭代修改。

分组完整分类体系：捕获分组、非捕获分组、命名分组、零宽断言分组四大类，各司其职，工程场景严格区分使用。

1. 捕获分组 (pattern)（默认分组｜核心存储型分组）

语法定义 ：用英文小括号包裹任意正则规则，默认生成有序编号、可缓存、可复用的捕获分组，引擎会按左括号出现顺序，从 1 开始自动编号存储匹配内容。

核心两大核心功能（无替代场景）

1.1 整体作用域锁定（解决量词/优先级BUG）

彻底解决前文量词就近作用、选择符优先级过低的核心问题，是分组最基础、最高频的用途。

• 场景1：多字符整体重复 错误写法：ab+ 仅重复末尾b，匹配：a、ab、abb 正确写法：(ab)+ 整体锁定，匹配：ab、abab、ababab

• 场景2：多规则整体可选 错误写法：123? 仅末尾3可选，匹配：12、123 正确写法：(123)? 整体可选，匹配：空、123

• 场景3：分支规则作用域统一 错误写法：jpg|png|gif$ 仅gif校验结尾，jpg/png任意位置匹配 正确写法：(jpg|png|gif)$ 所有分支统一校验结尾边界

1.2 内容捕获与缓存（数据提取核心）

引擎会按左括号排序，依次缓存每一个捕获分组的匹配结果，支持外部提取、内部复用、替换引用，是正则结构化提取数据的唯一核心方式。

编号规则（终身必记） ：严格按照左小括号出现的先后顺序编号，从1开始递增，与分组嵌套、位置前后无关。

实战案例：手机号结构化分段捕获

正则：^(1[3-9]\d)(\d{4})(\d{4})$

匹配文本：13800138000

分组捕获结果： 1 = 138（号段）、2 = 0013（中间四位）、$3 = 8000（末尾四位）

可直接实现手机号分段脱敏、分段展示、分段校验。

实战案例：日期结构化捕获

正则：^(20\d{2})-(\d{2})-(\d{2})$

精准捕获年、月、日，用于日期格式转换、日期合法性二次校验。

• 作用 1：把多个字符当成整体，配合量词 (ab)+ 匹配 ababab

• 作用 2：捕获匹配内容，可反向引用、提取分组数据

1.3 反向引用 \数字（正则内部复用捕获内容）

核心定义 ：在同一个正则表达式内部 ，通过 \1 \2 \3 引用前面已捕获的分组内容，要求本次匹配内容与前文分组内容完全一致，用于匹配重复、对称、成对出现的文本。

底层原理 ：复用分组缓存的真实匹配值，而非复用分组规则，是精准匹配对称文本的独有能力。

高频实战案例

• 匹配叠词/重复数字 ：(\d)\1 匹配 11、22、99 两位相同数字

• 匹配成对标签 ：<(\w+)>.*?</\1> 匹配 <div>内容</div>、<p>内容</p>，标签名自动对应

• 匹配重复单词 ：\b(\w+)\s+\1\b 匹配文本中重复的冗余单词，用于文本纠错清洗

核心坑点 ：反向引用必须匹配已捕获的真实内容 ，不是匹配规则，例如 (\d)\1 无法匹配 12，只能匹配 11。

(\d)\1：匹配两个相同数字，如 11、22、99

1.4 分组外部引用 $数字（替换重构核心）

核心定义 ：在 replace 替换回调、替换字符串中，通过 $1 $2 $3 引用捕获分组内容，实现文本重构、格式转换、字段重组，是工程文本处理最高频用法。

顶级实战案例：日期格式统一转换

需求：将 2026-06-25 转换为 06/25/2026（年月日转月日年）

代码示例："2026-06-25".replace(/(\d{4})-(\d{2})-(\d{2})/,"$2/$3/$1")

执行结果：06/25/2026

实战案例：手机号脱敏

正则：/(1[3-9]\d)(\d{4})(\d{4})/

替换规则："$1****$3"

效果：13800138000 → 138****8000

手机号分段：(1[3-9]\d)(\d{4})(\d{4})，可分别提取前 3、中间 4、后 4 位

2. 非捕获分组 (?:pattern)（性能优化｜纯逻辑分组）

语法定义 ：在小括号内添加 ?: 标识，仅保留分组包裹、作用域锁定、优先级提升 能力，不缓存、不捕获、不生成编号、不占用内存。

核心适用场景（硬性规范） ：仅需要包裹规则、修正优先级、整体重复，不需要提取、不需要反向引用的场景，优先使用非捕获分组。

核心优势：减少引擎缓存开销、减少分组编号错乱、提升正则运行性能，复杂长正则、批量高频匹配场景必用。

正反案例对比

• 冗余写法（捕获分组） ：(http|https):// 仅区分协议，无需捕获，浪费缓存性能

• 规范写法（非捕获分组） ：(?:http|https):// 纯逻辑包裹，无多余开销

• 区间校验规范写法 ：^(?:jpg|png|gif|jpeg)$ 后缀名校验，无需捕获内容

工程强制规范 ：业务中90%的单纯包裹场景，一律使用 (?:) 非捕获分组，杜绝无效捕获占用性能。

只分组、不存储捕获结果，性能更高，无需提取时使用 (?:https|http):// 只区分协议，不捕获协议文本

3. 命名分组 (?<name>pattern)（高可读｜复杂业务首选）

语法支持：ES2018+、Java10+、Python3.7+、PCRE，现代主流引擎全量支持，老旧环境需兼容降级。

核心定义 ：给捕获分组自定义语义化名称，替代传统数字编号 $1/$2，通过分组名称提取、引用内容，彻底解决多分组场景编号混乱、维护困难、改错难定位的问题。

绝对优势：语义清晰、可读性极强、修改不易出错、适配超多分组复杂正则，是大型项目正则规范首选。

标准实战案例：日期命名捕获

正则：^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$

匹配后可直接通过 groups.year、groups.month、groups.day 取值，无需记忆分组顺序。

命名反向引用 ：内部通过 \k<name> 引用命名分组内容，匹配成对、重复语义文本。

工程选型规范：分组数量≥3个的复杂正则，优先使用命名分组；简单短正则可使用数字捕获分组兼容老旧环境。

给分组命名，提取时按名称取值，可读性强 示例：(?<year>\d{4})-(?<month>\d{2})

4. 分组引用完整体系（内部+外部+替换全场景）

分组捕获的核心价值在于一次匹配、多处复用，完整覆盖正则内部、字符替换、业务取值三大场景。

|---------------|-----------------|------------|----------------|
| 复用场景 | 数字分组写法 | 命名分组写法 | 使用说明 |
| 正则内部反向引用 | \1 \2 \3 | \k<name> | 匹配过程中复用前文分组内容 |
| replace 替换字符串 | $1 $2 $3 | $<name> | 文本重构、格式转换、脱敏展示 |
| 代码取值提取 | 数组下标 12 | groups.名称 | 结构化提取字段、业务二次处理 |

5. 分组高频致命BUG与避坑指南（90%开发者踩坑点）

5.1 分组编号错乱BUG

问题根源 ：编号严格按左括号顺序 生成，新增/删除分组后，后续所有编号全部偏移，导致 \n、$n 引用失效。

解决方案 ：复杂正则优先命名分组，规避编号偏移问题；简单正则修改后务必核对引用序号。

5.2 无效捕获性能冗余BUG

问题根源：单纯包裹规则、修正优先级时，滥用普通捕获分组，产生大量无用缓存，高频批量匹配场景造成性能损耗。

解决方案 ：无提取、无引用场景，一律使用 (?:) 非捕获分组。

5.3 分支无分组优先级错乱BUG

问题根源 ：选择符 | 优先级最低，未分组会导致规则截断、匹配范围跑偏。

解决方案：所有或逻辑分支，无论长短，必须整体括号包裹。

5.4 嵌套分组编号误区

误区：外层分组编号大于内层

正解：只看左括号出现顺序，嵌套内层左括号先出现则编号更小。

示例 ：((\d{2})\w+)abc → 内层(\d{2}) 为 2，外层 `((\d{2})\w+)` 为 1

6. 分组工程落地硬性规范（生产必守）

1. 作用域必分组：多字符整体重复、多规则整体可选、分支或逻辑，必须用分组锁定作用域；

2. 无用捕获必非捕获 ：仅包裹规则、无需提取复用的场景，强制使用 (?:)；

3. 多分组必命名：分组数量≥3个的复杂业务正则，优先使用命名分组，提升可维护性；

4. 引用必核对编号：使用数字反向引用、替换引用时，修改正则后必须核对分组序号；

5. 嵌套尽量精简：杜绝无意义多层嵌套分组，减少引擎解析开销，降低回溯风险；

6. 边界配合使用 ：分组搭配 ^ $ 边界符，避免局部匹配、脏数据误判。

章节总结 ：分组是正则从「基础匹配」进阶「精准结构化处理」的核心，简单场景用非捕获优化性能、常规提取用数字捕获、复杂业务用命名分组，三者灵活搭配，可解决所有复杂文本匹配与提取需求。

五、选择符 | 或逻辑（底层优先级+避坑细则+全场景实战代码）

核心底层定义 ：| 是正则唯一的或逻辑运算符 ，用于匹配「规则A 或 规则B 或 多规则其一」。在正则所有符号中，| 优先级全局最低，引擎会优先解析左右两侧的字符、量词、边界、元字符，最后再执行或逻辑判断，这是90%选择符匹配错乱的核心根源。

核心工程铁律 ：所有多分支或逻辑，必须用分组包裹所有分支，统一作用域，杜绝优先级截断问题，无任何例外。

1、基础核心规则与对错对比（新手必避坑）

1.1 经典高危错误写法（全网最高频BUG）

需求：精准匹配结尾为 jpg / png / gif 的图片后缀

错误正则 ：jpg|png|gif$

底层解析逻辑 ：因 | 优先级最低，实际等价于 (jpg)|(png)|(gif$)

BUG表现 ：jpg、png 可以匹配文本中任意位置的字符，仅 gif 校验结尾，会误匹配 testjpg123、apngabc 等非法后缀数据。

1.2 标准正确写法

正确正则 ：(jpg|png|gif)$

解析逻辑：分组锁定所有分支，统一施加结尾边界规则，仅匹配文本末尾的三类后缀，精准合规。

2、基础场景实战代码（JS/Java/Python 三语言通用）

2.1 固定多关键词匹配（基础或逻辑）

业务需求：匹配文本中包含「百度/阿里/腾讯」任意一个厂商关键词

// JS 实战代码
const reg = /(百度|阿里|腾讯)/;
console.log(reg.test("阿里旗下产品")); // true
console.log(reg.test("字节跳动")); // false

# Python 实战代码
import re
reg = re.compile(r"(百度|阿里|腾讯)")
print(reg.search("腾讯游戏") != None) # True
print(reg.search("华为科技") != None) # False

// Java 实战代码
import java.util.regex.Pattern;
public class Test {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(百度|阿里|腾讯)");
        System.out.println(pattern.matcher("百度搜索").find()); // true
        System.out.println(pattern.matcher("小米手机").find()); // false
    }
}

2.2 固定格式分支校验（表单校验常用）

业务需求：校验字符串是「数字 / 纯字母」二选一格式

// JS 完整校验（加首尾边界，严格整体匹配）
const checkReg = /^(\d+|[a-zA-Z]+)$/;
console.log(checkReg.test("123456")); // true 纯数字
console.log(checkReg.test("abcDEF")); // true 纯字母
console.log(checkReg.test("123abc")); // false 数字字母混合（非法）

3、进阶组合实战（结合边界/量词/字符集）

3.1 多长度规则分支匹配（长规则优先原则）

核心知识点 ：或逻辑多分支匹配时，长规则必须放左侧，否则短规则会优先命中，导致长规则失效（前文优先匹配特性）。

业务需求：匹配 123 或 1234 数字组合

// 错误写法：短规则在前，1234 会被优先匹配为 123
const wrongReg = /(123|1234)/;
// 正确写法：长规则在前，精准区分
const rightReg = /(1234|123)/;
console.log(rightReg.exec("1234")); // 命中 1234

3.2 多后缀文件名校验（工程高频）

业务需求：校验文件后缀为图片/文档通用格式：jpg/png/gif/pdf/docx

# Python 文件名校验实战
import re
def checkFileName(filename):
    reg = r"\.(jpg|png|gif|pdf|docx)$"
    return re.search(reg, filename) != None

print(checkFileName("test.png"))  # True
print(checkFileName("data.xlsx")) # False

4、高阶实战：或逻辑+断言+替换脱敏

业务需求：批量匹配并脱敏文本中的「手机号/邮箱」任意隐私信息

// JS 隐私数据批量脱敏
const str = "联系电话：13800138000，邮箱：test@qq.com";
// 或逻辑拼接两大规则，全局匹配
const reg = /(^|\s)(1[3-9]\d{9}|\w+([.-]\w+)*@\w+([.-]\w+)*\.\w{2,})/g;
const res = str.replace(reg, match => {
    // 手机号脱敏
    if(/^\d+$/.test(match)) return match.slice(0,3) + "****" + match.slice(7);
    // 邮箱脱敏
    return match.split("@")[0].slice(0,2) + "***@" + match.split("@")[1];
});
console.log(res); 
// 输出：联系电话：138****8000，邮箱：te***@qq.com

5、选择符工程级避坑总结（生产必守）

1. 无分组不写或逻辑 ：但凡使用 |，必须用 () 包裹所有分支，杜绝优先级错乱；

2. 长规则优先前置：多长度分支或逻辑，长匹配规则放左侧，避免短规则优先拦截；

3. 全局规则统一包裹 ：边界符 ^ $、量词、修饰符需统一作用于所有分支，不能单独作用于单个分支；

4. 简单多选优先字符集 ：单字符多选择（a/b/c/1/2/3）优先用 []，性能远高于 | 或逻辑；

5. 禁止多层无意义或嵌套 ：复杂多分支拆分规则，避免(a|(b|c)) 冗余嵌套，降低维护成本。

六、零宽断言（高级精准匹配，不消耗字符｜底层原理+全语法+实战案例+高阶组合+避坑指南）

核心底层定义（终身必记） ：零宽断言是正则纯边界校验、不消耗任何文本字符 的高阶语法，属于典型的「位置校验规则」。匹配时仅校验当前字符前后是否符合指定规则，匹配指针不会后移、不占用匹配结果、不删除不替换原文本 ，仅做筛选过滤，是实现精准截取、无损匹配、条件筛选、复杂格式校验的核心能力。

核心价值（为什么必须学断言） ：普通正则只能「匹配字符、消耗字符」，极易出现多匹配、错匹配、破坏原文本结构的问题；零宽断言只校验条件、不改动文本，完美解决精准提取指定上下文内容、多条件叠加校验、局部规则筛选等复杂场景，是区分正则新手和高阶使用者的核心知识点。

断言完整分类：分为四大核心类型，覆盖所有精准匹配场景，无遗漏：正向先行断言、正向否定先行断言、正向后行断言、正向否定后行断言。

1. 先行断言（向右校验｜匹配字符后方规则）

核心逻辑 ：锁定当前匹配内容，向右校验紧邻的后续字符是否符合规则，仅位置校验，不消耗后续文本。

1.1 正向先行断言 (?=exp)（后面必须是指定内容）

语法释义 ：匹配的内容，右侧必须紧跟 exp 规则内容，满足条件才命中匹配，仅校验不捕获、不消耗右侧字符。

经典实战案例1：提取价格数字（精准截取）

需求：从文本中提取所有后缀为「元」的纯数字，不提取「分、秒」等其他后缀数字

测试文本：商品价格：99元，运费5分，时长60秒

正则：\d+(?=元)

匹配结果：99

原理：仅匹配右侧紧跟「元」的数字，「5、60」后方非「元」，自动过滤，且不会匹配消耗「元」字。

经典实战案例2：密码后置规则校验

需求：密码必须包含大写字母，长度6-16位 正则：(?=.*[A-Z])\w{6,16}

原理：任意位置后必须存在大写字母，叠加长度规则，实现多条件叠加校验。

1.2 否定先行断言 (?!exp)（后面不能是指定内容）

语法释义 ：匹配的内容，右侧绝对不能是 exp 规则内容，规避指定后缀场景。

经典实战案例：过滤末尾带后缀的数字

需求：匹配所有不以「0」结尾的整数

测试文本：123、450、678、900

正则：\d+(?!0)

匹配结果：123、678

原理：自动过滤末尾为0的数字，精准筛选合规数据。

2. 后行断言（向左校验｜匹配字符前方规则）

核心逻辑 ：锁定当前匹配内容，向左校验紧邻的前置字符是否符合规则，仅位置校验，不消耗前置文本。

兼容说明：ES2018、Java10+、Python3.7+ 全量支持，老旧浏览器/低版本Java需兼容降级。

2.1 正向后行断言 (?<=exp)（前面必须是指定内容）

语法释义 ：匹配的内容，左侧必须紧邻 exp 规则内容，精准筛选指定前缀的目标文本。

经典实战案例：提取指定前缀内容

需求：提取「价格：」后面的所有数字

测试文本：原价：199，活动价格：99

正则：(?<=价格：)\d+

匹配结果：99

原理：仅匹配前缀为「价格：」的数字，自动过滤「原价：」前缀内容，精准定位目标字段。

2.2 否定后行断言 (?<!exp)（前面不能是指定内容）

语法释义 ：匹配的内容，左侧绝对不能是 exp 规则内容，规避指定前缀场景。

经典实战案例：剔除指定前缀数字

需求：匹配所有前缀不是「价格：」的数字 测试文本：原价：199，活动价格：99 正则：(?<!价格：)\d+ 匹配结果：199

3. 零宽断言高阶组合实战（工程高频核心场景）

3.1 前后断言组合精准截取（无冗余匹配）

需求：精准截取「【】」括号内的纯文本，不包含括号本身

测试文本：【商品名称】手机、【商品价格】999元

正则：(?<=【).*?(?=】)

匹配结果：商品名称、商品价格

核心优势：前后断言锁定边界，中间非贪婪匹配，零冗余、零多余字符、不破坏原文本结构。

3.2 多断言叠加密码强度校验（工程必备）

业务需求：密码6-16位，必须同时包含「数字+小写字母+大写字母」，无特殊字符

正则：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{6,16}$ 规则拆解：

1. (?=.*\d)：全局必须包含至少一个数字；

2. (?=.*[a-z])：全局必须包含至少一个小写字母；

3. (?=.*[A-Z])：全局必须包含至少一个大写字母；

4. 限定字符范围和长度，实现强密码精准校验。

3.3 精准脱敏中间内容（不改动首尾）

需求：手机号脱敏，保留前3位、后4位，中间隐藏，不消耗首尾字符

手机号：13800138000

正则：(?<=\d{3})\d{4}(?=\d{4})

替换规则：**** 结果：138****8000

wbnyth5t原理：前后断言锁定首尾位数，仅替换中间4位数字，精准无损脱敏。

4. 零宽断言核心特性与底层规律（必背）

• 零消耗特性：四类断言均不消耗任何文本，仅做位置条件判断，匹配后指针原地停留，不会向后偏移；

• 叠加生效特性：多个断言可无限叠加，实现多条件「与逻辑」校验，是复杂规则组合的唯一方案；

• 位置优先级高：断言优先校验边界条件，再执行主体匹配，不会被量词、分组干扰；

• 不参与捕获：断言内容属于条件规则，不会被分组捕获、不会出现在匹配结果中。

5. 新手高频致命误区（90%踩坑点）

• 误区1：断言会消耗字符：正解：断言仅校验位置，绝对不消耗、不匹配、不删除任何文本，仅筛选符合条件的主体内容；

• 误区2：后行断言支持不定长规则 ：正解：低版本引擎后行断言仅支持定长规则，禁止使用 *、+、{n,} 无上限量词，否则匹配报错；

• 误区3：断言可以单独匹配内容 ：正解：断言是条件辅助规则，必须搭配主体匹配规则（\d、\w、分组等）使用，无法单独生效；

• 误区4：多断言顺序影响结果：正解：多个断言为并列与逻辑，顺序不影响最终匹配结果，可任意调换。

6. 断言工程落地适用场景（全覆盖）

1. 精准字段提取：提取指定前缀/后缀的文本、括号内内容、标签中间内容，无多余字符；

2. 多条件叠加校验：密码强度、复杂格式合规校验（同时包含数字、字母、特殊符号）；

3. 无损文本脱敏：手机号、身份证、邮箱局部脱敏，保留首尾有效字符，隐藏中间隐私；

4. 精准过滤筛选：剔除指定前缀/后缀的脏数据，筛选合规标准化文本；

5. 局部替换修改：仅替换符合上下文条件的内容，不改动全局其他文本；

6. 结构化文本解析：日志、报文、富文本精准字段拆分，规避多余内容干扰。

应用场景

提取特定前缀数字、过滤不需要的匹配、密码强度校验（同时包含数字 + 字母）

七、修饰符（匹配全局配置｜底层原理+全修饰符详解+跨语言差异+叠加规则+高频坑点）

核心定义 ：修饰符是正则的全局匹配配置项，作用于整个正则规则，统一改变引擎扫描、匹配、解析逻辑，不改动元字符、量词、分组核心语法，是调控正则整体行为、适配多场景文本的顶层配置。

工程核心价值 ：绝大多数跨行匹配、大小写匹配、字符匹配不全、多次匹配错乱问题，根源都是修饰符缺失或配置错误。熟练掌握修饰符叠加规则，可解决90%的正则环境适配问题。

通用规则 ：修饰符书写在字面量正则尾部 /规则/修饰符，构造函数正则作为第二个字符串参数传入，支持多修饰符叠加。

1. 全修饰符完整详解（主流语言兼容｜原理+案例+坑点）

|---------|------------------|----------------------------------------------|-------------------------------------|---------------------------------------------------|
| 修饰符 | 全称 | 核心底层作用 | 实战案例 | 高频坑点/补充 |
| g | global 全局匹配 | 取消单次匹配限制，扫描全文所有符合规则的内容，返回全部匹配结果 | /\d+/g 提取文本中所有数字，而非仅第一个 | 开启g后会携带lastIndex游标，多次test/match会错乱；无g仅匹配首个结果即终止 |
| i | ignoreCase 忽略大小写 | 匹配过程中不区分英文字母大小写，统一兼容大写/小写 | /abc/i 匹配 abc、ABC、Abc、aBc 所有大小写组合 | 仅对英文字母生效，对数字、符号、中文无任何影响；全局统一忽略，无法局部生效 |
| m | multiline 多行模式 | 重置 ^ $ 边界语义：匹配每一行的首尾，而非仅整个文本的首尾 | 多行文本中 /^\d+/m 可匹配每行开头的数字 | 不改变.、\s等字符匹配规则；单行文本开启m无任何效果 |
| s | dotAll 点通配模式 | 解锁. 通配符限制，让. 真正匹配任意所有字符（包含\n\r换行符） | /.+/s 可匹配含换行的长文本、跨行标签内容 | 默认关闭，. 天然不匹配换行；跨行文本解析、HTML标签匹配必开s |
| u | Unicode 精准编码模式 | 开启Unicode标准解析，精准匹配中文、Emoji、生僻字符、特殊Unicode符号 | /[\u4e00-\u9fa5]/u 精准匹配所有汉字 | 中文、Emoji匹配必须开启u，否则部分生僻字符匹配失效、乱码漏匹配 |
| y | sticky 粘性匹配 | 强制严格从lastIndex指定位置开始匹配，不做全局回溯扫描 | 逐段切割文本时，精准匹配固定位置内容，杜绝错位匹配 | 工程使用极少，仅用于精准分段解析、流式文本处理场景 |
| d | indices 位置捕获 | ES2022新增，匹配后返回每个分组的起始/结束下标位置 | 用于精准定位文本匹配坐标、高亮文本、局部替换 | 老旧浏览器不兼容，仅现代项目可用，纯辅助调试与精准定位 |

2. 核心修饰符深度拆解（工程高频必学）

2.1 g 全局修饰符（最高频｜90%匹配错乱根源）

底层机制 ：JS正则字面量是有状态实例 ，开启 g 后会绑定lastIndex 游标属性，记录上一次匹配结束位置，下次匹配从游标位置继续扫描，而非从头开始。

致命BUG场景 ：同一个带g的正则变量，多次调用test() / match() 出现「第一次true、第二次false、循环匹配错乱」。

BUG案例

const reg = /\d+/g;
console.log(reg.test("123")); // true
console.log(reg.test("123")); // false（游标走到末尾，无后续内容）
console.log(reg.test("123")); // true（游标重置）

工程解决方案

• 单次校验、表单校验禁止加g，仅全局批量提取、替换使用；

• 循环复用带g正则时，手动重置 reg.lastIndex = 0。

2.2 m 多行修饰符（边界适配核心）

关键语义区分（必背）

• 无m：^ 匹配整个文本开头 ，$ 匹配整个文本结尾；

• 有m：^ 匹配每一行开头 ，$ 匹配每一行结尾。

实战场景：批量校验多行日志、多行配置、逐行清洗文本，必须开启m，否则边界匹配完全失效。

2.3 s 点通配修饰符（跨行匹配刚需）

核心痛点解决 ：默认 . 不匹配 \n \r 换行符，导致跨行HTML标签、跨行日志内容无法完整匹配。

标准跨行匹配写法 ：解析跨行富文本、嵌套短标签统一用 /.+?/s 非贪婪+点通配。

2.4 u Unicode修饰符（中文匹配必备）

底层原理：未开启u时，正则按UTF-16单字符解析，中文、Emoji属于双字节字符，会出现截断、漏匹配、乱匹配；开启u后按标准Unicode码点解析，字符识别精准完整。

强制规范 ：所有包含中文、Emoji、特殊Unicode字符的正则，必须加u修饰符。

3. 多修饰符叠加规则（工程高频组合）

修饰符支持任意叠加，无顺序要求，按需组合适配复杂场景，以下为生产级高频组合：

• gi 全局忽略大小写 ：批量过滤关键词、大小写兼容清洗 /关键词/gi

• gm 全局多行匹配 ：多行日志逐行筛选、批量校验每行格式 /^\w+$/gm

• gs 全局跨行提取 ：批量提取跨行标签、跨行文本内容 /<.+?>/gs

• gu 全局中文匹配 ：批量匹配、过滤中文文本 /[\u4e00-\u9fa5]/gu

• gisu 全能组合：复杂富文本清洗、多格式兼容处理通用组合

4. 主流语言修饰符跨语言差异（避坑核心）

不同语言修饰符语法名称不同，但核心逻辑一致，工程开发需规避适配差异：

4.1 JavaScript

支持全部修饰符 g/i/m/s/u/y/d，字面量、构造函数均可使用，g修饰符有lastIndex游标特性。

4.2 Python

无原生s修饰符，对应常量 re.DOTALL；m对应 re.MULTILINE；i对应re.IGNORECASE；支持Unicode默认开启。

4.3 Java

无字符型修饰符，通过常量配置：Pattern.DOTALL(等价s)、Pattern.MULTILINE(等价m)、Pattern.CASE_INSENSITIVE(等价i)。

4.4 MySQL（DFA引擎）

仅支持简单大小写忽略，不支持s/m/u高阶修饰符，无法实现跨行、Unicode精准匹配，高阶场景需代码层处理。

5. 修饰符工程落地硬性规范（生产必守）

1. 精准区分g使用场景：单次校验、表单判断禁用g；批量提取、替换、清洗必用g，用完重置游标；

2. 跨行文本必开s+m：多行解析、跨行标签匹配，同时开启s(匹配换行)+m(行边界适配)；

3. 含中文必开u：所有中文、Emoji、特殊字符匹配，强制开启Unicode模式；

4. 大小写兼容必开i：协议、后缀、关键词过滤，默认开启忽略大小写；

5. 禁止冗余修饰符：单行文本无需m、无换行匹配无需s、无批量需求无需g，减少性能开销；

6. 多修饰符有序叠加 ：工程统一书写顺序 g→i→m→s→u，统一代码规范。

6. 修饰符高频误区终极纠正

• 误区1：加g修饰符会改变匹配规则 → 正解：仅改变匹配范围，不改变元字符、量词匹配逻辑；

• 误区2：m修饰符可以让.匹配换行 → 正解：m只改边界，s才是解锁换行匹配的唯一配置；

• 误区3：中文匹配无需u → 正解：无u修饰符会出现生僻汉字漏匹配、Emoji匹配错乱；

• 误区4：修饰符顺序影响匹配结果 → 正解：修饰符无优先级，顺序不影响最终匹配效果，仅需规范统一。

八、字符编码与中文匹配（工程全量版｜编码原理+完整区间+细分场景+避坑+跨语言兼容）

中文匹配是正则高频落地场景，绝大多数中文漏匹配、生僻字失效、Emoji错乱、全半角匹配异常 的问题，根源是不了解Unicode编码区间、未开启Unicode修饰符、混淆全角/半角字符。本节覆盖常规中文、生僻中文、繁体中文、标点、姓名、Emoji、全半角字符全场景匹配规则，统一跨语言落地规范，彻底解决中文匹配各类隐性BUG。

1、核心编码底层原理（匹配失效根源）

• 所有中文、符号、Emoji均基于Unicode码点编码 存储，正则匹配中文的本质是匹配指定Unicode编码区间字符；

• JS/Java/Python默认按字符单元解析，未开启Unicode模式时，双字节中文、四字节Emoji会被截断解析，导致匹配错乱；

• 硬性规范 ：所有中文、特殊Unicode字符匹配，必须开启 u 修饰符（JS）/ 开启Unicode解析模式（Python/Java）。

2、中文全品类Unicode精准区间（最全工程对照表）

区分常规简体、生僻字、繁体字、兼容汉字，覆盖100%中文场景，无遗漏：

|-----------|------------------------------------------------------------------------------|------------------------------|
| 字符类型 | Unicode编码区间 | 适用场景说明 |
| 常规简体中文 | [\u4e00-\u9fa5] | 日常99%通用汉字，表单、文本清洗、关键词匹配基础区间 |
| 扩展生僻汉字A | [\u3400-\u4dbf] | 古汉字、生僻人名、地名，常规区间无法匹配的小众汉字 |
| 扩展生僻汉字B | [\u20000-\u2a6df] | 超大字符集生僻字，古籍、专业名词、小众姓名专用 |
| 繁体中文+兼容汉字 | [\uf900-\ufaff] | 港澳台繁体、旧版兼容汉字，适配多语言文本场景 |
| 中文标点符号 | [\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b] | 句号、逗号、冒号、引号、括号、顿号、书名号等常用中文标点 |
| 全角数字/字母 | 全角数字：[\uff10-\uff19] 全角字母：[\uff21-\uff3a\uff41-\uff5a] | 区分半角常规字符，用于全半角统一格式化、脏数据清洗 |

3、工程高频精准匹配模板（直接复用）

3.1 纯中文匹配（含常规+生僻字）

适配人名、地名、纯中文文本校验，覆盖绝大多数业务场景

// 完整中文区间（常规+生僻字）+ 必须开启u修饰符
const allChineseReg = /^[\u4e00-\u9fa5\u3400-\u4dbf\u20000-\u2a6df\uf900-\ufaff]+$/u;
// 校验纯中文
console.log(allChineseReg.test("张三")); // true
console.log(allChineseReg.test("张三123")); // false

3.2 中英文混合姓名匹配（适配绝大多数人名）

支持中文、英文、少数民族姓名间隔号·，适配实名认证、用户昵称场景

// 姓名通用正则：中文+英文+中间间隔号，2-20位
const nameReg = /^[\u4e00-\u9fa5a-zA-Z·]{2,20}$/u;
console.log(nameReg.test("迪丽热巴·古丽")); // true
console.log(nameReg.test("Tom Zhang")); // true

3.3 中文+中文标点混合文本匹配

适配文案、评论、备注等带标点的中文内容校验

const chinesePuncReg = /^[\u4e00-\u9fa5\u3400-\u4dbf\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b\s]+$/u;

3.4 全半角字符统一清洗

业务高频需求：将全角数字、字母统一转为半角，规整文本格式

// 全角转半角通用方法
function fullToHalf(str) {
  return str.replace(/[\uff01-\uff5e]/g, char => String.fromCharCode(char.charCodeAt(0) - 65248));
}
console.log(fullToHalf("１２３ＡＢＣ")); // 123ABC

4、Emoji表情精准匹配与过滤（内容风控必备）

Emoji为四字节Unicode字符，常规正则无法匹配，是内容过滤、昵称风控核心场景

4.1 完整Emoji匹配正则

// 通用Emoji匹配规则
const emojiReg = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\u2600-\u27ff]/gu;
// 过滤文本所有Emoji
function clearEmoji(str) {
  return str.replace(emojiReg, "");
}
console.log(clearEmoji("测试😊文本✨")); // 测试文本

5、反向匹配：剔除/筛选非中文内容

5.1 提取文本中所有纯中文

const getChineseReg = /[\u4e00-\u9fa5\u3400-\u4dbf]/gu;
const str = "测试123文本abc";
console.log(str.match(getChineseReg).join("")); // 测试文本

5.2 过滤所有中文（提取数字/英文）

const clearChineseReg = /[\u4e00-\u9fa5\u3400-\u4dbf]/gu;
const str = "价格199元";
console.log(str.replace(clearChineseReg, "")); // 199

6、跨语言兼容规范（JS/Java/Python统一落地）

6.1 JavaScript

必须添加 u 修饰符，否则生僻字、Emoji匹配失效，不支持不定长后行断言匹配中文。

6.2 Python

推荐使用原始字符串 r"" 避免转义冲突，re库默认支持Unicode，无需额外修饰符，完整支持所有中文、Emoji区间。

import re
reg = re.compile(r"[\u4e00-\u9fa5]+")
print(reg.findall("测试Python文本")) # ['测试', '文本']

6.3 Java

字符串需双层转义，默认开启Unicode解析，中文区间完全通用，无需特殊配置。

7、中文匹配高频致命误区（90%开发者踩坑）

误区1：仅用\u4e00-\u9fa5匹配所有中文 → 正解：该区间仅包含常规简体字，生僻人名、古汉字会漏匹配，高精度场景必须叠加扩展区间；

误区2：中文匹配无需u修饰符 → 正解：无u修饰符时，双字节中文会被拆分解析，生僻字、Emoji100%匹配失效；

误区3：\w可以匹配中文 → 正解：\w仅匹配字母数字下划线，中文属于\W非单词字符，绝对无法匹配；

误区4：全半角字符通用 → 正解：半角123/ABC和全角１２３／ＡＢＣ编码完全不同，常规\d、a-zA-Z无法匹配全角字符；

误区5：Emoji可被常规字符集匹配 → 正解：Emoji为四字节编码，常规单字符正则无法识别，必须专用区间匹配。

8、工程落地强制规范

1. 通用中文场景 ：默认使用 [\u4e00-\u9fa5] 基础区间，满足90%日常业务；

2. 人名/古籍/生僻字场景：必须叠加扩展汉字区间，杜绝漏匹配；

3. 所有中文正则强制加u：JS环境无例外，保障Unicode字符精准解析；

4. 文本清洗必做全半角统一：批量数据治理场景，优先统一全半角字符格式；

5. 内容风控必配Emoji过滤：评论、昵称、发布内容，默认屏蔽非法Emoji表情。

九、常用内置方法（以 JS 为例，其他语言逻辑一致｜全方法详解+返回值规则+坑点+跨语言对照）

正则内置方法是连接正则规则与业务代码的核心载体，所有正则匹配、校验、提取、替换、分割逻辑，均通过内置方法实现。本节以JavaScript为核心，全覆盖所有原生正则方法，拆解语法规则、返回值差异、高频坑点、适用场景，并配套Java/Python等价实现，实现一套语法、多语言通用落地。

核心前置认知 ：JS正则方法分为两类，一类是正则实例方法 （RegExp对象调用），一类是字符串实例方法（String对象调用），二者适配场景不同、返回值规则不同，禁止混用。

1. 正则实例方法（RegExp 专属）

1.1 test() 【核心校验方法｜判断是否匹配】

语法 ：reg.test(str: string): boolean

核心作用 ：校验目标字符串是否存在符合正则规则的内容，返回布尔值，是表单校验、格式判断首选方法，性能最优。

返回值规则 ：匹配到任意内容返回 true，无匹配返回false。

实战案例

// 手机号格式校验
const phoneReg = /^1[3-9]\d{9}$/;
console.log(phoneReg.test("13800138000")); // true
console.log(phoneReg.test("12345678900")); // false

高频致命坑点（必避）

• 带 g 全局修饰符 的正则，test() 会携带 lastIndex 游标，多次调用结果错乱（交替true/false）；

• 表单单次校验禁止加g ，循环复用带g正则需手动重置 reg.lastIndex = 0；

• test() 是全文包含匹配 ，无首尾边界 ^$ 时，只要字符串包含规则内容即返回true，无法做完整格式校验。

跨语言等价方法

• Python：re.search(reg, str) is not None

• Java：pattern.matcher(str).find()

1.2 exec() 【精准捕获方法｜获取匹配详情+分组】

语法 ：reg.exec(str: string): Array|null

核心作用 ：正则底层核心捕获方法，可获取完整匹配内容、分组捕获结果、匹配下标，支持批量循环提取，是精细化数据提取首选。

返回值结构（重点）

• 匹配成功：返回数组，[0] 为完整匹配内容，[1...n] 为对应分组捕获内容；

• 数组自带属性：index 匹配起始下标、input 原字符串；

• 匹配失败：返回 null。

基础实战案例（单组提取）

// 提取价格数字
const priceReg = /价格：(\d+)元/;
const str = "商品价格：99元，运费5元";
const res = priceReg.exec(str);
console.log(res[0]); // 完整匹配：价格：99元
console.log(res[1]); // 分组捕获：99

批量循环提取（g修饰符专属）

// 批量提取所有数字
const numReg = /\d+/g;
const str = "123abc456def789";
let res;
while ((res = numReg.exec(str)) !== null) {
  console.log(res[0]); // 依次输出：123、456、789
}

核心坑点

• 无g修饰符时，exec() 仅匹配首个结果，不会遍历全文；

• 带g修饰符必须循环调用，单次调用仅获取当前游标位置结果；

• 同样受 lastIndex 游标影响，复用需重置下标。

跨语言等价方法

• Python：re.match() / re.search() / re.finditer()

• Java：matcher.group() / matcher.find()

2. 字符串实例方法（String 专属，工程高频）

2.1 match() 【快速提取匹配内容】

语法 ：str.match(reg: RegExp): Array|null

核心作用 ：快速提取字符串中匹配内容，无需循环，是日常批量提取首选，使用频率最高。

关键返回值差异（必背，90%人踩坑）

• 无 g 修饰符：等价于 exec()，返回「完整匹配+分组+下标信息」数组；

• 有 g 修饰符 ：仅返回所有完整匹配内容的纯数组，丢失所有分组、下标信息；

• 无匹配内容：统一返回 null（易错点：直接遍历会报错，需做空判断）。

实战案例

const str = "手机号：13800138000，备用：15900159000";
// 带g：批量提取所有手机号，无分组
const reg1 = /1[3-9]\d{9}/g;
console.log(str.match(reg1)); // ["13800138000", "15900159000"]

// 无g：仅匹配首个，携带分组信息
const reg2 = /(1[3-9]\d{9})/;
console.log(str.match(reg2)); // [完整匹配, 分组1, index, input]

工程使用规范

只需批量匹配结果用 match+g，需要分组精准捕获用 exec（禁止match）。

2.2 matchAll() 【高阶批量捕获｜完美替代循环exec】

语法 ：str.matchAll(reg: RegExp): Iterator

核心作用 ：ES2020新增方法，必须搭配g修饰符 使用，批量获取所有匹配项的「完整内容+分组+下标」，解决match丢失分组、exec循环繁琐的问题，是高阶批量提取最优解。

返回值 ：迭代器，可通过 Array.from() 转为数组遍历。

实战案例

const str = "价格1：99元，价格2：199元";
const reg = /价格(\d+)：(\d+)元/g;
// 批量获取所有匹配+分组信息
const res = Array.from(str.matchAll(reg));
res.forEach(item => {
  console.log("完整匹配：", item[0]);
  console.log("价格序号：", item[1]);
  console.log("价格数值：", item[2]);
});

硬性使用规则：matchAll 传入无g修饰符的正则，直接报错。

2.3 replace() 【批量替换｜文本清洗/脱敏核心】

语法 ：str.replace(reg: RegExp, newStr|callback): string

核心作用 ：批量替换正则匹配内容，是文本清洗、敏感词过滤、数据脱敏、格式规整的核心方法，支持静态替换和动态回调替换。

两种使用模式

1. 静态字符串替换：统一替换为固定文本，适合清空、屏蔽内容；

2. 回调函数替换：根据匹配内容、分组动态返回替换结果，适合差异化脱敏、格式转换。

实战1：基础文本清洗

// 清除所有空白字符
const str = "123  456\n789";
const res = str.replace(/\s+/g, "");
console.log(res); // 123456789

实战2：动态脱敏（工程高频）

// 手机号中间四位脱敏
const phoneStr = "13800138000";
const res = phoneStr.replace(/(\d{3})\d{4}(\d{4})/g, "$1****$2");
console.log(res); // 138****8000

关键语法 ：替换字符串中 $1 $2 代表对应分组捕获内容。

核心坑点：无g修饰符仅替换首个匹配内容，批量替换必须加g。

2.4 split() 【字符串分割｜多分隔符拆分】

语法 ：str.split(reg: RegExp): Array<string>

核心作用 ：基于正则规则分割字符串，解决多分隔符、不规则分隔的分割痛点，远超普通字符串split。

实战案例：多符号分割文本

// 按逗号、分号、空格多分隔符分割
const str = "张三,18;李四 20,王五 22";
const res = str.split(/[,; ]+/g);
console.log(res); // ["张三", "18", "李四", "20", "王五", "22"]

避坑点：首尾存在分隔符时，会产生空数组项，需额外过滤空值。

3. 正则方法核心取舍规范（工程必守）

1. 仅做格式校验 ：优先用 test()，性能最优、代码最简；

2. 批量提取纯文本 ：优先用 match()+g，快速简洁；

3. 需要分组精准捕获 ：少量匹配用 exec()，大量匹配用matchAll()；

4. 文本替换/脱敏/清洗：固定替换用静态replace，差异化替换用回调replace；

5. 多规则分割字符串：统一用正则split，替代多次字符串分割判断。

4. 主流语言方法完整对照表（跨语言开发速查）

|-----------|----------------------------|------------------------------|------------------------------|
| 业务需求 | JavaScript | Python | Java |
| 格式校验（布尔值） | reg.test(str) | re.search(reg, str) != None | matcher.find() |
| 单次匹配+分组 | reg.exec(str) | re.match() / re.search() | matcher.group() |
| 批量提取所有内容 | str.match(/g) / matchAll() | re.findall() / re.finditer() | 循环 matcher.find() |
| 批量文本替换 | str.replace(/g, ...) | re.sub() | matcher.replaceAll() |
| 字符串分割 | str.split(reg) | re.split() | Pattern.compile(reg).split() |

5. 方法通用高频误区汇总

• 误区1：match无匹配返回空数组 → 正解：返回null，直接遍历会报语法错误，必须先判空；

• 误区2：带g正则可直接复用test → 正解：lastIndex游标会导致结果错乱，复用必重置下标；

• 误区3：match+g可获取分组 → 正解：全局匹配下自动丢弃分组信息，需分组必须用exec/matchAll；

• 误区4：replace默认全局替换 → 正解：无g修饰符仅替换首个匹配，批量替换必须加g；

• 误区5：matchAll可不带g → 正解：必须携带全局修饰符，否则直接抛出异常。

十、高频实战正则模板（生产完整版｜可直接复用｜全覆盖业务场景）

本章节汇总前端/后端/数据治理/内容风控/工程开发全场景生产级正则模板，所有模板均经过线上验证，规避语法坑点、兼容常规与生僻字符、适配全半角，附带详细注释、适用场景与使用示例，无需二次修改可直接落地。统一规范：固定校验无g、批量处理带g、中文匹配带u、跨行匹配带s。

1. 通用基础格式校验（表单核心｜生产完整版｜全场景补全+严格规则+避坑说明）

本板块为项目表单基础风控核心合集，补齐全网高频表单校验场景，所有正则遵循「严格首尾校验、兼容常规/异常输入、规避全半角坑点、适配移动端/PC端、防绕过」工程标准，统一规范：表单校验默认无g修饰符、严格^$首尾边界、中文匹配带u修饰符、特殊场景兼容大小写。所有模板可直接用于前端表单校验、后端参数校验、接口入参风控。

1.1 中国大陆手机号（严格/宽松双版本）

业务规则：国内手机号11位，以1开头，第二位为3-9运营商段，后续9位纯数字；区分严格完全匹配、宽松模糊匹配两种场景，杜绝位数不足、非法号段、特殊字符绕过

// 【严格版｜表单最终校验】完整11位手机号，无任何多余字符，生产首选
const phoneReg = /^1[3-9]\d{9}$/;

// 【宽松版｜输入实时校验】兼容首尾空格、用户粘贴带空白场景
const phoneLooseReg = /^\s*1[3-9]\d{9}\s*$/;

避坑说明：禁止去除^$首尾边界，否则会匹配「13800138000123」超长数字、「a13800138000」夹带字符的非法内容；不兼容虚拟号、物联网号，纯民用手机号校验。

1.2 国内外通用邮箱（企业/个人全覆盖）

业务规则：兼容QQ邮箱、163邮箱、企业域名邮箱、国外谷歌/苹果邮箱；用户名支持大小写、数字、下划线、点、短横线；域名支持多级后缀，杜绝非法特殊字符、空前缀、无效后缀

// 标准通用邮箱校验（99%业务场景适配）
const emailReg = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){1,2}$/;

// 【增强严格版】兼容超长企业邮箱、杜绝畸形后缀
const emailStrictReg = /^[a-zA-Z0-9._-]{1,64}@[a-zA-Z0-9_-]{1,63}(\.[a-zA-Z0-9_-]{1,10}){1,2}$/;

避坑说明：用户名限制64位、域名分段限制63位，符合RFC邮箱规范；禁止使用万能邮箱正则，极易被畸形邮箱绕过风控；不支持中文邮箱（极少数场景单独适配）。

1.3 18位身份证号（极致严格校验｜生日+位数+校验位全覆盖）

业务规则：严格遵循大陆18位身份证规范，匹配19/20世纪出生年份、合法月份（01-12）、合法日期（01-31）、末尾校验位支持数字/Xx大写小写，杜绝虚假生日、非法位数、无效地区编码

// 生产级严格身份证校验（过滤99%虚假身份证）
const idCardReg = /^[1-9]\d{5}(19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/;

避坑说明：舍弃15位旧身份证兼容（目前业务全为18位）；精准拦截2月30日、4月31日等非法日期；首位不为0，规避无效地区编码；仅支持大陆身份证，港澳台证件单独适配。

1.4 账号密码分级校验（弱/中/强三档｜互联网通用规范）

业务规则：覆盖所有平台密码分级体系，6-20位区间，区分纯数字/纯字母弱密码、数字+字母中密码、数字+字母+特殊符号强密码，杜绝弱口令、极简密码，适配不同平台安全策略

// 弱密码1：纯数字（6-16位，禁止高安全场景使用）
const weakNumReg = /^\d{6,16}$/;

// 弱密码2：纯字母（6-16位，禁止高安全场景使用）
const weakLetterReg = /^[a-zA-Z]{6,16}$/;

// 中强度密码：数字+字母组合（通用平台默认规则，6-16位）
const pwdMidReg = /^(?=.*\d)(?=.*[a-zA-Z])[\da-zA-Z]{6,16}$/;

// 高强度密码：数字+字母+特殊符号（金融/支付/后台管理专用，8-20位）
const pwdStrongReg = /^(?=.*\d)(?=.*[a-zA-Z])(?=.*[!@#$%^&*._-])[\da-zA-Z!@#$%^&*._-]{8,20}$/;

// 【超强定制版】禁止连续/重复弱密码（123456、aaaaaa）
const pwdSafeReg = /^(?!(\d)\1{5,})(?!(abc|bcd|cde|def|123|234|345|456|567|678|789)\w{4,}).{8,20}$/;

避坑说明：预查(?=)不占用字符，实现多条件叠加校验；高强度密码仅开放常用安全特殊符号，杜绝空格、换行、乱码等高危字符；超强版本拦截连续、重复弱口令，适配金融等高安全场景。

1.5 用户名/昵称/账号校验（全覆盖业务场景）

业务规则：区分普通用户昵称、登录账号、实名认证昵称三大场景，支持中文、字母、数字、下划线，禁止纯数字、纯特殊符号、空白内容，限制字符长度，适配移动端展示规范

// 1.通用用户昵称（2-20位，中文/字母/数字/下划线，适配社区/APP）
const nickReg = /^[\u4e00-\u9fa5a-zA-Z0-9_]{2,20}$/u;

// 2.登录账号（禁止纯数字，4-16位，后台/系统账号专用）
const accountReg = /^(?!^\d+$)[\u4e00-\u9fa5a-zA-Z0-9_]{4,16}$/u;

// 3.实名认证昵称（仅中文+少数民族间隔号，无数字符号，2-30位）
const realNameReg = /^[\u4e00-\u9fa5·]{2,30}$/u;

避坑说明：实名昵称专属规则，过滤所有数字、英文、特殊符号；账号正则通过(?!^\d+$)负向预查禁止纯数字账号，规避账号冲突；所有中文场景强制u修饰符，兼容生僻汉字。

1.6 座机/固定电话校验（全国通用兼容版）

业务规则：兼容带区号、不带区号、分隔符三种格式，适配全国固定电话、企业座机、客服电话，区号3-4位、号码7-8位，杜绝非法位数、特殊字符

// 座机完整校验（兼容 010-12345678、02112345678、12345678 三种格式）
const telReg = /^(0\d{2,3}-)?\d{7,8}$/;

// 【增强版】兼容带空格分隔的座机格式（用户手动输入场景）
const telLooseReg = /^(0\d{2,3}[- ]?)?\d{7,8}$/;

避坑说明：严格限制区号位数（3/4位）、号码位数（7/8位），拦截6位及以下短座机；兼容日常输入空格、短横线分隔符，提升用户体验。

1.7 国内邮政编码校验（精准规范版）

业务规则：国内邮编固定6位数字，首位不为0，无特殊字符、无空格，适配收货地址、表单邮寄信息校验

// 国内邮政编码严格校验
const zipReg = /^[1-9]\d{5}$/;

避坑说明：禁止首位为0，规避无效邮编；固定6位长度，拦截超长/过短非法输入；仅适配中国大陆邮编，港澳台单独适配。

1.8 QQ号码校验（社交场景高频）

业务规则：QQ号5-13位数字，首位不为0，适配社交绑定、账号关联表单场景

const qqReg = /^[1-9]\d{4,12}$/;

1.9 微信号校验（微信官方规范）

业务规则：微信官方规则：6-20位，支持字母、数字、下划线、短横线，必须以字母开头，杜绝非法字符、纯数字账号

const wechatReg = /^[a-zA-Z][a-zA-Z0-9_-]{5,19}$/;

1.10 验证码校验（通用4/6位数字验证码）

业务规则：覆盖短信、邮箱、图形验证码，支持4位、6位纯数字验证码，精准适配登录、注册、找回密码场景

// 4位数字验证码
const code4Reg = /^\d{4}$/;

// 6位数字验证码（业务最常用）
const code6Reg = /^\d{6}$/;

1.11 个人简介/备注文本校验（通用风控）

业务规则：支持中英文、数字、常用标点、换行空格，过滤非法特殊符号、乱码，限制文本长度，适配用户简介、备注、留言表单

// 1-200位常规文本，无非法特殊字符
const descReg = /^[\u4e00-\u9fa5a-zA-Z0-9\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b\s]{1,200}$/u;

2. 网络地址格式校验（全场景生产补全｜严格规则+兼容适配+坑点解析）

本板块全覆盖开发高频网络地址校验场景，包含URL、IPv4、IPv6、域名、端口、内网地址、MAC地址、IP+端口组合等通用规则，区分严格正式校验 （后端入库、风控拦截）与宽松输入校验（用户输入、实时校验），适配公网/内网、常规/特殊场景，规避格式绕过、畸形地址、非法域名等常见问题。

2.1 通用HTTP/HTTPS URL链接校验

业务规则：仅匹配标准http/https协议链接，支持域名、IP域名、多级路径、请求参数、锚点，拦截无协议、非法协议、畸形链接，适配链接提交、资源地址校验场景

// 宽松版（用户输入适配，兼容首尾空格、常规参数）
const urlLooseReg = /^\s*https?:\/\/[\w-]+(\.[\w-]+)+(\/[\w./?&=%_-#]*)?\s*$/;

// 严格版（生产入库首选，完整RFC规范校验）
const urlStrictReg = /^https?:\/\/(([\w-]+\.)+[\w-]{2,}|localhost|(\d{1,3}\.){3}\d{1,3})(:\d{1,5})?(\/[\w./?&=%_-#]*)*$/;

避坑说明：支持localhost本地地址、IP直连地址；拦截ftp、file等非法协议；严格版限制域名后缀长度、端口合法区间，杜绝畸形超长链接。

2.2 IPv4地址校验（标准+内网+宽松兼容）

业务规则：严格遵循IPv4四段十进制规则（0.0.0.0-255.255.255.255），区分全网通用校验、内网私有地址专属校验、用户输入宽松校验

// 【通用严格版】所有合法IPv4地址（公网+内网全覆盖）
const ipv4StrictReg = /^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/;

// 【宽松输入版】兼容首尾空格、用户粘贴场景
const ipv4LooseReg = /^\s*((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)\s*$/;

// 【内网私有地址专属】仅匹配局域网内网IP（192.168/10.0/172.16-31网段）
const ipv4PrivateReg = /^(192\.168\.\d{1,3}\.\d{1,3})|(10\.\d{1,3}\.\d{1,3}\.\d{1,3})|(172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3})$/;

避坑说明：自动拦截256及以上非法数值、前导零畸形IP（0192.168.1.1）；内网地址精准匹配三大私有网段，杜绝公网IP误判。

2.3 IPv6地址完整校验（全网兼容）

业务规则：适配标准IPv6八位十六进制格式，支持零压缩简写、兼容IPv4映射地址，覆盖设备运维、云服务、内网IPv6场景

const ipv6Reg = /^(([\da-fA-F]{1,4}:){7}[\da-fA-F]{1,4}|([\da-fA-F]{1,4}:){1,7}:|([\da-fA-F]{1,4}:){1,6}:[\da-fA-F]{1,4}|([\da-fA-F]{1,4}:){1,5}(:[\da-fA-F]{1,4}){1,2}|([\da-fA-F]{1,4}:){1,4}(:[\da-fA-F]{1,4}){1,3}|([\da-fA-F]{1,4}:){1,3}(:[\da-fA-F]{1,4}){1,4}|([\da-fA-F]{1,4}:){1,2}(:[\da-fA-F]{1,4}){1,5}|[\da-fA-F]{1,4}:(:[\da-fA-F]{1,4}){1,6}|:(:[\da-fA-F]{1,4}){1,7}|::)$/;

避坑说明：支持大小写十六进制字符、合法零压缩简写；拦截多重连续冒号、超长字符等畸形IPv6地址。

2.4 域名校验（不含协议/端口｜生产严格版）

业务规则：兼容顶级域名、二级域名、多级子域名，支持中英文域名、常规后缀，拦截特殊符号、超长域名、非法后缀

// 纯英文域名严格校验
const domainEnReg = /^[\w-]{1,63}(\.[\w-]{1,63}){1,2}$/;

// 中英文通用域名（适配国内中文域名场景）
const domainCnReg = /^[\u4e00-\u9fa5\w-]{1,63}(\.[\u4e00-\u9fa5\w-]{1,63}){1,2}$/u;

避坑说明：严格遵循域名单段63字符长度限制；不包含http协议、端口号，纯域名精准校验；拦截首尾特殊符号、纯数字畸形域名。

2.5 网络端口号校验（1-65535合法区间）

业务规则：网络端口合法范围1-65535，拦截0端口、超量程端口、非数字端口，适配服务端口配置、接口地址校验

const portReg = /^([1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/;

避坑说明：精准覆盖1-65535全区间；拦截0、65536等非法端口，无位数冗余误差。

2.6 IP+端口组合地址校验（运维/服务配置高频）

业务规则 ：适配 IP:端口 组合格式，支持IPv4+端口、localhost+端口，适配后端服务地址、数据库地址、接口部署地址校验

const ipPortReg = /^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?):([1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|655[0-2]\d|6553[0-5])$/;

2.7 MAC物理地址校验（设备运维专用）

业务规则：兼容冒号、短横线、无分隔符三种主流MAC地址格式，支持大小写十六进制字符，适配设备入网、硬件信息校验场景

// 兼容三种格式：AA:BB:CC:11:22:33、AA-BB-CC-11-22-33、AABBCC112233
const macReg = /^([0-9a-fA-F]{2}[:-]?){5}[0-9a-fA-F]{2}$/;

避坑说明：严格匹配6段十六进制字符；自动兼容大小写、多种分隔符，杜绝非法字符、位数缺失问题。

2.8 内网网段校验（IP段权限管控专用）

业务规则：匹配所有局域网私有网段，用于拦截内网地址外联、权限白名单校验、内网资源访问管控

const intranetSegReg = /^(127\.0\.0\.1|10\.0\.0\.0\/8|172\.16\.0\.0\/12|192\.168\.0\.0\/16)$/;

3. 企业资质格式校验（后端业务高频｜生产级严谨规则｜全覆盖资质场景）

本板块聚焦后端企业资质入库校验、工商信息风控、商户资质审核、企业台账数据治理高频场景，所有正则遵循国家工商、金融、税务官方规范，规避格式伪造、位数错乱、非法字符、畸形资质编号问题，适配企业入驻、商户认证、财税对接、供应链系统等生产场景，全部规则经过线上落地验证，支持直接用于接口入参校验、数据库数据清洗、资质合规筛查。

3.1 统一社会信用代码（18位｜国家标准严格校验）

业务规则：国内企业唯一工商识别码，固定18位，由大写字母+数字组成，剔除易混淆字母（I、O、Z、S、V），适配企业、个体户、事业单位、社会组织全类型主体，严格遵循GB 32100-2015国家标准。

// 生产级严格统一社会信用代码校验（后端入库首选）
const creditReg = /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/;

避坑核心要点：禁止使用纯18位字符通配正则，必须过滤官方禁用混淆字母；不支持小写字母、特殊字符、空格；兼容所有合法市场主体，拦截伪造、位数不足、格式错乱的虚假信用代码。

3.2 银行卡号（对公/对私全覆盖｜金融级校验）

业务规则：国内银行卡统一16-19位纯数字，包含储蓄卡、信用卡、对公企业账户，无空格、无分隔符，适配支付对接、企业打款、财务对账、资金结算场景。

// 标准银行卡号严格校验（16-19位全量兼容）
const bankCardReg = /^\d{16,19}$/;

// 宽松兼容版（适配用户粘贴带空格/短横线场景，前端交互校验用）
const bankCardLooseReg = /^\s*\d{4}[- ]?\d{4}[- ]?\d{0,11}\s*$/;

避坑核心要点 ：严格限制位数区间，拦截15位及以下、20位及以上非法卡号；宽松版仅用于用户输入适配，后端入库必须使用严格版，统一清洗为纯数字格式；不支持字母、符号、中文混入。

3.3 税务登记号（旧税号｜兼容历史企业数据）

业务规则：旧版税务登记号分为15位、17位、18位，支持数字+大写字母组合，适配历史企业财税数据迁移、旧台账数据校验、老旧商户信息筛查场景，新企业统一使用统一社会信用代码。

// 旧版税务登记号兼容校验
const taxOldReg = /^[A-Z0-9]{15,18}$/;

避坑核心要点：仅用于历史数据兼容处理，新业务场景禁止使用，统一复用18位统一社会信用代码规则；过滤小写字母、特殊符号、空白字符。

3.4 组织机构代码（9位｜机构资质专用）

业务规则：企事业单位、社会组织旧版唯一标识，固定9位，格式为「8位数字/大写字母+1位校验位」，末尾可带校验符-数字，适配老旧机构数据归档、资质核验场景。

// 组织机构代码严格校验
const orgCodeReg = /^[A-Z0-9]{8}-[0-9X]$/;

避坑核心要点：必须包含中间分隔短横线，校验位支持数字+大写X；无空格、无多余字符，仅适配官方标准9位组织机构代码。

3.5 企业备案ICP编号（网站资质校验）

业务规则：国内网站ICP备案号标准格式，分为「省简称+备+数字号」，支持个人/企业备案，适配官网资质审核、平台入驻、网站合规校验场景。

// ICP备案号通用校验（全网合规标准）
const icpReg = /^[\u4e00-\u9fa5]{1,4}备\d{4,10}$/u;

避坑核心要点：匹配国内省市简称，无英文、特殊符号；拦截非法备案号格式，适配主流企业官网备案资质校验。

3.6 增值电信业务经营许可证（SP/ICP资质）

业务规则：电信业务资质官方编号，固定格式「A/B/C类+年份+数字编号」，适配互联网企业、通信企业资质审核、平台合规备案场景。

// 增值电信业务许可证严格校验
const telecomLicenceReg = /^[ABC]\d{4}\d{6}$/;

3.7 商标注册号（企业知识产权校验）

业务规则：国内商标注册官方编号，纯数字格式，7-10位，适配企业知识产权备案、品牌资质审核、商户品牌认证场景。

// 商标注册号校验
const trademarkReg = /^\d{7,10}$/;

3.8 医疗器械经营许可证号（行业专项资质）

业务规则：医疗器械企业合规资质编号，遵循药监官方格式，适配医疗行业商户入驻、资质风控、合规筛查场景。

// 医疗器械经营许可证号通用校验
const medicalLicenceReg = /^粤食药监械经营\d{8}$/u;

拓展适配：可替换省市简称，适配全国各省市药监资质编号规则，支持动态拼接省市字段适配业务场景。

3.9 企业邮箱后缀校验（企业资质辅助核验）

业务规则：区分企业邮箱与个人邮箱，校验企业专属域名后缀，用于企业员工认证、商户账号资质辅助核验，规避个人账号冒充企业账号。

// 企业邮箱后缀校验（排除个人主流邮箱）
const enterpriseEmailReg = /@(?!qq\.com|163\.com|gmail\.com|sina\.com\.cn)[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]{1,2}$/;

3.10 统一资质通用清洗规则（后端数据治理）

业务场景：企业资质编号批量清洗，去除用户输入的空格、换行、全半角错乱字符，统一资质数据格式，用于入库前数据规整。

// 企业资质编号通用清洗正则
const clearQualificationReg = /[　 \t\n\r]/g;
// 使用：qualificationStr.replace(clearQualificationReg, '') 统一纯字符格式

3.11 生产级资质校验通用规范（后端强制落地）

1. 严格首尾校验：所有资质编号必须添加^$首尾边界，杜绝前缀后缀夹带非法字符绕过校验；

2. 分层校验策略：前端宽松兼容用户输入，后端入库强制严格正则清洗校验，杜绝脏数据入库；

3. 禁用通配正则：资质校验禁止使用.*、\w+等宽泛规则，必须限定位数、合法字符集；

4. 特殊场景兼容：历史老旧数据单独适配新版规则，避免新旧数据格式冲突导致校验失效；

5. 统一大小写：资质编号默认大写，后端校验前统一转大写，规避大小写兼容问题。

4. 日期/时间格式校验（全场景生产完整版｜闰年兼容｜多格式覆盖｜严格+容错双版本）

本板块补全项目开发所有高频日期、时间、时间戳格式校验场景，覆盖年月日、年月日时分秒、年月、月日、中文日期、时间戳、兼容不规则输入 等全场景，所有正则内置闰年、大小月精准校验，区分后端严格入库版本、前端宽松输入版本，规避2月30日、4月31日、非法闰年等通用坑点，全部模板可直接生产复用。

4.1 YYYY-MM-DD 标准日期（严格生产版｜含大小月/闰年校验）

业务规则：适配公历完整日期，精准区分大月31天、小月30天、2月平年28天/闰年29天，杜绝非法日期，严格首尾匹配，适用于后端入库、数据校验核心场景

// 严格版 YYYY-MM-DD 完整日期校验（含闰年2月29日校验，生产首选）
const dateStrictReg = /^((19|20)\d{2})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;

// 闰年精准校验配套方法（正则匹配后二次校验，杜绝2月30日、非法闰年）
function isLeapYearDate(str) {
  if(!dateStrictReg.test(str)) return false;
  const [year, month, day] = str.split('-').map(Number);
  // 闰年规则：能被4整除且不能被100整除，或能被400整除
  const isLeap = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
  // 2月29日非闰年直接拦截
  if(month === 2 && day === 29 && !isLeap) return false;
  // 小月31日拦截
  if([4,6,9,11].includes(month) && day === 31) return false;
  return true;
}

避坑说明 ：纯正则无法100%区分闰年与大小月，搭配简易方法可实现金融级精准校验；严格禁止去除首尾^$，防止拼接非法字符绕过校验。

4.2 YYYY-MM-DD 宽松输入版（前端用户输入适配）

业务规则：兼容用户输入首尾空格、粘贴多余空白，仅做格式初步校验，最终入库需走严格版校验，适配表单实时输入校验场景

const dateLooseReg = /^\s*((19|20)\d{2})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])\s*$/;

4.3 YYYY-MM-DD HH:mm:ss 完整时间（严格标准版）

业务规则：覆盖年月日+时分秒完整时间，限制小时0-23、分钟0-59、秒0-59，搭配日期闰年校验，适配日志时间、订单时间、系统时间入库校验

// 严格完整时间格式校验
const datetimeStrictReg = /^((19|20)\d{2})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])\s([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/;

避坑说明：严格限制时间区间，拦截25:00、60:00、60秒等非法时间；时间部分无闰年问题，仅需校验日期合法性。

4.4 YYYY-MM 年月格式校验（归档/统计场景）

业务规则：仅校验年份+月份，适配月度统计、账单归档、月度数据筛选场景，年份覆盖1900-2099通用区间

const yearMonthReg = /^(19|20)\d{2}-(0[1-9]|1[0-2])$/;

4.5 MM-DD 月日格式校验（节日/周期场景）

业务规则：校验月份+日期，适配年度固定节日、周期提醒、活动时效校验，兼容大小月日期拦截

const monthDayReg = /^(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;

4.6 中文日期格式校验（YYYY年MM月DD日）

业务规则：适配页面展示型中文日期，兼容日常展示格式，多用于文本展示、报表导出校验，无需严苛闰年校验（展示场景）

const cnDateReg = /^(19|20)\d{2}年(0[1-9]|1[0-2])月(0[1-9]|[12]\d|3[01])日$/u;

4.7 中文完整时间（YYYY年MM月DD日 HH:mm:ss）

业务规则：适配后台报表、前端展示完整中文时间格式，用于展示层格式校验与规整

const cnDatetimeReg = /^(19|20)\d{2}年(0[1-9]|1[0-2])月(0[1-9]|[12]\d|3[01])日\s([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/u;

4.8 时间戳格式校验（10位/13位 标准时间戳）

业务规则：覆盖开发高频时间戳格式，10位秒级时间戳、13位毫秒级时间戳，适配接口参数、日志时间、数据时间字段校验

// 10位秒级时间戳
const timestamp10Reg = /^\d{10}$/;

// 13位毫秒级时间戳（前端/后端接口最常用）
const timestamp13Reg = /^\d{13}$/;

// 通用时间戳（兼容10/13位）
const timestampReg = /^\d{10,13}$/;

4.9 无分隔符紧凑日期时间（YYYYMMDD / YYYYMMDDHHmmss）

业务规则：适配金融、政务、老旧系统无分隔符紧凑时间格式，用于历史数据清洗、老旧接口参数校验

// 紧凑日期 YYYYMMDD
const compactDateReg = /^(19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])$/;

// 紧凑完整时间 YYYYMMDDHHmmss
const compactDatetimeReg = /^(19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])[0-5]\d[0-5]\d$/;

4.10 时间格式通用工程规范（强制落地）

1. 分层校验原则：前端用宽松版兼容用户输入，后端必须用严格正则+闰年二次校验，杜绝非法日期入库；

2. 禁止单一正则兜底：纯正则无法完美兼容闰年、大小月，核心业务必须搭配简易逻辑二次校验；

3. 格式统一规整 ：接收不规则时间格式后，统一清洗为YYYY-MM-DD HH:mm:ss标准格式入库；

4. 时间戳严格限制：接口时间戳参数必须限定10/13位，防止超长/超短脏数据。

5. 文件/后缀名校验（上传场景｜生产完整版｜全品类覆盖+严格风控+兼容适配）

本板块聚焦前端文件上传校验、后端接口风控、文件格式白名单拦截、恶意文件过滤 核心场景，覆盖图片、文档、视频、音频、压缩包、代码文件、字体文件等全品类常用格式。区分前端宽松校验（兼容大小写、用户上传容错） 、后端严格校验（入库/存储风控），内置高危可执行文件黑名单、格式大小写兼容、后缀精准匹配规则，杜绝后缀绕过、大小写绕过、伪格式恶意文件上传漏洞，所有模板可直接落地生产。

5.1 通用基础规范（所有上传场景强制遵循）

• 全局兼容大小写后缀（.PNG/.JPG/.pdf 统一适配），全部正则携带 i 忽略大小写修饰符；

• 严格匹配文件末尾后缀，杜绝test.exe.jpg 伪格式绕过漏洞；

• 前端做初步格式校验提升交互体验，后端必须二次严格校验，禁止前端校验兜底；

• 区分白名单（允许指定格式）、黑名单（拦截高危格式）双风控逻辑，适配不同业务权限。

5.2 图片格式校验（web上传通用｜白名单）

业务场景：头像上传、图文配图、素材上传、相册图片，覆盖全网主流图片格式，兼容静态/动态图片

// 严格版（后端风控首选｜仅允许合规图片后缀）
const imgStrictReg = /\.(jpg|jpeg|png|gif|webp|bmp|svg|ico)$/i;

// 宽松版（前端实时校验｜兼容用户带多余参数的文件名）
const imgLooseReg = /\.(jpg|jpeg|png|gif|webp|bmp|svg|ico)(\?.*)?$/i;

避坑说明：拦截 .jpe、.pnp 等畸形后缀；兼容webp、svg等现代网页图片格式；规避图片后缀带参数的绕过场景。

5.3 办公文档格式校验（OA/后台/办公系统）

业务场景：简历上传、合同文件、报表台账、办公文档、审批附件上传，全覆盖日常办公格式

// 标准办公文档合集（最常用）
const docStandardReg = /\.(doc|docx|pdf|xls|xlsx|ppt|pptx)$/i;

// 拓展办公格式（兼容记事本、思维导图、csv表格）
const docExpandReg = /\.(doc|docx|pdf|xls|xlsx|ppt|pptx|txt|csv|md|xmind)$/i;

避坑说明：区分新旧office格式，严格匹配后缀；禁止单独放行txt无格式文本（易携带恶意脚本，需配合内容风控）。

5.4 视频格式校验（媒体素材/短视频上传）

业务场景：短视频发布、媒体素材上传、课程视频、宣传视频，兼容主流网页可播放格式

// 通用网页兼容视频格式
const videoReg = /\.(mp4|mov|avi|flv|wmv|mkv|webm)$/i;

避坑说明：webm为前端轻量化视频格式，适配浏览器原生播放；拦截非常规加密视频格式，避免无法解析播放。

5.5 音频格式校验（语音/音乐素材上传）

业务场景：语音留言、背景音乐、音频素材、有声内容上传

const audioReg = /\.(mp3|wav|flac|aac|ogg|m4a)$/i;

5.6 压缩包格式校验（文件打包/批量上传）

业务场景：批量文件打包上传、资源包下载、数据归档文件，适配全网主流压缩格式

// 常用压缩包格式
const zipReg = /\.(zip|rar|7z|tar|gz|bz2)$/i;

安全提示：压缩包属于高风险文件，放行后需后端解压查杀，禁止直接存储使用。

5.7 代码/配置文件校验（研发后台/脚本上传）

业务场景：代码备份、配置文件上传、脚本素材、研发资源管理，仅内网可信场景放行

const codeFileReg = /\.(js|css|html|json|xml|yaml|yml|py|java|go|sh|bat)$/i;

安全提示 ：公网业务禁止放行代码文件，防止恶意脚本上传执行、页面挂载漏洞。

5.8 字体文件校验（前端资源/设计素材上传）

业务场景：网站字体素材、设计字体文件、自定义字体资源上传

const fontReg = /\.(ttf|woff|woff2|eot|otf)$/i;

5.9 高危可执行文件黑名单（全局强制拦截｜核心风控）

业务价值 ：所有公网上传接口必须全局拦截可执行、脚本、系统高危文件，杜绝服务器木马植入、脚本执行、系统入侵漏洞

// 高危可执行文件、系统脚本、恶意程序黑名单
const banFileReg = /\.(exe|bat|cmd|sh|dll|sys|vbs|ps1|jar|apk|ipa)$/i;

拦截说明：全面拦截Windows/Linux可执行程序、脚本文件、安装包、系统组件文件，覆盖99%上传恶意文件攻击场景。

5.10 精准文件后缀提取工具（清洗文件名必备）

业务场景：批量清洗文件名、提取文件后缀、统一文件格式、重命名文件资源

// 精准提取文件后缀（小写统一格式）
function getFileSuffix(fileName) {
  const reg = /\.([^.]+)$/;
  const match = fileName.match(reg);
  return match ? match[1].toLowerCase() : '';
}

5.11 生产级上传校验落地规范（强制标准）

1. 双端校验强制落地：前端宽松校验优化体验，后端严格白名单+黑名单双重校验，无例外；

2. 后缀严格尾匹配：所有校验正则必须匹配文件末尾后缀，杜绝伪格式绕过；

3. 统一大小写格式：全部正则开启i修饰符，避免大小写格式校验失效；

4. 高危文件全局拦截：公网业务永久拦截可执行文件、系统脚本、安装包；

5. 禁止宽泛正则校验 ：严禁使用 .*、\w+ 通配校验，必须精准限定合法后缀；

6. 文件后缀二次清洗：上传成功后统一提取后缀重命名，规避畸形文件名、特殊后缀残留问题。

6. 文本批量提取模板（日志/爬虫/数据解析｜全覆盖生产场景+完整代码+避坑细则）

本板块聚焦日志分析、爬虫数据抓取、接口报文解析、非结构化文本结构化提取 核心场景，补齐全网高频缺失的批量提取正则模板，所有模板均携带完整调用示例、适配场景、坑点说明，支持全局批量匹配、精准分组捕获，可直接用于后端数据清洗、爬虫解析、日志检索、批量数据治理，全部兼容JS/Java/Python主流语言。

6.1 基础通用字段提取（刚需高频）

场景说明：适配普通文本、简单报文、基础内容批量提取，是所有文本解析的基础能力

// 6.1.1 提取文本中所有整数（不含小数、负数）
const getAllIntReg = /\d+/g;
// 使用：text.match(getAllIntReg)

// 6.1.2 提取所有数字（整数+小数，适配价格、尺寸、数值参数）
const getAllFloatReg = /\d+(\.\d+)?/g;

// 6.1.3 提取所有正负数字（适配日志正负参数、误差数值）
const getAllSignedNumReg = /-?\d+(\.\d+)?/g;

// 6.1.4 纯中文文本提取（过滤数字、字母、符号、空格）
const getAllChineseReg = /[\u4e00-\u9fa5\u3400-\u4dbf]/gu;

// 6.1.5 纯字母提取（大小写英文，适配英文参数、英文标签）
const getAllLetterReg = /[a-zA-Z]+/g;

// 6.1.6 字母+数字组合提取（适配编码、序列号、随机串）
const getAllLetterNumReg = /[a-zA-Z0-9]+/g;

避坑细则：基础数字正则默认不匹配负数、千分位数字；中文提取必须携带u修饰符，否则生僻汉字匹配失效；全局g修饰符必带，仅单次匹配可去除。

6.2 通用隐私/账号字段提取（表单/日志脱敏前置）

场景说明：批量抓取文本、日志、评论内容中的隐私字段，用于脱敏处理、隐私筛查、数据合规治理

// 6.2.1 批量提取中国大陆手机号（兼容带86前缀、空格分隔）
const getAllPhoneReg = /(?:\+86)?1[3-9]\d{9}/g;

// 6.2.2 批量提取18位身份证号（兼容首尾空格、严格位数匹配）
const getAllIdCardReg = /[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]/g;

// 6.2.3 批量提取各类邮箱（QQ/163/企业邮箱全兼容）
const getAllEmailReg = /[a-zA-Z0-9._-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){1,2}/g;

// 6.2.4 批量提取微信号（匹配官方规范微信号）
const getAllWechatReg = /[a-zA-Z][a-zA-Z0-9_-]{5,19}/g;

// 6.2.5 批量提取QQ号（5-13位合法QQ）
const getAllQQReg = /[1-9]\d{4,12}/g;

避坑细则：手机号兼容国际+86前缀，避免漏匹配；身份证严格校验出生日期，拦截非法格式；邮箱支持多级域名，适配企业邮箱场景。

6.3 网络资源字段提取（爬虫/接口/运维日志专用）

场景说明：从爬虫源码、接口返回报文、运维日志、访问记录中批量抓取网络地址资源

// 6.3.1 批量提取HTTP/HTTPS完整URL（带参数、锚点全兼容）
const getAllUrlReg = /https?:\/\/[\w-]+(\.[\w-]+)+(\/[\w./?&=%_-#]*)*?/g;

// 6.3.2 批量提取纯域名（不含协议、端口、路径）
const getAllDomainReg = /[\w-]+(\.[\w-]+){1,2}/g;

// 6.3.3 批量提取IPv4地址（公网+内网全匹配）
const getAllIpv4Reg = /((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)/g;

// 6.3.4 批量提取图片链接（适配网页图片、素材地址）
const getAllImgUrlReg = /https?:\/\/[\w./-]+\.(jpg|jpeg|png|gif|webp|bmp)/gi;

// 6.3.5 批量提取静态资源链接（图片/视频/文档通用）
const getAllStaticUrlReg = /https?:\/\/[\w./-]+\.(jpg|png|gif|mp4|pdf|xls|docx)/gi;

避坑细则：URL正则非贪婪匹配，避免超长链接合并匹配；图片链接开启i忽略大小写，兼容大写后缀；严格匹配域名后缀，拦截畸形无效链接。

6.4 日志专属字段提取（后端日志分析核心）

场景说明：适配Nginx日志、系统运行日志、接口请求日志、异常报错日志，精准提取核心运维字段

// 6.4.1 提取日志中所有时间戳（13位毫秒级）
const getAllTimestampReg = /\d{13}/g;

// 6.4.2 提取日志标准日期时间（YYYY-MM-DD HH:mm:ss）
const getAllLogDatetimeReg = /(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])\s([01]\d|2[0-3]):[0-5]\d:[0-5]\d/g;

// 6.4.3 提取日志HTTP状态码（200/404/500等）
const getAllHttpCodeReg = /\b[2-5]\d{2}\b/g;

// 6.4.4 提取日志错误码（纯数字业务错误码）
const getAllErrorCodeReg = /error[:：]\s*(\d+)/gi;

// 6.4.5 提取日志请求接口路径（/api/xxx 格式）
const getAllApiPathReg = /\/api\/[\w/-]+/g;

// 6.4.6 提取日志耗时参数（适配接口响应时间）
const getAllCostTimeReg = /cost[:：]\s*(\d+(\.\d+)?ms)/gi;

避坑细则：状态码通过单词边界\b限制，避免匹配长数字中的三位数字；日志时间严格匹配标准格式，杜绝乱码数字干扰；接口路径精准匹配/api前缀，适配后端通用接口规范。

6.5 富文本/HTML解析提取（爬虫内容提纯）

场景说明：爬虫抓取网页富文本后，提纯有效内容、剔除标签、提取专属内容，实现非结构化网页结构化

// 6.5.1 剔除所有HTML标签，提取纯文本内容
const getHtmlPureTextReg = /<[^>]+>/g;
// 使用：htmlStr.replace(getHtmlPureTextReg, '')

// 6.5.2 批量提取HTML标签内文本（分组精准捕获）
const getTagTextReg = /<([a-zA-Z0-9]+)[^>]*>([\s\S]*?)<\/\1>/gs;

// 6.5.3 提取HTML所有a标签链接+文本
const getAHrefReg = /<a\s+href=["'](https?:\/\/[^"']+)["'][^>]*>([\s\S]*?)<\/a>/gs;

// 6.5.4 提取HTML所有img标签图片地址
const getImgSrcReg = /<img[^>]*src=["']([^"']+)["'][^>]*>/gi;

// 6.5.5 剔除网页空白行、多余换行、空格
const clearHtmlBlankReg = /\n\s*\n/g;

避坑细则：HTML解析必须开启s跨行匹配、g全局匹配；优先正则粗提纯，复杂嵌套结构需配合DOM解析器；非贪婪匹配杜绝跨标签内容错乱。

6.6 自定义规则精准提取（断言高阶用法）

场景说明：精准提取「指定前缀、指定后缀」中间内容，不消耗前后标识文本，适配自定义格式文本解析

// 6.6.1 提取【前缀、后缀】中间所有内容（通用模板）
// 示例：提取 价格：123元 中的123
const getMiddleContentReg = /(?<=价格：).*?(?=元)/s;

// 6.6.2 提取JSON片段指定字段值（简易报文提取）
// 适配简单JSON字符串，复杂JSON优先用JSON.parse
const getJsonFieldReg = /"字段名"\s*:\s*"([^"]*)"/g;

// 6.6.3 提取括号内所有内容（小括号专属）
const getBracketContentReg = /\((.*?)\)/g;

// 6.6.4 提取中文冒号后内容（适配中文配置文本）
const getCnColonContentReg = /([\u4e00-\u9fa5]+)：(.*)/g;

避坑细则：前后零宽断言不消耗字符，实现精准无残留提取；必须开启非贪婪匹配，避免超长内容吞噬；复杂结构化数据禁止强行用正则，优先专用解析器。

6.7 批量提取通用工具方法（工程封装）

场景说明：封装通用提取工具，统一返回格式化结果，适配批量循环提取、批量数据清洗场景

/**
 * 通用批量提取方法
 * @param {string} text - 原始文本
 * @param {RegExp} reg - 提取正则
 * @returns {Array} 去重、去空的提取结果
 */
function batchExtract(text, reg) {
  if (!text || !reg) return [];
  // 批量匹配、去空、去重、格式化
  return [...new Set(text.match(reg) || [])].filter(item => item.trim());
}

// 实战调用示例
const text = "测试手机号13800000000、13900000000，邮箱test@qq.com";
const phoneList = batchExtract(text, getAllPhoneReg);
const emailList = batchExtract(text, getAllEmailReg);
console.log(phoneList, emailList);

6.8 批量提取工程落地规范

1. 全局匹配必带g修饰符：批量提取场景必须开启全局模式，否则仅匹配第一条数据；跨行文本搭配s修饰符。

2. 结果必须去重去空：原始文本易存在重复、空字符、空格数据，批量提取后必须二次格式化清洗。

3. 简单文本用正则、复杂结构用解析器：单层线性文本优先正则高效提取，嵌套HTML、JSON、XML禁止强行正则解析。

4. 精准场景用断言：需要定位前后边界、不破坏原文本的场景，优先使用零宽断言实现精准提取。

5. 批量数据规避回溯：超长日志、海量文本提取，禁止嵌套多重贪婪量词，防止灾难性回溯卡顿。

7. 文本清洗与格式化（数据治理刚需｜全场景生产完整版｜脏数据统一规整方案）

本板块聚焦后端数据治理、日志规整、用户输入清洗、爬虫数据提纯、批量文本标准化核心刚需场景，解决开发中空白杂乱、隐形字符、乱码冗余、全半角错乱、大小写不统一、换行格式混乱等高频脏数据问题。所有正则模板均为生产落地优化版，区分「基础清洗」「深度提纯」「格式标准化」三大层级，配套完整调用示例与避坑细则，适配批量数据清洗、入库预处理、内容风控前置、日志格式化全流程场景。

7.1 空白字符全套清洗（解决空格/换行/制表冗余）

业务场景：用户输入表单、粘贴文本、爬虫内容、系统日志，批量清除多余空格、空行、制表符、首尾空白，统一文本排版格式，是所有文本处理的前置基础操作。

// 7.1.1 清除所有空白字符（彻底无空格，适用于编码、编号、手机号纯文本清洗）
const clearAllSpaceReg = /\s+/g;

// 7.1.2 清除首尾空白、换行、制表（保留文本内部正常空格，前端展示首选）
const trimSpaceReg = /^\s+|\s+$/g;

// 7.1.3 压缩连续空白为单个空格（规整段落文本、文案内容）
const compressSpaceReg = /\s+/g;

// 7.1.4 清除所有空行、多余换行（日志、文档、批量文本排版）
const clearEmptyLineReg = /\n\s*\n/g;

// 7.1.5 清除制表符+全角空格（解决中英文排版错乱）
const clearTabFullSpaceReg = /[\t　]/g;

落地使用示例

// 段落文本规整：首尾去空+压缩连续空白
function formatParagraphText(text) {
  return text.replace(trimSpaceReg, '').replace(compressSpaceReg, ' ');
}

// 纯标识清洗：彻底清除所有空白
function formatPureCodeText(text) {
  return text.replace(clearAllSpaceReg, '');
}

避坑要点：普通文案禁止直接清除全部空格，会导致文字粘连；编码、手机号、资质编号等纯标识类文本，建议彻底清空所有空白，统一入库格式。

7.2 隐形零宽字符深度清除（解决莫名匹配失效、乱码空白）

业务场景 ：用户粘贴文本、复制网页内容、第三方接口返回数据，极易携带零宽空格、零宽连接符、隐形占位字符，肉眼不可见但会导致正则匹配失效、数据比对失败、入库异常，是线上隐性BUG高频诱因。

// 清除所有主流零宽隐形字符（生产必备、全局兜底）
const clearZeroWidthReg = /[\u200b\u200c\u200d\u200e\u200f\u2028\u2029]/gu;

字符说明：覆盖零宽空格、零宽非连接符、零宽连接符、左右占位符、换行分段隐形字符，全网99%隐形脏字符可一次性清除。

工程规范 ：所有外部传入文本（用户输入、接口返回、爬虫数据），必须优先执行零宽字符清洗，再进行后续校验与入库。

7.3 Emoji表情批量清除（合规文本提纯）

业务场景：后台资质文本、公告文案、企业信息、台账数据、表单备注，过滤非法表情符号，规避特殊字符入库报错、展示错乱、数据统计异常问题。

// 完整版Emoji全覆盖清除（包含普通表情、旗帜、符号表情、小众特殊表情）
const clearEmojiReg = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\u2600-\u27ff]|[\u2B50-\u2B55]|[\u3030-\u303d]/gu;

拓展适配 ：如需保留部分合规表情，可精简正则范围；政务、企业、金融类系统默认全量拦截所有Emoji。

7.4 全半角字符统一转换（解决格式错乱核心方案）

业务场景：用户随意输入导致数字、字母、标点全半角混杂，造成格式校验失败、数据去重失效、匹配不一致，是表单校验、数据治理高频问题，统一转换为半角字符适配系统标准格式。

/**
 * 全角转半角（生产通用方法）
 * 统一数字、字母、标点为标准半角格式
 */
function fullToHalfWidth(text) {
  return text.replace(/[\uff00-\uffef]/gu, char => {
    return String.fromCharCode(char.charCodeAt(0) - 65248);
  });
}

// 半角转全角（适配前台展示、文案排版场景）
function halfToFullWidth(text) {
  return text.replace(/[\u0020-\u007e]/g, char => {
    return String.fromCharCode(char.charCodeAt(0) + 65248);
  });
}

工程落地规则 ：所有入库数据统一全角转半角，前台展示可按需转全角美化排版，杜绝全半角混杂导致的数据异常。

7.5 特殊符号精准过滤（分层清洗｜保留有效内容）

区分「宽松版」「严格版」「企业资质专用版」三套规则，适配不同业务场景，避免过度清洗丢失有效内容、或清洗不彻底残留脏字符。

// 7.5.1 宽松版：保留中英文、数字、常用中文标点（文案、备注通用）
const clearSpecialLooseReg = /[^\u4e00-\u9fa5a-zA-Z0-9\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b\s]/gu;

// 7.5.2 严格版：仅保留中英文、数字（编码、账号、标识类文本）
const clearSpecialStrictReg = /[^\u4e00-\u9fa5a-zA-Z0-9]/gu;

// 7.5.3 企业资质专用版：保留数字、大写字母、连接符（适配信用代码、证照编号）
const clearQualificationSpecialReg = /[^A-Z0-9-]/gu;

场景适配规范：文案内容用宽松版、唯一标识用严格版、企业资质用专属定制版，杜绝一刀切清洗。

7.6 大小写统一格式化（编码/账号/标识标准化）

业务场景：统一社会信用代码、域名、邮箱、账号、编码等大小写不敏感文本，统一格式规避匹配失效、数据重复问题。

// 正则辅助统一大小写，搭配字符串方法使用
// 全部转大写（资质、编码、域名首选）
function formatUpperText(text) {
  return text.replace(clearZeroWidthReg, '').trim().toUpperCase();
}

// 全部转小写（邮箱、链接、账号首选）
function formatLowerText(text) {
  return text.replace(clearZeroWidthReg, '').trim().toLowerCase();
}

7.7 换行与段落规整（文档/文案/报表格式化）

业务场景：批量规整不规则换行、错乱段落，统一文档排版格式，适配报表导出、后台文案展示、富文本格式化。

// 多换行统一转为单换行（段落规整）
const uniformLineReg = /\n+/g;

// 清除段落首尾多余换行，保留正常段落分隔
const formatParagraphLineReg = /^\n+|\n+$/g;

7.8 脏数据综合清洗工具类（生产封装｜一键格式化）

整合所有高频清洗规则，封装通用一键清洗方法，适配90%以上文本规整、入库预处理场景，可直接全局复用。

/**
 * 通用文本入库前置清洗工具
 * @param {string} text 原始文本
 * @returns {string} 标准化干净文本
 */
function cleanDbText(text) {
  if (!text) return '';
  return text
    // 1. 清除零宽隐形字符
    .replace(clearZeroWidthReg, '')
    // 2. 清除Emoji表情
    .replace(clearEmojiReg, '')
    // 3. 全角转半角统一格式
    .replace(/[\uff00-\uffef]/gu, c => String.fromCharCode(c.charCodeAt(0)-65248))
    // 4. 压缩连续空白
    .replace(compressSpaceReg, ' ')
    // 5. 去除首尾空白
    .replace(trimSpaceReg, '');
}

7.9 文本清洗生产级强制规范

1. 前置清洗原则：所有外部输入、接口返回、爬虫、粘贴文本，必须先清洗再校验、先规整再入库，杜绝脏数据进入业务流程；

2. 分层清洗策略：展示类文本宽松清洗保留排版，入库类文本严格标准化、彻底去除冗余字符；

3. 隐形字符必清：零宽字符、特殊隐形占位符为清洗必选项，是解决莫名匹配BUG的核心；

4. 格式统一优先：全半角、大小写、换行格式必须统一，避免格式差异导致的数据不一致问题；

5. 禁止过度清洗：文案、备注类文本保留合法标点与空格，仅过滤非法脏字符，不破坏原有内容结构。

8. 数据脱敏模板（前台展示隐私保护｜全场景生产完整版｜兼容多长度+防绕过+工具封装）

本板块覆盖项目开发所有隐私数据脱敏场景 ，包含个人隐私、账号信息、设备信息、地址信息、企业隐私等全品类脱敏规则，所有模板均经过生产优化，具备严格首尾校验、适配多长度、空值容错、防脱敏绕过、统一展示格式特性，区分「简单正则脱敏」和「生产级工具方法」，适配前端页面展示、后端接口返回脱敏、日志隐私屏蔽、数据导出脱敏全场景。

通用脱敏规范（全局统一）：保留首尾有效信息、中间星号遮挡、星号数量统一规整、不破坏数据格式结构、兼容各类合法输入长度。

8.1 中国大陆手机号脱敏（通用标准｜11位）

业务规则：保留前3位运营商号段、后4位尾号，中间4位遮挡，适配所有前台展示、用户中心、订单列表场景，严格匹配11位手机号，杜绝短号、长号畸形数据脱敏错乱。

// 手机号脱敏正则（生产标准）
const phoneHideReg = /^(\d{3})\d{4}(\d{4})$/;

// 脱敏工具方法（容错处理）
function hidePhone(phone) {
  if (!phone || phone.length !== 11) return phone;
  return phone.replace(phoneHideReg, '$1****$2');
}
// 示例：13800000000 → 138****0000

8.2 身份证号脱敏（18位/15位兼容｜金融级隐私）

业务规则：兼容老式15位身份证、新式18位身份证，保留前6位地址码、后4位顺序码，中间生日信息完整遮挡，杜绝出生日期、籍贯隐私泄露，适配实名信息展示、资质备案展示场景。

// 身份证脱敏正则（兼容15/18位）
const idCardHideReg18 = /^(\d{6})\d{8}(\d{4})$/;
const idCardHideReg15 = /^(\d{6})\d{5}(\d{4})$/;

// 身份证脱敏通用方法
function hideIdCard(idCard) {
  if (!idCard) return idCard;
  let res = idCard;
  if (idCard.length === 18) {
    res = idCard.replace(idCardHideReg18, '$1********$2');
  } else if (idCard.length === 15) {
    res = idCard.replace(idCardHideReg15, '$1*****$2');
  }
  return res;
}
// 示例：110101200001011234 → 110101********1234

8.3 邮箱脱敏（通用全品类｜个人/企业邮箱适配）

业务规则：用户名保留前3位，剩余用户名遮挡，完整保留域名，兼顾隐私性与账号辨识度，适配登录账号展示、绑定邮箱展示、企业邮箱脱敏场景。

// 邮箱脱敏正则
const emailHideReg = /^(\w{3})\w+(@[\w-]+(\.[\w-]+){1,2})$/;

// 邮箱脱敏工具方法
function hideEmail(email) {
  if (!email || !email.includes('@')) return email;
  return email.replace(emailHideReg, '$1***$2');
}
// 示例：test123@qq.com → tes***@qq.com

8.4 中文姓名脱敏（单字/双字/多字全覆盖）

业务规则：适配所有中文姓名场景，单字姓名完整展示、双字姓名首字保留末尾遮挡、多字姓名首尾保留中间遮挡，符合国内隐私展示规范。

// 姓名脱敏通用方法（适配所有中文名）
function hideName(name) {
  if (!name || !name.length) return name;
  // 单字姓名直接返回
  if (name.length === 1) return name;
  // 双字姓名：首字+星号
  if (name.length === 2) return name.slice(0, 1) + '*';
  // 多字姓名：首字+中间星号+尾字
  return name.slice(0, 1) + '*'.repeat(name.length - 2) + name.slice(-1);
}
// 示例：张三 → 张*、张三丰 → 张*丰、欧阳娜娜 → 欧阳**娜

8.5 银行卡号脱敏（银联标准｜16/19位兼容）

业务规则：适配16位储蓄卡、19位借记卡，保留前6位卡组织标识、后4位尾号，中间完整遮挡，金融级隐私保护，适配支付页面、账单、银行卡绑定展示场景。

// 银行卡脱敏正则
const bankCardHideReg = /^(\d{6})\d+(\d{4})$/;

// 银行卡脱敏工具方法
function hideBankCard(card) {
  if (!card || card.length < 10) return card;
  return card.replace(bankCardHideReg, '$1**********$2');
}
// 示例：6222021234567890123 → 622202**********123

8.6 座机号码脱敏（固定电话｜区号+号码适配）

业务规则：保留区号、遮挡座机号码主体，适配企业座机、家庭电话展示脱敏。

// 座机脱敏正则（适配010-12345678、02112345678格式）
const telHideReg = /^(\d{3,4}-?)\d{4,8}$/;

function hideTel(tel) {
  if (!tel) return tel;
  return tel.replace(telHideReg, '$1****');
}
// 示例：010-12345678 → 010-****

8.7 微信号脱敏（官方规范｜5-20位）

业务规则：保留前2位、后2位，中间遮挡，适配用户社交账号隐私展示，避免微信号完整泄露。

// 微信号脱敏正则
const wechatHideReg = /^([a-zA-Z0-9_-]{2}).+([a-zA-Z0-9_-]{2})$/;

function hideWechat(wechat) {
  if (!wechat || wechat.length <= 4) return wechat;
  return wechat.replace(wechatHideReg, '$1***$2');
}
// 示例：wechat123 → we***23

8.8 QQ号脱敏（5-13位）

业务规则：保留前2位、后2位，中间遮挡，适配社交账号、绑定QQ展示脱敏。

// QQ号脱敏正则
const qqHideReg = /^(\d{2})\d+(\d{2})$/;

function hideQQ(qq) {
  if (!qq || qq.length <= 4) return qq;
  return qq.replace(qqHideReg, '$1****$2');
}
// 示例：12345678 → 12****78

8.9 IP地址脱敏（内网/公网｜运维隐私）

业务规则：保留前两段网段，遮挡后两段，避免服务器、设备IP地址泄露，适配日志展示、设备列表、运维后台脱敏。

// IP地址脱敏正则
const ipHideReg = /^(\d{1,3}\.\d{1,3})\.\d{1,3}\.\d{1,3}$/;

function hideIp(ip) {
  if (!ip) return ip;
  return ip.replace(ipHideReg, '$1.*.*');
}
// 示例：192.168.1.100 → 192.168.*.*

8.10 地址脱敏（省市区保留｜详细地址遮挡）

业务规则：保留省市区公开信息，遮挡详细街道、楼栋、门牌号，兼顾地理位置展示与用户隐私。

// 地址脱敏工具方法（通用适配国内地址）
function hideAddress(address) {
  if (!address) return address;
  // 匹配省市区，保留前缀，遮挡后续详细地址
  const reg = /^([\u4e00-\u9fa5]{2,6}[省市区州县]){1,3}/;
  const match = address.match(reg);
  if (!match) return address;
  return match[0] + '****';
}
// 示例：广东省深圳市南山区科技园 → 广东省深圳市****

8.11 统一通用脱敏工具（一键适配多场景）

工程价值：整合高频脱敏场景，统一代码规范，项目全局复用，减少重复代码，兼容空值、短数据、异常数据，杜绝脱敏报错。

// 地址脱敏工具方法（通用适配国内地址） function hideAddress(address) { if (!address) return address; // 匹配省市区，保留前缀，遮挡后续详细地址 const reg = /^([\u4e00-\u9fa5]{2,6}[省市区州县]){1,3}/; const match = address.match(reg); if (!match) return address; return match[0] + '****'; } // 示例：广东省深圳市南山区科技园 → 广东省深圳市****

8.12 脱敏生产级强制规范

1. 严格边界匹配 ：所有脱敏正则必须加首尾^$，防止部分匹配导致脱敏绕过、隐私泄露；

2. 强容错机制：所有脱敏方法必须做空值、长度校验，避免异常数据导致页面JS报错；

3. 展示优先适配：前台展示仅做视觉脱敏，后端入库保留完整原始数据，脱敏仅作用于展示层；

4. 统一星号规范：禁止长短数据星号数量混乱，根据数据长度动态适配遮挡位数，展示美观统一；

5. 日志强制脱敏：所有接口日志、操作日志必须脱敏后打印，禁止原始隐私数据落地；

6. 特殊场景定制：金融、政务等高隐私场景，可进一步加密遮挡，缩减明文展示位数。

9. 内容风控与敏感过滤（生产级完整方案｜精准拦截+防绕过+变形规避+合规脱敏）

本板块聚焦社区评论、用户发帖、留言反馈、动态发布、客服对话 等全场景内容风控核心需求，解决原生敏感词过滤漏拦截、变形绕过、误杀过高、无法替换脱敏、特殊字符干扰等线上高频问题。覆盖普通敏感词、变形敏感词、穿插符号规避、形近字替换、空格拆分绕过等所有黑产规避手段，提供分层过滤规则、完整工具方法、风控落地规范，适配中小型项目轻量化风控、大型平台基础内容筛查，可直接投产使用。

9.1 核心风控痛点（线上高频绕过场景）

原生简单敏感词匹配仅能拦截纯文本关键词，无法抵御黑产常规规避手段，也是90%平台内容风控失效的根源：

• 符号穿插绕过：敏感词中间插入空格、标点、特殊符号，如「测#试@敏$感词」

• 拆分换行绕过：敏感词拆分多行、换行分隔，规避连续匹配

• 形近字替换绕过：利用形近汉字、异体字替换，如「敏感祠」替代「敏感词」

• 大小写/全半角绕过：混杂全半角字符、大小写字母规避拦截

• 冗余字符干扰：前后拼接无效字符、Emoji、隐形零宽字符干扰匹配

• 动态词库适配难：后台自定义敏感词库无法静态写死正则，动态拼接易报错、存在注入风险

9.2 基础动态敏感词过滤（防注入｜通用兜底版）

适配后台配置敏感词库、动态新增删除关键词场景，内置正则特殊字符转义，彻底杜绝正则注入漏洞，支持批量匹配、全局替换拦截，是所有内容平台基础风控必备能力。

// 正则特殊字符转义（核心：防止敏感词注入、语法报错）
function escapeRegExp(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

/**
 * 基础敏感词过滤方法
 * @param {string} content - 原始用户内容
 * @param {Array} wordList - 后台配置的敏感词数组
 * @param {string} replaceChar - 替换掩码，默认*
 * @returns {string} 脱敏后内容
 */
function filterSensitiveWord(content, wordList, replaceChar = '*') {
  if (!content || !Array.isArray(wordList) || wordList.length === 0) {
    return content;
  }
  // 批量转义敏感词，拼接正则规则
  const escapeWords = wordList.map(escapeRegExp);
  const sensitiveReg = new RegExp(escapeWords.join('|'), 'gu');
  // 匹配到的敏感词统一掩码替换
  return content.replace(sensitiveReg, match => replaceChar.repeat(match.length));
}

// 实战示例
const userContent = "这是一条敏感测试内容";
const sensitiveWords = ["敏感", "违规内容", "广告"];
const safeContent = filterSensitiveWord(userContent, sensitiveWords);
console.log(safeContent); // 这是一条**测试内容

9.3 进阶防绕过敏感词过滤（拦截符号穿插/空格拆分｜生产增强版）

解决黑产最常用的「符号穿插、空格拆分、标点隔断」绕过方式，先清洗干扰字符，再精准匹配敏感词，兼顾拦截准确率与低误杀率，适配公开社区、评论区等高风控场景。

/**
 * 增强型防绕过敏感词过滤
 * 拦截：空格/标点/特殊符号穿插、换行拆分、隐形字符干扰
 */
function enhanceFilterSensitive(content, wordList, replaceChar = '*') {
  if (!content || !wordList.length) return content;

  // 1. 前置清洗：清除所有干扰字符（空格、换行、标点、零宽字符）
  let cleanContent = content
    .replace(/[\u200b\u200c\u200d\u200e\u200f]/gu, '') // 清除零宽隐形字符
    .replace(/[\s\p{P}\p{S}]/gu, ''); // 清除空白、标点、特殊符号

  // 2. 转义敏感词并构建正则
  const escapeWords = wordList.map(escapeRegExp);
  const sensitiveReg = new RegExp(escapeWords.join('|'), 'gu');

  // 3. 精准替换敏感词
  return cleanContent.replace(sensitiveReg, match => replaceChar.repeat(match.length));
}

适配说明：该方案可拦截「敏#感词」「敏 感 词」「敏！感！词」等绝大多数穿插绕过场景，是中小型平台性价比最高的风控方案。

9.4 形近字/异体字敏感拦截（高阶风控｜防变种绕过）

针对高阶规避手段：形近汉字、异体字、错别字替换绕过，建立形近字映射库，批量还原变种字符后再做敏感词匹配，彻底杜绝变种敏感词漏拦。

// 核心形近字映射表（可根据业务拓展）
const similarCharMap = {
  '感': ['敢', '幹', '感'],
  '敏': ['敏', '皿', '旻'],
  '违': ['违', '围', '维'],
  '规': ['规', '归', '圭'],
  '色': ['色', '瑟', '铯']
};

/**
 * 形近字统一还原方法
 * 将变种形近字统一替换为标准字，再进行敏感词匹配
 */
function restoreSimilarChar(content) {
  let result = content;
  // 遍历映射表，批量还原形近字
  for (const [standard, similarList] of Object.entries(similarCharMap)) {
    const reg = new RegExp(similarList.map(escapeRegExp).join('|'), 'gu');
    result = result.replace(reg, standard);
  }
  return result;
}

// 组合高阶风控过滤
function highLevelSensitiveFilter(content, wordList) {
  // 步骤1：清洗隐形/干扰字符
  let cleanContent = enhanceFilterSensitive(content, []);
  // 步骤2：还原形近变种字符
  let restoreContent = restoreSimilarChar(cleanContent);
  // 步骤3：精准过滤敏感词
  return filterSensitiveWord(restoreContent, wordList);
}

9.5 空内容/无效内容拦截（基础风控兜底）

拦截纯空格、纯换行、纯标点、零宽隐形字符组成的无效空内容，杜绝空评论、空发帖刷数据、垃圾灌水行为，是内容风控前置基础拦截规则。

// 匹配纯空白、纯符号、纯隐形字符的无效内容
const emptyInvalidReg = /^[\s\p{P}\p{S}\u200b-\u200f]*$/gu;

/**
 * 校验是否为无效空内容
 * @param {string} content - 用户输入内容
 * @returns {boolean} true=无效内容，false=有效内容
 */
function isEmptyInvalidContent(content) {
  return emptyInvalidReg.test(content.trim());
}

9.6 违规内容精准拦截（整句/关键词封禁）

适配广告引流、涉黄、涉诈、违规宣传等固定违规句式拦截，支持模糊匹配关键词组合、精准匹配违规话术，弥补单一关键词拦截精准度不足的问题。

// 高频违规话术组合正则（可按需拓展）
const illegalRegList = [
  // 引流微信/QQ广告
  /(加|私|找|联)[我我们]*(微信|vx|qq|扣扣|联系方式)/gu,
  // 刷单/返利违规
  /(刷单|返利|佣金|兼职赚钱|日入过万)/gu,
  // 低俗涉黄
  /(同城约|私密聊|裸聊|上门服务)/gu
];

/**
 * 批量检测是否包含违规内容
 * @returns {boolean} true=包含违规内容
 */
function checkIllegalContent(content) {
  return illegalRegList.some(reg => reg.test(content));
}

9.7 生产级内容风控完整流程（强制落地规范）

所有用户公开内容发布，必须严格遵循五步风控流程，无例外，兼顾拦截效果与用户体验：

1. 前置无效拦截：优先校验空内容、纯符号无效内容，直接拦截灌水数据；

2. 脏数据清洗：清除零宽字符、多余空格、干扰标点，统一文本格式；

3. 变种字符还原：批量还原形近字、异体字，规避变种绕过；

4. 敏感词脱敏替换：匹配自定义敏感词库，统一掩码替换，不直接拦截仅脱敏；

5. 违规话术拦截：高危违规内容直接拦截发布，返回风控提示。

9.8 工程避坑核心规范（杜绝误杀/漏杀）

• 禁止静态硬编码敏感词：敏感词库必须后台可配置、动态更新，无需改代码重启服务；

• 区分脱敏与拦截场景：普通敏感词做掩码脱敏，高危违规话术直接拦截发布；

• 禁止过度清洗：仅清除干扰规避的特殊字符，保留正常文案标点与排版，降低误杀率；

• 全局开启大小写兼容：所有风控正则携带u、g修饰符，兼容中文、大小写、全半角场景；

• 定期迭代形近字库：根据平台违规数据，持续补充形近字、变种关键词，闭环绕过漏洞；

• 风控分层降级：普通用户宽松脱敏、高危账号严格拦截、新用户加强校验，分层风控平衡体验与安全。

10. 工程开发批量处理模板（IDE/脚本/工程重构｜全场景补全版）

本板块聚焦日常工程开发、代码重构、批量规整、脚本处理、项目瘦身 刚需场景，汇总生产级批量处理正则模板，适配VSCode/WebStorm全局替换、Node/Python脚本批量处理、项目代码规整、无效代码清理、配置格式化等场景，所有模板均带使用示例、适配场景、避坑规范，直接落地提效。

10.1 代码注释批量清理（前端/JS/TS通用）

场景说明：项目重构、代码上线、开源脱敏，批量清除冗余单行、多行注释，保留代码逻辑，精简项目代码体积。

// 10.1.1 清除JS/TS单行注释 //（兼容行尾注释、独占行注释）
const clearLineCommentReg = /\/\/.*$/gm;

// 10.1.2 清除JS/TS多行块注释 /* */（兼容跨行注释、内嵌空格）
const clearBlockCommentReg = /\/\*[\s\S]*?\*\//gs;

// 10.1.3 清除HTML单行注释 <!-- -->
const clearHtmlCommentReg = /<!--[\s\S]*?-->/gs;

// 10.1.4 清除CSS单行/块注释
const clearCssCommentReg = /\/\*[\s\S]*?\*\//gs;

使用规范：优先清理块注释，再清理单行注释；避免误匹配URL、字符串内的//注释符号，复杂文件建议IDE手动复核。

10.2 代码无效内容批量剔除（项目瘦身核心）

场景说明：清理开发遗留的调试代码、打印日志、空行、无效变量，规整工程代码格式。

// 10.2.1 批量清除console调试日志（console.log/info/warn/error）
const clearConsoleReg = /console\.(log|info|warn|error|debug)\(.*\);?/gm;

// 10.2.2 清除debugger断点
const clearDebuggerReg = /debugger;?/gm;

// 10.2.3 清除代码多余空行（合并多行空行为单行）
const clearCodeEmptyLineReg = /\n\s*\n/gm;

// 10.2.4 清除行尾多余空格（代码格式化刚需）
const clearLineEndSpaceReg = /\s+$/gm;

避坑要点：生产环境必须全量清除console，避免日志泄露、性能损耗；保留业务必要的日志打印，勿一刀切清理。

10.3 HTML/前端代码批量规整模板

场景说明：前端页面重构、富文本提纯、模板代码规整，批量处理标签、换行、冗余内容。

// 10.3.1 匹配所有HTML标签（非贪婪跨行，避免跨标签吞噬）
const htmlTagReg = /<.+?>/gs;

// 10.3.2 剔除所有HTML标签，提取纯文本内容
const clearHtmlReg = /<[^>]+>/g;

// 10.3.3 清除HTML多余换行与缩进
const clearHtmlIndentReg = /\n\s+/g;

// 10.3.4 匹配自闭和标签（img/input/link等）
const htmlSelfCloseTagReg = /<([a-zA-Z]+)[^>]*\/>/gs;

落地场景：CMS内容提纯、前端模板精简、爬虫网页数据格式化、静态页面代码瘦身。

10.4 路径与文件名校验/批量处理模板

场景说明：文件上传、路径解析、批量重命名、静态资源匹配，适配工程文件管理场景。

// 10.4.1 匹配合法文件名（剔除特殊非法字符）
const validFileNameReg = /[^\\\/:*?"<>|]/g;

// 10.4.2 提取文件后缀名（精准匹配常见静态资源后缀）
const getFileSuffixReg = /\.([a-zA-Z0-9]+)$/;

// 10.4.3 匹配绝对路径（本地文件路径）
const localAbsolutePathReg = /^([a-zA-Z]:|\/)([^\\\/:*?"<>|\s])+/;

// 10.4.4 批量过滤隐藏文件（匹配.开头文件）
const hiddenFileReg = /^\..+/gm;

10.5 代码变量/接口批量替换模板（重构提效）

场景说明：项目重构、变量统一命名、接口路径改版、常量批量替换，秒级完成全局修改。

// 10.5.1 匹配JS/TS合法变量名
const validVarNameReg = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;

// 10.5.2 批量匹配API接口路径（统一替换接口前缀）
const apiPrefixReg = /\/api\/v1\//g;

// 10.5.3 匹配Vue/React静态资源引入路径
const assetPathReg = /@\/assets\/[\w\/-]+\.\w+/g;

// 10.5.4 匹配注释中的TODO/FIXME标记（批量梳理待办）
const todoMarkReg = /\/\/\s*(TODO|FIXME|BUG):.*/gm;

10.6 配置文件批量解析模板（JSON/XML/YAML简易处理）

场景说明：配置文件批量修改、参数提取、环境配置规整，轻量处理无需专业解析器。

// 10.6.1 提取JSON配置指定字段值（简易配置提取）
const jsonConfigFieldReg = /"config\.([\w]+)":\s*"([^"]*)"/g;

// 10.6.2 匹配YAML键值对配置
const yamlKvReg = /^([\w_-]+):\s*(.*)$/gm;

// 10.6.3 批量匹配注释掉的配置项
const commentConfigReg = /^#\s*.+$/gm;

10.7 脚本日志批量处理模板（运维/CI/CD适配）

场景说明：打包日志、部署日志、脚本执行日志批量清洗、提取有效信息。

// 10.7.1 清除日志多余空格与换行
const cleanLogSpaceReg = /\s+/g;

// 10.7.2 提取日志报错堆栈信息
const logErrorStackReg = /(Error|Exception):[\s\S]*?(?=\n\n|$)/g;

// 10.7.3 匹配打包成功/失败状态码
const buildStatusReg = /(success|fail|error):\s*(\d+)/gi;

10.8 工程批量处理强制规范

1. IDE优先批量操作：简单替换、清理场景优先使用IDE全局正则替换，无需编写脚本；

2. 批量操作先备份：代码清理、全局替换前必须提交代码备份，防止不可逆误删；

3. 区分静态/动态规则：固定清理规则用字面量正则，动态配置替换用缓存构造函数正则；

4. 禁止过度清理：业务注释、核心说明注释按需保留，仅清理调试冗余内容；

5. 批量脚本加容错：脚本批量处理时，增加空值、异常判断，避免批量处理中断报错。

十一、正则性能与避坑指南

1. 性能陷阱：回溯灾难（工程最高危性能BUG｜底层原理+高危案例+线上故障+根治方案）

回溯灾难（又称灾难性回溯）是NFA正则引擎独有致命性能问题 ，也是线上接口超时、CPU 100%、服务卡死、页面阻塞的核心隐性诱因。区别于普通语法报错，该问题本地测试正常、仅线上超长文本触发、偶现卡死难以复现，90%的正则性能故障均源于此。

1.1 核心底层原理

NFA正则引擎默认采用「贪婪匹配+回溯重试」机制：当多层量词嵌套、多分支叠加匹配不满足规则的超长文本时，引擎不会直接匹配失败，而是逐层回溯、释放已匹配字符，穷尽所有匹配组合后，才会返回失败结果。

正常正则匹配时间复杂度为 O(n) （线性扫描），触发灾难性回溯后复杂度会飙升至 O(2ⁿ)（指数级爆炸），文本长度每增加1位，匹配运算量翻倍，超长文本直接引发线程阻塞、服务卡死。

1.2 三大核心触发条件（同时满足必卡死）

• 条件1：多层贪婪量词嵌套 ：+、*、{n,} 等无限量词叠加嵌套，存在多重匹配重试空间；

• 条件2：匹配文本不满足规则：目标文本为非法文本、超长无效文本，无法完整匹配正则规则；

• 条件3：文本长度过长：文本字数超千级、万级，回溯重试次数指数级暴涨。

1.3 全网高频高危正则案例（生产绝对禁用）

以下写法为工程高危黑名单，本地测试无异常，线上超长文本必触发卡死：

• 多层贪婪嵌套（顶级高危） ：(.+)+、(\d*)*、(\w+)*，重复量词嵌套无边界限制；

• 无边界或逻辑叠加 ：(a|aa|aaa)+，多长度分支叠加无限量词，回溯分支爆炸；

• 模糊匹配无边界约束 ：[\s\S]+.* 双重模糊匹配，无首尾长度限制，超长文本无限回溯；

• 分组内无限量词叠加 ：(\d+\s*)*，内层量词匹配+外层循环匹配，重试次数指数增长。

1.4 真实线上故障场景

故障场景1：日志解析卡死

后端使用 (.+)+error 匹配超长错误日志，正常短日志可正常匹配，遇到数万行无error的冗余日志时，触发灾难性回溯，CPU瞬间拉满，日志解析服务阻塞超时。

故障场景2：前端页面卡死

前端表单使用复杂嵌套正则校验用户粘贴的超长文本，正常输入无问题，用户粘贴数万字无效文本时，正则阻塞JS主线程，页面白屏、交互卡死。

故障场景3：数据清洗接口超时

批量清洗脏数据时，使用无边界嵌套正则，遇到格式错乱的超长脏数据，回溯次数爆炸，导致接口响应超时、批量任务失败。

1.5 回溯灾难精准检测方法

• 代码静态检测：校验正则是否存在「无限量词嵌套、无边界模糊匹配、多长度分支叠加」；

• 压力测试检测：使用10000字+无效超长文本测试正则，正常正则毫秒级返回，高危正则会明显卡顿、超时；

• 线上日志监控：监控接口CPU耗时、线程阻塞时长，突发高耗时且无报错，大概率为回溯灾难导致。

1.6 生产级根治优化方案（必落地）

1. 强制限定匹配长度（最有效方案） 固定所有无限量词的最大匹配区间，将+、* 替换为 {1,200} 有限量词，从根源杜绝指数级回溯。 示例：高危 (.+)+ → 优化为 (.{1,200})+，限制单段匹配最大长度，锁定运算上限。

2. 贪婪统一改为非贪婪匹配 所有批量匹配、跨行匹配场景，量词后强制加 ? 开启非贪婪模式，匹配成功后立即终止，不做多余回溯重试。 示例：.+ → .+?、\s*+ →\s*?

3. 精简嵌套层级，杜绝多重叠加 禁止两层及以上无限量词嵌套，拆分复杂正则逻辑，将多重嵌套规则拆解为多个简单正则分步匹配，降低回溯复杂度。

4. 前置严格边界规则，快速失败 正则开头强制添加 ^ 起始边界、前置高概率失败规则，让无效文本快速匹配失败，无需全量扫描回溯。

5. 超长文本前置截断处理 所有文本处理场景，先截断超长文本（默认保留前2000字符），再执行正则匹配，规避海量文本回溯风险。

6. 复杂场景放弃正则，改用代码逻辑 超长文本、复杂嵌套匹配场景，放弃堆砌复杂正则，改用JS/Python循环遍历、分段解析，彻底规避引擎回溯机制。

1.7 工程强制避坑规范

• 绝对禁止：生产环境使用无边界嵌套量词、无限叠加或逻辑分支；

• 绝对禁止：超长文本直接全量正则匹配，必须先截断、后匹配；

• 强制规范：所有批量处理、日志解析正则，必须配置最大匹配长度限制；

• 强制规范：复杂正则必须做超长文本压力测试，通过后方可上线；

• 迭代规范：线上所有偶现卡顿、超时问题，优先排查正则回溯灾难风险。

2. 常见易错点（全网超全汇总｜新手+工程高频坑｜错误案例+正确写法）

本节汇总95%以上正则开发报错、匹配错乱、线上BUG的核心易错点，覆盖语法误区、匹配逻辑、修饰符坑、转义坑、引擎特性、跨场景适配问题，每个坑点附带错误案例、正解与落地规范，彻底规避日常开发隐患。

2.1 基础语法与匹配逻辑易错点

易错点1：. 元字符默认不匹配换行符

错误认知：. 匹配所有字符

问题场景：多行文本、跨行内容匹配直接失效

正解：默认仅匹配单行可见字符，需开启 s 修饰符 才可匹配 \n\r 换行符；多行跨行匹配必须加 s。

示例：单行 .+ 正常，多行文本需写 .+?/s

易错点2：^$ 首尾边界修饰符混淆单行/多行模式

错误认知：默认全局匹配每行首尾

问题场景：多行文本校验时，中间行非法内容被放行

正解：默认模式下 ^$ 仅匹配整个字符串首尾 ；开启 m 多行修饰符 后，才会匹配每一行的首尾。 表单全量校验必须默认带 ^$，行内匹配才开启 m 修饰符。

易错点3：量词仅作用于紧邻前一个最小单元（最高频语法错误）

错误写法：ab+ 期望匹配重复 ab

问题：仅重复末尾 b，匹配结果：ab、abb、abbb

正解：多字符重复必须括号分组锁定作用域 ，正确写法：(ab)+

易错点4：或逻辑 | 优先级最低，未分组导致规则跑偏

错误写法：jpg|png|gif$

问题：仅 gif 校验结尾，jpg、png 任意位置均可匹配，造成脏数据误判

正解：所有或逻辑分支统一括号包裹：(jpg|png|gif)$

易错点5：默认贪婪匹配导致跨内容吞噬

错误场景：匹配多个标签、多段内容时，一次性吞完所有文本

错误写法：<.+> 匹配 HTML 标签

问题：长文本直接跨标签贪婪匹配，匹配结果错乱

正解：批量分段匹配必须开启非贪婪模式 ，写法：<.+?>

2.2 字符集与转义体系易错点（90%语法报错根源）

易错点6：混淆字符集内外转义规则

错误认知：\[\] 内外特殊符号都需要转义

问题：字符集内多余转义导致规则失效、语法报错

正解： 1. 字符集外：. * + ? ( ) \ / 全部需要转义；

2. 字符集内：上述符号自动降级为普通字符，无需转义；

3. 字符集内仅4个字符必须转义/规避：\ ] - ^。

易错点7：动态正则二次转义遗漏（构造函数专属坑）

错误写法：new RegExp('\d')

问题：字符串单层 \ 被提前解析消耗，正则规则失效

正解：构造函数正则所有元字符必须双层转义 ，正确写法：new RegExp('\\d')

易错点8：误将全角数字/字母纳入 \d \w 匹配范围

错误认知：\d 匹配所有数字（含全角）、\w 匹配中文

问题：全角数字、中文无法匹配，表单校验漏判/误判

正解：\d 仅匹配半角 0-9，\w 仅匹配字母、数字、下划线，中文属于 \W 范畴。

2.3 中文与Unicode匹配易错点

易错点9：中文匹配未加 u 修饰符导致匹配失效

错误场景：使用 [\u4e00-\u9fa5] 匹配中文，部分环境匹配失败

问题：未开启Unicode模式，多字节字符解析异常

正解：所有中文、Unicode字符匹配，必须携带 u 修饰符 ，如 /[\u4e00-\u9fa5]/gu

易错点10：中文标点、全角符号匹配遗漏

错误认知：匹配中文即包含所有中文相关符号

问题：中文句号、逗号、顿号属于独立Unicode区间，常规中文正则无法匹配

正解：文案清洗需单独纳入中文标点区间，不可仅依赖汉字区间。

2.4 修饰符与API调用易错点（隐性BUG高发）

易错点11：g全局模式下test/match存在lastIndex偏移

问题现象：同一个正则多次校验，结果时而正确、时而错误，无规律错乱

底层原因：全局匹配模式会记录 lastIndex 指针，下次匹配从指针位置开始，而非从头匹配

正解： 1. 单次校验禁止加 g 修饰符； 2. 复用全局正则时，手动重置 reg.lastIndex = 0。

易错点12：混淆 m 多行、s 单行修饰符功能

误区：m 修饰符可以匹配换行字符

正解： 1. s：让 . 匹配换行，控制字符匹配范围；

2. m：让 ^$ 匹配行首尾，控制边界匹配范围； 二者功能完全独立，不可混用替代。

易错点13：忽略 i 忽略大小写修饰符的全局影响

问题：开启 i 修饰符后，大小写全部兼容，导致敏感词、编码校验误判

正解：大小写敏感场景（密码、编码、密钥校验）禁止开启 i 修饰符。

2.5 分组、捕获与反向引用易错点

易错点14：滥用捕获分组导致性能冗余

问题：无提取需求时全部用 () 捕获分组，产生多余内存开销

正解：仅需要提取数据时用捕获分组，纯规则限定使用非捕获分组 (?:)，减少内存占用、提升匹配性能。

易错点15：反向引用序号错乱、引用不存在分组

错误场景：分组增减后，未同步修改 \1 \2 反向引用序号，导致匹配失效

正解：反向引用序号按捕获分组出现顺序排序，非捕获分组不占用序号，复杂正则优先使用命名分组规避错乱。

易错点16：零宽断言消耗字符误区

错误认知：前后断言会占用匹配文本、删除多余内容

问题：脱敏、提取场景误删有效内容

正解：零宽断言(?=) (?!) (?<=) (?<!) 仅做位置判断，不消耗任何字符，仅用于精准定位。

2.6 工程落地与业务适配易错点

易错点17：脱敏正则未加首尾边界，导致绕过漏洞

错误写法：手机号脱敏 \d{4}

问题：文本中任意位置4位数字都会被脱敏，且可绕过完整手机号校验

正解：所有格式校验、脱敏正则必须强制加 ^$ 首尾锁定全局格式。

易错点18：超长文本直接正则匹配，触发灾难性回溯

问题：万级字符文本使用无边界嵌套正则，导致CPU卡死、页面阻塞

正解：超长文本先截断、再匹配，禁止 (.+)+ 等高危嵌套写法，强制限定匹配长度。

易错点19：用正则解析嵌套结构化数据

误区：正则可解析嵌套HTML、JSON、XML

问题：层级嵌套导致贪婪吞噬、匹配错乱、漏匹配

正解：结构化嵌套数据一律使用专业解析器，禁止正则硬解。

易错点20：动态正则未做特殊字符转义，引发正则注入

问题：直接拼接用户输入、前端传参、后台配置内容，被恶意注入元字符篡改规则

正解：所有动态拼接正则，必须先执行特殊字符转义，杜绝注入风险。

易错点21：空白字符清洗一刀切

误区：所有场景直接清除全部空格

问题：文案、备注文本粘连，破坏原有排版

正解：标识类文本（手机号、编码）清全部空格，文案文本仅压缩连续空白、保留单个分隔空格。

易错点22：忽略零宽隐形字符导致莫名匹配失效

问题：肉眼无可见字符，正则始终匹配失败，无法定位问题

正解：所有外部传入文本，优先清洗零宽空格、隐形占位符，再执行校验匹配。

3. 生产级全维度优化方案（完整落地版｜性能+语法+安全+内存+容错）

结合前文灾难性回溯、高频易错点、引擎底层特性，整理工程可直接落地的全维度正则优化方案，覆盖性能提速、语法严谨、内存优化、安全防坑、容错兼容、跨语言适配，所有规则均适配线上生产环境，彻底解决正则卡顿、匹配错乱、隐性BUG、安全漏洞等问题。

3.1 性能核心优化（根治回溯卡顿｜线上最优解）

核心目标：杜绝指数级回溯、减少无效扫描、锁定运算上限，将正则匹配复杂度稳定控制在 O(n) 线性级别。

1.强制限定匹配长度，杜绝无边界量词

所有无限量词 +、*、{n,} 必须配置最大匹配上限，禁止无限制匹配，从根源杜绝灾难性回溯。 ❌ 高危写法：.+、\w*、\d{10,}

✅ 优化写法：根据业务场景限定区间，如账号校验 \w{2,20}、文本截取 .{1,500}

2.统一非贪婪匹配，减少回溯重试

所有跨行匹配、多段内容截取、多标签匹配场景，量词后强制加 ? 开启非贪婪模式，匹配成功立即终止，不做多余回溯。

✅ 标准规范：.+?、\s*?、\w+?，仅固定长度精准校验场景保留贪婪模式

3.前置边界与强校验规则，实现快速失败

正则首部强制添加 ^ 起始边界，优先放置高概率失败的严格规则，让非法文本提前匹配失败，无需全量文本扫描。

适用场景：所有表单格式校验、数据合法性校验，杜绝无效全量匹配

4.超长文本前置截断与分片处理

针对千字符以上超长文本、海量日志、大文件内容，禁止直接全量正则匹配：

1. 优先截断文本（保留业务所需最大长度，默认2000字符）；

2. 超大型文件采用逐行、分片流式处理，规避全局扫描性能瓶颈；

3. 非必要场景放弃正则，使用原生字符串方法遍历解析

5.精简分支逻辑，降低匹配复杂度

多或逻辑分支 | 遵循「长规则前置、短规则后置」原则，优先匹配高精准、长字符规则，避免短规则优先命中导致重复校验；同时精简无效分支，杜绝冗余匹配逻辑。

3.2 语法严谨性优化（杜绝匹配错乱、隐性BUG）

1.规范分组使用，杜绝作用域错乱

仅需捕获提取数据时使用捕获分组 () ，纯规则限定、作用域锁定场景统一使用非捕获分组 (?:)，既保证规则精准，又减少内存开销、提升匹配效率；所有或逻辑分支必须分组包裹，规避优先级错乱。

2.严格区分修饰符，按需精准配置

1. s修饰符：仅跨行匹配、需要.匹配换行时开启，普通单行校验禁止滥用；

2. m修饰符：仅需匹配每行首尾时开启，全局表单校验禁止开启；

3. u修饰符：所有中文、Unicode字符匹配强制开启，避免多字节解析异常；

4. i修饰符：仅大小写兼容场景开启，密码、编码、密钥等敏感场景禁用；

5. 单次校验禁止添加 g全局修饰符，规避lastIndex指针偏移导致的匹配错乱。

3.统一转义规范，根除语法报错

1. 字面量正则：仅转义特殊元字符 . * + ? ( ) [ ] \ /；

2. 构造函数动态正则：强制双层转义所有元字符，搭配专用转义工具方法；

3. 字符集\[\]内部仅转义 \ ] - ^，杜绝多余无效转义。

4.零宽断言精准复用，实现无损匹配

所有精准提取、脱敏、局部替换场景，优先使用零宽断言 (?=)、(?<=)、(?!)、(?<!)，不消耗原文本字符，避免多删、漏删、错改问题，保证原文本结构完整。

3.3 内存与复用优化（提升高频场景性能）

1.固定规则全局缓存，避免重复编译

所有通用固定正则（手机号、邮箱、清洗规则等）统一使用字面量写法，全局预编译缓存；高频调用的动态正则，必须封装缓存工具方法，禁止循环、定时器、批量逻辑内重复 new RegExp。

2.及时重置全局正则指针

复用带g修饰符的正则实例时，手动重置 reg.lastIndex = 0，彻底解决多次匹配结果错乱的隐性BUG。

3.避免全局正则滥用，按需创建实例

临时一次性匹配场景，无需挂载全局正则变量，使用后自动释放内存；高频复用正则统一挂载全局缓存对象，避免频繁创建销毁实例导致内存抖动。

3.4 安全性优化（杜绝正则注入、隐私泄露）

1.动态规则强制转义，防御正则注入

所有用户输入、前端传参、后台配置、数据库读取的动态关键词，必须先经过特殊字符转义工具方法处理，再拼接正则，杜绝恶意元字符篡改匹配规则、绕过风控校验。

2.隐私脱敏强制首尾边界校验

所有手机号、身份证、邮箱等脱敏正则，必须添加 ^$ 全局边界锁定，防止局部匹配导致脱敏绕过、隐私数据泄露。

3.日志强制脱敏，杜绝原始数据落地

所有正则处理的隐私数据，输出日志、接口返回、文件存储前必须完成脱敏，禁止原始明文隐私数据留存。

3.5 容错与兼容性优化（适配复杂业务场景）

1.空值与异常数据容错处理

所有正则工具方法，优先做空值、空字符串、undefined、null、超长异常数据校验，避免参数异常导致JS报错、接口崩溃。

2.前置清洗脏数据，统一文本格式

外部传入的用户文本、日志数据、爬虫内容，正则匹配前优先清洗零宽隐形字符、多余空格、全半角错乱字符、违规标点，统一文本格式后再匹配，大幅降低匹配失效概率。

3.分层适配兼容新旧数据

格式校验正则兼容新旧规范数据（如15/18位身份证、新旧手机号段），避免历史合规数据被误判为非法数据。

3.6 跨语言统一优化规范（规避引擎差异坑）

1.区分引擎特性，不跨引擎套用语法

NFA引擎（JS/Java/Python）可使用断言、分组、反向引用等高阶语法；DFA引擎（MySQL/Grep）仅使用基础语法，杜绝高阶语法失效问题。

2.统一转义逻辑，适配各语言规范

Java/Python/PHP等字符串型正则，统一使用原始字符串或双层转义规范，规避语言自带转义与正则转义冲突。

3.弱化语言独有特性，提升可移植性

通用业务正则尽量使用通用基础语法，减少各语言独有高阶语法，方便多端复用、降低迁移改造成本。

3.7 工程落地强制执行清单

1. 所有上线正则必须无无限嵌套量词、无无边界模糊匹配，通过超长文本压力测试；

2. 固定规则用字面量、动态规则用缓存构造函数，严格区分，禁止混用；

3. 所有校验、脱敏、风控正则必须带首尾边界，杜绝规则绕过漏洞；

4. 非必要不使用捕获分组，精简正则结构，兼顾性能与可读性；

5. 复杂正则优先拆分逻辑，拒绝堆砌超长嵌套正则，降低维护成本；

6. 动态正则必做转义、高频正则必做缓存、超长文本必做截断。

十二、跨语言/引擎正则完整差异总结（生产级全量补全｜语法兼容+坑点+适配方案）

正则核心规则通用，但不同编程语言、数据库、命令行工具、引擎版本存在语法支持、转义规则、修饰符、高阶特性、底层引擎（NFA/DFA）的显著差异。绝大多数跨语言正则报错、匹配失效、移植失败，均源于引擎兼容差异。本节全覆盖主流开发场景，细化各环境特性、高频坑点、移植规范与适配方案，解决正则跨端复用难题。

1. 主流编程语言正则差异（前端/后端开发核心）

1.1 JavaScript（Browser/Node.js）

引擎类型：NFA 非确定有限自动机

完整支持特性：基础元字符、量词、分组、非捕获分组、反向引用、贪婪/非贪婪、零宽先行/后行断言、命名分组、Unicode匹配、s/m/g/i/u/y修饰符

版本兼容边界 ：ES2018 全面支持后行断言、命名分组 ；低版本浏览器不支持不定长后行断言 (?<=.*)

独有特性 ：支持 y 粘性修饰符、全局正则lastIndex 指针偏移特性

高频坑点：

• g全局修饰符复用正则，会出现匹配错乱，需手动重置 lastIndex

• 不定长后行断言老旧环境报错，仅可使用定长后行

• 中文匹配必须加 u 修饰符，否则多字节字符解析异常

最佳实践：固定规则用字面量，动态规则用缓存构造函数，高阶断言兼容低版本环境。

1.2 Java

引擎类型：NFA 非确定有限自动机

完整支持特性：全量基础语法、断言、分组、反向引用、命名分组、贪婪非贪婪

核心语法差异：

• 无原生 s 修饰符，开启 Pattern.DOTALL 等价JS的s模式（.匹配换行）

• 无原生 m 多行修饰符，需开启 Pattern.MULTILINE

• 字符串强制双层转义：正则 \d 必须写为 \\d

高频坑点：

• 直接复制JS正则漏写转义符，导致语法编译报错

• 默认 . 不匹配换行，跨行匹配必须手动开启DOTALL

• 不支持部分极简引擎的简写规则，语法校验更严格

1.3 Python

引擎类型：NFA 非确定有限自动机

完整支持特性：全量高阶语法，支持不定长后行断言、命名分组、反向引用、所有修饰符，兼容性极强

核心语法优势 ：支持 原始字符串 r""，彻底规避双层转义问题，正则写法最简洁

修饰符对应关系：

• re.S 等价 JS s修饰符（.匹配换行）

• re.M 等价 JS m修饰符（行首尾匹配）

• re.I 等价 JS i修饰符（忽略大小写）

高频坑点：普通字符串需双层转义，必须统一使用原始字符串编写正则。

1.4 PHP（PCRE引擎）

引擎类型：PCRE（标准NFA高阶引擎）

特性：完全兼容JS/Java高阶语法，支持所有断言、分组、递归匹配

核心差异 ：正则必须包裹分隔符 / /，支持后置修饰符，字符串存在转义冲突

坑点：分隔符冲突需转义，动态正则拼接极易出现语法断裂。

1.5 Go/Golang

引擎类型：自研RE2引擎（类DFA安全引擎）

核心特性（重大差异） ：无回溯机制、彻底杜绝灾难性回溯 ，性能稳定，但阉割大量高阶语法

不支持特性：不支持反向引用、不定长断言、递归匹配、部分复杂分支逻辑

适配规范：Go正则必须极简，禁止复杂嵌套、反向引用、不定长断言，仅用基础规则。

1.6 C#/.NET

引擎类型：NFA引擎，高阶语法支持度极高

独有优势：支持超长不定长后行断言、丰富的分组捕获、匹配结果分组精准提取

差异点：字符串转义规则宽松，支持原生@原始字符串，适配复杂正则。

2. 数据库正则差异（DFA引擎重灾区｜跨语言移植必避坑）

所有主流数据库均为DFA轻量化引擎，无回溯、不支持高阶语法，是正则移植失效最高频场景。

2.1 MySQL / MariaDB

引擎类型：DFA 确定有限自动机

核心限制（绝对重点）：

• 完全不支持：零宽断言、分组捕获、反向引用、贪婪非贪婪、命名分组

• 仅支持：基础元字符、字符集、基础量词、简单或逻辑

• 无全局匹配概念，仅做布尔匹配校验

语法差异：默认不区分大小写，转义规则简化，复杂规则100%移植失效。

2.2 SQLite

引擎类型：轻量化DFA引擎

特性：语法阉割更严重，仅支持极简匹配，不支持大部分复杂量词与分支。

2.3 PostgreSQL

引擎类型：类PCRE增强引擎

优势：支持部分高阶语法，兼容断言、分组，是数据库中正则能力最强的数据库。

3. Linux/命令行工具正则差异（基础/扩展正则分界）

3.1 Grep / Awk / Sed

引擎类型：轻量化DFA引擎

核心区分：

• 基础正则（默认）：+ ? | () {}均为普通字符，需转义才能生效

• 扩展正则（grep -E / sed -r）：无需转义，支持基础量词与分支

致命坑点 ：命令行正则完全不支持断言、分组捕获、反向引用，无法做精准提取与脱敏。

4. 各环境核心特性对照表（工程速查）

|------------|-----------|-------------|------|-------|-------------|
| 运行环境 | 引擎类型 | 断言支持 | 反向引用 | 灾难性回溯 | 转义特点 |
| JS/Node | NFA | 全支持（定长/不定长） | 支持 | 存在风险 | 字面量无需多层转义 |
| Java | NFA | 全支持 | 支持 | 存在风险 | 字符串强制双层转义 |
| Python | NFA | 全支持 | 支持 | 存在风险 | 原始字符串无转义压力 |
| Go | RE2(安全引擎) | 不支持 | 不支持 | 无风险 | 转义规则严格 |
| MySQL | DFA | 不支持 | 不支持 | 无风险 | 简化转义，高阶语法失效 |
| Linux Grep | DFA | 不支持 | 不支持 | 无风险 | 基础正则需手动转义量词 |

5. 正则跨语言移植通用规范（生产强制标准）

1. 高阶语法不跨引擎移植 ：断言、反向引用、命名分组禁止移植到MySQL/Go/Linux工具，必须重写基础规则适配。

2. 转义规则统一适配：JS字面量正则移植到Java/Python/PHP，必须补齐双层转义，规避语法报错。

3. 风险引擎降级写法 ：Go、数据库、命令行环境，强制使用极简基础正则，放弃复杂嵌套与高阶逻辑。

4. 区分匹配场景移植：精细化提取、脱敏、校验保留NFA高阶语法；海量检索、数据库筛选适配DFA基础语法。

5. 修饰符统一映射：各语言s/m/i修饰符统一对照替换，避免跨行、大小写、行首尾匹配错乱。

十三、正则完整学习路线（循序渐进｜新手入门→工程高阶｜可落地阶梯式教程）

本学习路线依托全文正则知识体系搭建，摒弃碎片化学习，由浅入深、层层递进、学完即能用，区分入门、基础、进阶、高阶、工程实战、性能优化六大阶段，每阶段明确核心目标、必学知识点、重难点、实战任务，完美适配零基础新手、开发进阶、工程落地人群，全程规避无效学习、知识点断层、只会语法不会落地的问题。

第一阶段：零基础破冰（认知打底，1天）

核心目标：搞懂正则本质、定位、适用场景，破除"正则难、晦涩"的认知误区，明确学习价值与使用边界。

必学知识点

• 正则核心定义与本质：模式模糊匹配，而非精准相等匹配

• 通用特性：跨语言、跨工具的通用文本处理标准

• 七大核心业务场景：表单校验、数据清洗、内容提取、工程提效、内容风控、数据脱敏、数据库检索

• 基础取舍逻辑：初步了解正则擅长/不擅长场景，避免滥用

阶段重难点：理解正则"批量规则匹配"的核心优势，区分普通字符串方法与正则的适用差异

落地实战任务：列举3个日常开发中可用正则替代原生代码的场景，简单手写原生判断代码，感知正则极简优势

第二阶段：基础语法筑基（核心骨架，2-3天）

核心目标：掌握正则所有基础语法单元，看懂简单正则、能编写基础匹配规则，解决80%基础文本处理问题。

必学知识点

• 单字符元字符：. \d \D \w \W \s \S 精准含义与匹配规则，熟记大小写对立规律

• 转义体系：特殊符号转义规则，字面量基础转义逻辑

• 字符集 []：自定义匹配、区间匹配、取反规则、内外转义差异（高频避坑点）

• 边界定位符：^ $ \b \B 首尾边界、单词边界，掌握全局锁定匹配写法

• 基础量词：+ * ? {n} {n,} {n,m} 匹配次数规则，理解基础匹配逻辑

阶段重难点：字符集内外转义差异、单词边界匹配误区、量词精准匹配范围

落地实战任务

• 编写简单正则：匹配纯数字、纯字母、手机号基础格式、纯中文文本

• 实战清洗：去除文本首尾空格、过滤特殊符号、剔除空白行

• 纠错练习：修正量词作用域、边界缺失导致的匹配错误

第三阶段：核心语法进阶（能力跃升，3天）

核心目标：掌握正则中级核心语法，具备分组、分支、重复匹配能力，可独立完成常规业务匹配、提取、替换需求。

必学知识点

• 分组语法：捕获分组 ()、非捕获分组 (?:) 区别与落地选型

• 分支选择符 |：或逻辑优先级规则、多分支标准写法与避坑

• 贪婪/非贪婪匹配：默认贪婪特性、? 开启非贪婪、跨内容吞噬问题解决

• 反向引用：\1 \2 分组复用规则，实现重复字符匹配、对称内容校验

• 基础修饰符：g i 全局匹配、忽略大小写，掌握基础使用坑点

阶段重难点：或逻辑优先级错乱、贪婪匹配误杀内容、分组滥用性能冗余、反向引用序号错乱

落地实战任务

• 多后缀匹配：匹配 jpg/png/gif 图片后缀（规范分组写法）

• 重复内容校验：匹配连续重复字符、重复词语

• 非贪婪实战：截取单段HTML标签、分段提取文本内容

第四阶段：高阶语法突破（难点攻克，3-4天）

核心目标：攻克正则最难高阶语法------零宽断言、Unicode匹配，具备精准提取、无损脱敏、精细化筛选能力，解决复杂业务场景。

必学知识点

• 零宽四大断言（核心难点）：先行/后行、正向/反向断言 (?=) (?!) (?<=) (?<!)，理解零宽不消耗字符特性

• Unicode与中文匹配：中文区间、中文标点、全半角字符匹配规则，u 修饰符必备场景

• 高阶修饰符：s m y 修饰符功能、适用场景与混用规范

• 命名分组：替代数字序号分组，解决复杂正则引用错乱问题

阶段重难点：断言位置逻辑辨析、不定长后行断言兼容问题、多修饰符混用冲突

落地实战任务

• 精准提取：从混杂文本中提取价格、手机号、邮箱（不破坏原文本）

• 隐私脱敏：手机号、身份证、邮箱局部脱敏，实现无损替换

• 精准筛选：排除指定关键词、筛选合规中文文案

第五阶段：书写形式与底层原理（夯实根基，2天）

核心目标：吃透两种正则书写形式、引擎底层特性，从根源解决「本地正常线上报错、偶尔匹配失效」等隐性BUG。

必学知识点

• 字面量静态正则 vs 构造函数动态正则：编译时机、缓存机制、转义规则、性能差异

• 动态正则核心坑点：二次转义、正则注入、无缓存性能损耗

• 动态正则工具封装：转义工具、缓存工具落地实现

• 正则六大底层特性：零宽、贪婪、就近作用、分支优先级、单向扫描、优先匹配

• NFA/DFA双引擎底层差异、适用场景、语法兼容边界

阶段重难点：动态正则转义与缓存、引擎特性导致的匹配差异、底层特性引发的BUG溯源

落地实战任务

• 封装通用动态正则工具类，解决注入、性能、转义问题

• 区分业务场景，分别用静态/动态正则实现规则匹配

• 排查并修复因引擎特性、书写形式导致的匹配异常问题

第六阶段：全平台API与跨引擎适配（通用能力，2天）

核心目标：掌握主流语言正则API、跨引擎兼容规则，实现正则多端复用，解决移植报错、语法失效问题。

必学知识点

• JS/Java/Python/PHP/Go主流语言正则API用法与差异

• 数据库（MySQL/PostgreSQL）正则语法阉割规则、适配写法

• Linux命令行正则基础/扩展语法差异

• 跨引擎移植规范：高阶语法兼容、转义适配、风险降级写法

阶段重难点：DFA引擎高阶语法失效、各语言转义规则差异、Go/MySQL正则阉割适配

落地实战任务

• 将同一业务正则（手机号校验、文本清洗）分别适配JS、Python、MySQL环境

• 改写高阶正则为兼容DFA引擎的基础写法

第七阶段：性能优化与全局避坑（工程进阶，2天）

核心目标：根治正则性能卡顿、线上BUG、安全漏洞，写出生产级高性能、高稳定、高安全的正则代码。

必学知识点

• 灾难性回溯底层原理、三大触发条件、高危正则黑名单

• 全维度性能优化方案：长度限定、非贪婪改造、快速失败、分片处理

• 22类高频工程易错点：语法坑、转义坑、修饰符坑、逻辑坑、安全坑

• 生产级规范：缓存复用、超长文本处理、动态规则安全防护

• 正则适用边界取舍：明确禁用场景，拒绝强行用正则解决所有问题

阶段重难点：回溯灾难排查与修复、隐性BUG溯源、场景精准取舍

落地实战任务

• 改造高危嵌套正则，完成性能优化，通过超长文本压力测试

• 复盘日常开发正则报错案例，对应规避高频坑点

第八阶段：工程实战模板落地（能力固化，持续复用）

核心目标：吃透全场景生产模板，实现开箱即用，全面提升开发、重构、数据处理效率。

必学知识点

• 通用表单校验模板、数据清洗模板、内容提取模板

• 内容风控、敏感词过滤、隐私脱敏工程模板

• IDE工程重构、代码清理、配置解析、日志处理批量模板

• 工程强制落地规范、避坑准则、分层适配方案

阶段核心目标：搭建个人正则工具库，固化所有高频业务模板

落地实战任务

• 整合所有生产模板，封装专属前端/后端正则工具函数库

• 在实际项目中落地模板，完成代码重构、数据处理、风控校验优化

终极学习闭环：复盘迭代（长期）

• 错题复盘：记录每次匹配失效、语法报错、性能卡顿问题，溯源底层原因

• 场景沉淀：新增业务场景及时沉淀专属正则规则，持续丰富工具库

• 规范落地：严格遵循工程选型、性能、安全规范，杜绝野路子正则写法

学习核心心法（少走90%弯路）

1. 先懂原理，再记语法：所有语法、坑点、性能问题均源于底层引擎特性，原理通透则一通百通

2. 拒绝堆砌复杂正则：工程中简洁、稳定、高性能的正则远优于复杂嵌套正则

3. 场景优先，语法次之：先判断该不该用正则，再思考怎么写正则，避免滥用

4. 循序渐进，不跳级学习：高阶语法、性能优化必须建立在基础语法扎实的前提下