断言

1. 学习目标

本节采用 Bloom 分类法对学习目标进行层级化建模，确保读者能够由浅入深、由具体到抽象地掌握正则表达式断言（Assertion）的全部要义。

1.1 记忆层（Remember）

• 准确回忆四种断言的语法形式：正向先行 (?=pattern)、负向先行 (?!pattern)、正向后行 (?<=pattern)、负向后行 (?<!pattern)。
• 列出 ECMAScript 标准中后行断言（Lookbehind）引入的具体版本（ES2018）及其在 V8、SpiderMonkey、JavaScriptCore 三大引擎中的落地时间。
• 复述”零宽匹配（Zero-Width Match）“的定义：断言匹配位置而非字符，不消耗输入字符串。

1.2 理解层（Understand）

• 解释断言与普通字符匹配在有限状态自动机（Finite State Automaton, FSA）层面的本质差异。
• 阐释后行断言在正则引擎实现中的核心难点：NFA 的”反向扫描”为何需要特殊数据结构（如双向链表字符流）。
• 说明固定长度后行断言（Fixed-Length Lookbehind）与可变长度后行断言（Variable-Length Lookbehind）在 ECMAScript 规范中的语义差异。

1.3 应用层（Apply）

• 在生产项目中使用先行断言实现密码强度校验、CSV 字段分割、HTML 标签内容提取等典型场景。
• 通过后行断言简化”前缀条件匹配”逻辑，避免使用捕获组与后处理的繁琐写法。
• 在 Node.js 服务端使用断言实现日志清洗、配置文件解析、SQL 注入检测等文本处理任务。

1.4 分析层（Analyze）

• 对比 JavaScript 正则引擎与 PCRE2、Python re、Java java.util.regex、Rust regex、Go regexp 在断言支持上的差异。
• 拆解一个含嵌套断言的复杂正则表达式，绘制其对应的 NFA 状态转移图，标注零宽位置。
• 分析”回溯爆炸（Catastrophic Backtracking）“在断言场景下的触发条件，并解释 V8 的回溯限制策略。

1.5 评价层（Evaluate）

• 评估在同一文本处理任务中，“断言方案”与”非断言方案（如字符串方法链式调用）“在可读性、性能、维护成本三维度上的得分。
• 对给定的三套密码强度正则（单层断言、多层断言、断言+反向引用）评判其安全性与执行效率。
• 评审主流开源项目（如 ESLint、Prettier、Babel）中正则断言的使用模式，给出可量化的改进建议。

1.6 创造层（Create）

• 设计并实现一个基于断言的轻量级词法分析器（Lexer），支持自定义 token 规则与上下文敏感匹配。
• 构建一套正则性能基准测试框架，自动测量含断言正则在不同输入规模下的执行时间与内存占用。
• 撰写一份团队级《正则表达式工程规范》文档，包含断言使用准则、性能预算、Code Review 检查项、CI 静态分析脚本。

2. 历史动机与演化

2.1 正则表达式的理论起源（1943-1956）

正则表达式的理论基础可追溯至 1943 年 Warren McCulloch 与 Walter Pitts 提出的神经元数学模型，他们用正规式描述神经网络的状态转移。1956 年，Stephen Kleene 在论文《Representation of Events in Nerve Nets and Finite Automata》中正式定义了**正则集合（Regular Sets）与正则表达式（Regular Expression）**的概念，并证明其与有限状态自动机等价。

Kleene 定理奠定了正则表达式的数学基础：

其中 $L(A)$ 表示自动机 $A$ 接受的语言，$L(R)$ 表示正则表达式 $R$ 描述的语言。

2.2 Unix 工具与 POSIX 标准（1968-1992）

1968 年，Ken Thompson 在《QED Text Editor》中实现了首个正则表达式搜索引擎，并将其引入 Unix 的 ed、grep、sed 等工具。Thompson 的实现采用 NFA（Nondeterministic Finite Automaton）构造法，是现代正则引擎的鼻祖。

1975 年，Bell Labs 的开发者将正则表达式分为两类：

• 基础正则（BRE, Basic Regular Expression）：用于 grep、sed 默认模式。
• 扩展正则（ERE, Extended Regular Expression）：用于 egrep、awk。

1992 年，POSIX.2 标准化了两类正则的语法，但未包含断言。断言是 PCRE 的扩展特性。

2.3 PCRE 与先行断言的诞生（1987-1997）

1987 年，Philip Hazel 在剑桥大学开发了 PCRE（Perl Compatible Regular Expressions）库，目标是兼容 Perl 5 的正则语法。Perl 5 在 1994 年引入了先行断言（Lookahead）：

# Perl 5.004 (1996)
$price =~ /\d+(?=元)/;  # 正向先行
$non_px =~ /\d+(?!px)/;  # 负向先行

先行断言的设计动机源于”上下文敏感匹配”需求：开发者希望匹配某个模式，但只消费其中一部分，另一部分作为”上下文”不被消费。在断言出现之前，开发者只能通过捕获组实现：

# 断言出现前的写法：必须用捕获组
if ($text =~ /(\d+)元/) {
    $price = $1;
}

断言的引入使代码更简洁：

# 使用先行断言：直接匹配数字
@prices = $text =~ /\d+(?=元)/g;

2.4 后行断言的演进（2000-2018）

后行断言（Lookbehind）的实现远比先行断言复杂，原因在于：

1. 方向问题：NFA 是从左到右扫描输入，后行断言需要”向左看”，即扫描已经经过的字符。
2. 长度问题：先行断言从当前位置向前扫描，长度可变；后行断言需要确定”向左看多远”。
3. 回退问题：NFA 没有原生回退能力，后行断言需要缓存已扫描字符或反向遍历。

Perl 5.005（1999）首次实验性支持后行断言，但要求固定长度（Fixed-Length）。PCRE 4.0（2003）开始支持可变长度后行断言，但实现复杂度高。

Java 1.4（2002）通过 java.util.regex 支持后行断言，同样要求固定长度。Python 2.0（2000）的 re 模块也要求固定长度。

ECMAScript 标准化进程较为缓慢：

• ES3（1999）：支持先行断言。
• ES2018（ES9）：正式引入后行断言，支持可变长度。

V8 引擎在 Chrome 62（2017.10）首次实现后行断言，SpiderMonkey 在 Firefox 78（2020.06）跟进，JavaScriptCore 在 Safari 16.4（2023.03）完全支持。

2.5 V8 正则引擎的演化

V8 的正则引擎经历了多次重大重构：

V8 的双引擎策略（irregexp + experimental NFA）是为了应对回溯爆炸攻击：irregexp 编译为本地代码速度快但易受 DoS 攻击，新 NFA 引擎虽慢但有严格的执行时间上限。

2.6 浏览器兼容性现状

截至 2026 年，断言在主流环境的支持情况：

对于需要兼容 IE 或旧版浏览器的项目，应使用 Babel 插件 @babel/plugin-transform-named-capturing-groups-regex 或 transpile 为等价的非断言实现。

3. 形式化定义

3.1 正则表达式的代数定义

正则表达式 $R$ 在字母表 $\Sigma$ 上递归定义如下：

其中：

• $\emptyset$：空语言。
• $\epsilon$：空串。
• $a \in \Sigma$：单字符。
• $R_1 \cdot R_2$：连接。
• $R_1 | R_2$：选择。
• $R^*$：Kleene 闭包。

扩展操作符（如 +、?、{n,m}）均可由上述基本操作符表达。例如 $R^+ = R \cdot R^*$，$R? = R | \epsilon$。

3.2 断言的形式化语义

定义 1（先行断言）：给定正则表达式 $R$ 与输入串 $w = w_1 w_2 \ldots w_n$，位置 $i$（$0 \leq i \leq n$）满足正向先行断言 (?=R) 当且仅当：

即从位置 $i$ 开始的后缀串中，存在一个前缀属于 $L(R)$。

定义 2（负向先行断言）：位置 $i$ 满足 (?!R) 当且仅当：

定义 3（正向后行断言）：位置 $i$ 满足 (?<=R) 当且仅当：

即从位置 $0$ 到 $i$ 的前缀串中，存在一个后缀属于 $L(R)$。

定义 4（负向后行断言）：位置 $i$ 满足 (?<!R) 当且仅当：

3.3 零宽特性的数学表述

断言的”零宽”特性可形式化为：

普通正则匹配返回的是消费的字符区间 $[i, j]$，而断言返回的是单点 $\{i\}$（位置而非字符）。这意味着断言可以”叠加”在同一位置：

// 同一位置应用多个断言
const regex = /(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}/;

数学上，多个先行断言的合取为：

3.4 NFA 构造规则

Thompson 构造法将正则表达式转换为 NFA。对于断言，需扩展标准构造规则：

标准 Thompson 构造：

• 字符 $a$：状态 $q_0 \xrightarrow{a} q_1$
• 连接 $R_1 \cdot R_2$：串联两个 NFA
• 选择 $R_1 | R_2$：新增起始状态分叉到两个 NFA
• 闭包 $R^*$：新增起始状态接受或循环

断言扩展构造：

• 先行断言 (?=R)：在当前位置”虚拟”运行 $R$ 的 NFA，若接受则继续，但不消费字符。
• 负向先行 (?!R)：在当前位置”虚拟”运行 $R$ 的 NFA，若拒绝则继续。
• 后行断言 (?<=R)：从位置 0 到当前位置的子串上”虚拟”运行 $R$ 的 NFA，检查是否有后缀被接受。

实现上，断言通常通过”子匹配 + 位置回退”实现：

NFA for (?=R):
  1. Save current position p
  2. Run NFA for R starting at p
  3. If accepted, restore position to p (zero-width)
  4. If rejected, fail

NFA for (?<=R):
  1. Save current position p
  2. Find all positions q < p such that w[q:p] ∈ L(R)
  3. If any q exists, continue at p (zero-width)
  4. If none, fail

3.5 复杂度分析

设输入串长度为 $n$，正则表达式长度为 $m$：

• 标准 NFA 匹配：$O(nm)$ 时间，$O(m)$ 空间（Thompson NFA）。
• 回溯 NFA 匹配：最坏 $O(2^n)$ 时间（回溯爆炸），平均 $O(nm)$。
• 含先行断言的匹配：每个断言增加一次子匹配，最坏 $O(n^2 m)$。
• 含后行断言的匹配：每个位置需扫描前缀，最坏 $O(n^2 m)$。
• 含嵌套断言的匹配：递归子匹配，最坏 $O(n^k m)$，$k$ 为嵌套深度。

V8 通过回溯上限（默认 $10^6$ 步）与超时机制防止指数级回溯。

4. 理论推导与证明

4.1 引理：断言不改变正则语言的表达能力

引理：包含断言的正则表达式所描述的语言仍是正则语言。

证明：

需证明对任意含断言的正则 $R$，存在不含断言的正则 $R'$ 使得 $L(R) = L(R')$。

对 $R$ 的结构进行归纳：

基础情形：$R = a$ 或 $R = \epsilon$，显然是正则语言。

归纳情形：

1. $R = R_1 \cdot R_2$：由归纳假设 $L(R_1), L(R_2)$ 正则，正则语言对连接封闭，故 $L(R)$ 正则。

2. $R = R_1 | R_2$：正则语言对并封闭。

3. $R = R_1^*$：正则语言对 Kleene 闭包封闭。

4. $R = (?=R_1) R_2$：位置 $i$ 满足 (?=R_1) 当且仅当 $w[i:]$ 有前缀属于 $L(R_1)$。可构造等价的正则：

此语言可用正则表达式 (?=R_1)R_2 等价改写为 (R_1.*)? R_2 的变体（具体构造略，核心是正则语言对商运算封闭）。

5. $R = (?!R_1) R_2$：负向先行是 $L(R_1)$ 的补，正则语言对补封闭，故 $L(R)$ 仍正则。

6. 后行断言类似，通过左商（Left Quotient）运算证明。

证毕。

推论：断言是”语法糖”，不增加表达能力，但显著简化正则书写。

4.2 定理：先行断言的幂等性

定理：对任意正则 $R$，(?=R)(?=R) 与 (?=R) 描述同一语言。

证明：

对位置 $i$，(?=R)(?=R) 匹配当且仅当：

1. 位置 $i$ 满足 (?=R)（第一个断言）。
2. 位置 $i$ 满足 (?=R)（第二个断言，因零宽不前进）。

两者同时成立当且仅当位置 $i$ 满足 (?=R)，即与 (?=R) 等价。

形式化：

证毕。

4.3 命题：负向先行断言的补语言性质

命题：(?=R) 与 (?!R) 在同一位置上的匹配结果互斥且穷尽。

证明：

对位置 $i$ 与正则 $R$：

• 若 $w[i:]$ 有前缀属于 $L(R)$，则 (?=R) 匹配，(?!R) 不匹配。
• 若 $w[i:]$ 无前缀属于 $L(R)$，则 (?=R) 不匹配，(?!R) 匹配。

两者必居其一且仅居其一，即：

其中 $\oplus$ 表示异或。

证毕。

4.4 推论：后行断言的方向对称性

推论：(?<=R) 在位置 $i$ 的匹配等价于”将输入串反转后，(?=R^R) 在反转串的位置 $n-i$ 的匹配”，其中 $R^R$ 是 $R$ 的反转正则。

证明思路：

后行断言检查 $w[:i]$ 的后缀是否属于 $L(R)$。将 $w$ 反转为 $w^R$，则 $w[:i]$ 反转为 $w^R[n-i:]$。在反转串上，位置 $n-i$ 的先行断言检查 $w^R[n-i:]$ 的前缀是否属于 $L(R^R)$。

由于正则语言在反转操作下封闭（可构造反转 NFA），故 $R^R$ 存在。

证毕。

工程意义：理论上可通过反转输入串将后行断言转为先行断言，但实际实现中反转 Unicode 串（含组合字符、代理对）复杂，故引擎通常直接实现后行扫描。

4.5 回溯爆炸的不可判定性

定理：判定一个含断言的正则表达式是否在某些输入上触发指数级回溯，是不可判定的（Undecidable）。

证明思路：

通过归约到停机问题。构造正则 $R_M$ 使其在输入 $w$ 上的匹配行为模拟图灵机 $M$ 在 $w$ 上的计算。若能判定 $R_M$ 是否触发指数回溯，则可判定 $M$ 是否停机。

由停机问题不可判定，故回溯爆炸判定亦不可判定。

证毕。

工程后果：

1. 无法静态分析正则是否安全，必须依赖运行时限制（如 V8 的回溯上限）。
2. 开发者需通过 Code Review 与性能测试人工保证正则安全。
3. 对于不可信输入，应使用 RE2（Google）等基于 DFA 的引擎，其匹配时间保证 $O(nm)$，但 RE2 不支持回溯与部分断言特性。

5. 代码示例

5.1 基础用法：四种断言

// 文件名: assertions-basic.js
// 运行方式: node assertions-basic.js

/**
 * 演示四种断言的基础用法
 */

// 1. 正向先行断言 (?=pattern)
// 匹配后面跟着"元"的数字
const lookaheadPos = /\d+(?=元)/g;
console.log('苹果5元，香蕉3元'.match(lookaheadPos));
// 输出: ['5', '3']
// "元"字不被消费

// 2. 负向先行断言 (?!pattern)
// 匹配后面不跟"px"的数字
const lookaheadNeg = /\d+(?!px)/g;
console.log('12px 34em 56'.match(lookaheadNeg));
// 输出: ['1', '34', '56']
// 注意: "12px" 中的 1 后面是 2 不是 px，所以 1 匹配
// 更精确写法需要加边界: /\b\d+(?!px\b)/g

// 3. 正向后行断言 (?<=pattern)
// 匹配"价格："后面的数字
const lookbehindPos = /(?<=价格：)\d+/g;
console.log('苹果价格：5，香蕉价格：3'.match(lookbehindPos));
// 输出: ['5', '3']

// 4. 负向后行断言 (?<!pattern)
// 匹配前面不是"不"的"喜欢"
const lookbehindNeg = /(?<!不)喜欢/g;
console.log('我喜欢你，他不喜欢你'.match(lookbehindNeg));
// 输出: ['喜欢']
// 只匹配第一个"喜欢"，第二个前面有"不"

// 5. 组合使用：先行 + 后行
// 匹配被引号包围的数字
const quotedNum = /(?<=")\d+(?=")/g;
console.log('"123" abc "456"'.match(quotedNum));
// 输出: ['123', '456']

5.2 密码强度校验

// 文件名: password-validator.js
// 运行方式: node password-validator.js

/**
 * 使用正向先行断言实现多条件密码校验
 * 要求：至少8位，包含小写字母、大写字母、数字、特殊字符
 */

function validatePassword(password) {
  // 多个先行断言叠加在同一位置
  const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]).{8,}$/;

  if (!regex.test(password)) {
    // 分别检查每个条件以提供具体反馈
    const checks = [
      { name: '至少8位', pass: password.length >= 8 },
      { name: '包含小写字母', pass: /[a-z]/.test(password) },
      { name: '包含大写字母', pass: /[A-Z]/.test(password) },
      { name: '包含数字', pass: /\d/.test(password) },
      { name: '包含特殊字符', pass: /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password) }
    ];
    const failed = checks.filter(c => !c.pass).map(c => c.name);
    return { valid: false, reason: `不满足: ${failed.join(', ')}` };
  }

  return { valid: true, reason: '密码强度合格' };
}

// 测试用例
console.log(validatePassword('Abc12345!'));
// { valid: true, reason: '密码强度合格' }

console.log(validatePassword('abc12345'));
// { valid: false, reason: '不满足: 包含大写字母, 包含特殊字符' }

console.log(validatePassword('ABC12345!'));
// { valid: false, reason: '不满足: 包含小写字母' }

console.log(validatePassword('Abc1!'));
// { valid: false, reason: '不满足: 至少8位' }

// 解析正则：
// ^                          从开头匹配
// (?=.*[a-z])                先行断言：后面必须有小写字母
// (?=.*[A-Z])                先行断言：后面必须有大写字母
// (?=.*\d)                   先行断言：后面必须有数字
// (?=.*[!@#$%^&*()...])      先行断言：后面必须有特殊字符
// .{8,}                      实际匹配：至少8个任意字符
// $                          到结尾

5.3 CSV 字段分割

// 文件名: csv-parser.js
// 运行方式: node csv-parser.js

/**
 * 使用先行断言实现 CSV 字段分割
 * 支持引号内包含逗号的场景
 */

function parseCSVLine(line) {
  // 经典正则：匹配不在引号内的逗号
  // 原理：逗号后面的字符中，引号必须成对出现（即引号总数为偶数）
  const regex = /,(?=(?:[^"]*"[^"]*")*[^"]*$)/g;
  return line.split(regex).map(field => field.replace(/^"|"$/g, '').replace(/""/g, '"'));
}

const csvLine = 'name,"Smith, John",age,"30",city,"Beijing, China"';
console.log(parseCSVLine(csvLine));
// 输出: ['name', 'Smith, John', 'age', '30', 'city', 'Beijing, China']

// 正则解析：
// ,                          匹配逗号
// (?=                        先行断言开始
//   (?:[^"]*"[^"]*")*        零或多对"非引号+引号+非引号+引号"
//   [^"]*$                   后面到行尾没有引号
// )                          断言结束
//
// 直观理解：逗号后面若有偶数个引号，则该逗号不在引号内

// 多行 CSV 解析
function parseCSV(text) {
  const lines = text.split('\n').filter(line => line.trim());
  if (lines.length === 0) return [];

  const headers = parseCSVLine(lines[0]);
  const rows = lines.slice(1).map(line => {
    const values = parseCSVLine(line);
    const row = {};
    headers.forEach((h, i) => { row[h] = values[i]; });
    return row;
  });

  return { headers, rows };
}

const csvText = `id,name,description
1,"Alice","Software engineer, frontend"
2,"Bob","Data scientist"
3,"Charlie","Likes ""quotes"" in text"`;

console.log(parseCSV(csvText));
// {
//   headers: ['id', 'name', 'description'],
//   rows: [
//     { id: '1', name: 'Alice', description: 'Software engineer, frontend' },
//     { id: '2', name: 'Bob', description: 'Data scientist' },
//     { id: '3', name: 'Charlie', description: 'Likes "quotes" in text' }
//   ]
// }

5.4 HTML 标签内容提取

// 文件名: html-extractor.js
// 运行方式: node html-extractor.js

/**
 * 组合使用先行与后行断言提取 HTML 标签内容
 * 注意：正则不适合解析复杂 HTML，仅适用于简单场景
 */

const html = `
<div class="container">
  <h1>Title</h1>
  <p>Paragraph 1</p>
  <p>Paragraph 2</p>
  <a href="https://example.com">Link</a>
</div>
`;

// 1. 提取所有标签内的文本
const innerTextRegex = /(?<=<\w+[^>]*>)[^<]+(?=<\/\w+>)/g;
console.log('标签内文本:', html.match(innerTextRegex));
// 输出: ['Title', 'Paragraph 1', 'Paragraph 2', 'Link']

// 2. 提取所有 class 属性值
const classRegex = /(?<=class=")[^"]+(?=")/g;
console.log('class 值:', html.match(classRegex));
// 输出: ['container']

// 3. 提取所有 href 属性值
const hrefRegex = /(?<=href=")[^"]+(?=")/g;
console.log('href 值:', html.match(hrefRegex));
// 输出: ['https://example.com']

// 4. 提取所有开始标签名
const tagNameRegex = /(?<=<)\w+(?=[\s>])/g;
console.log('标签名:', html.match(tagNameRegex));
// 输出: ['div', 'h1', 'p', 'p', 'a']

// 5. 提取带特定 class 的元素内容
function extractByClass(html, className) {
  // 后行断言匹配 class="xxx" 之后的标签关闭
  // 先行断言匹配下一个 </tag>
  const regex = new RegExp(`(?<=class="${className}"[^>]*>)[^<]+(?=<\\/\\w+>)`, 'g');
  return html.match(regex) || [];
}

console.log('container 内容:', extractByClass(html, 'container'));
// 输出: [] (container 是 div，内容含其他标签，正则不适用)

// 6. 提取自闭合标签
const selfClosingRegex = /<\w+[^>]*\/>/g;
console.log('自闭合标签:', html.match(selfClosingRegex));
// 输出: null

// 7. 提取注释内容
const htmlWithComments = '<div>text</div><!-- comment --><p>more</p>';
const commentRegex = /(?<=<!--)[\s\S]+(?=-->)/g;
console.log('注释内容:', htmlWithComments.match(commentRegex));
// 输出: [' comment ']

5.5 货币格式处理

// 文件名: currency-formatter.js
// 运行方式: node currency-formatter.js

/**
 * 使用断言处理货币格式：提取金额、千分位格式化
 */

// 1. 提取带货币符号的金额
function extractAmounts(text) {
  // 后行断言匹配货币符号，先行断言确保数字后非数字
  const regex = /(?<=¥|￥|\$|€|£)\s?[\d,]+\.?\d*/g;
  const matches = text.match(regex);
  return matches ? matches.map(s => parseFloat(s.replace(/,/g, '').trim())) : [];
}

const text = '商品A ¥1,299.00，商品B $99.50，商品C ￥3,500，商品D €49.99';
console.log('提取金额:', extractAmounts(text));
// 输出: [1299, 99.5, 3500, 49.99]

// 2. 千分位格式化（经典应用）
function formatNumber(num) {
  // \B                          非单词边界（不在开头）
  // (?=(\d{3})+(?!\d))          先行断言：后面是3的倍数个数字且不再有数字
  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
}

console.log(formatNumber(1234567));      // '1,234,567'
console.log(formatNumber(1234567890));   // '1,234,567,890'
console.log(formatNumber(1234567.89));   // '1,234,567.89'
console.log(formatNumber(100));          // '100'
console.log(formatNumber(1000));         // '1,000'

// 正则解析：
// \B                  非单词边界（避免在数字开头加逗号）
// (?=                 先行断言开始
//   (\d{3})+          一个或多个"3位数字"组
//   (?!\d)            后面不再是数字（确保是3的整数倍）
// )                   断言结束
//
// 直观理解：从右往左每3位数字前加逗号

// 3. 反向操作：移除千分位
function removeThousandSeparator(numStr) {
  // 负向先行断言：小数点前的逗号才移除
  return numStr.replace(/,(?=\d{3}(\D|$))/g, '');
}

console.log(removeThousandSeparator('1,234,567.89'));  // '1234567.89'
console.log(removeThousandSeparator('1,234'));         // '1234'

5.6 文本清洗与替换

// 文件名: text-cleanup.js
// 运行方式: node text-cleanup.js

/**
 * 使用断言实现精细化的文本清洗
 */

// 1. 在数字与字母之间插入空格
function separateNumAndLetter(str) {
  // 后行断言：数字后，先行断言：字母前
  return str
    .replace(/(?<=\d)(?=[a-zA-Z])/g, ' ')
    .replace(/(?<=[a-zA-Z])(?=\d)/g, ' ');
}

console.log(separateNumAndLetter('abc123def456'));
// 输出: 'abc 123 def 456'

console.log(separateNumAndLetter('IPv4Address192168'));
// 输出: 'IPv 4 Address 192 168'

// 2. 移除代码中的注释（保留字符串内的）
function stripComments(code) {
  // 负向先行断言确保不在字符串内（简化版，仅处理双引号）
  // 实际项目应使用 AST 解析器如 @babel/parser
  const regex = /\/\/[^\n]*(?=(?:[^"]*"[^"]*")*[^"]*$)/g;
  return code.replace(regex, '').trim();
}

const code = `
const name = "old // value"; // this is a comment
const url = "https://example.com"; // another comment
`;

console.log(stripComments(code));
// 输出:
// const name = "old // value";
// const url = "https://example.com";

// 3. 中英文混排加空格
function addSpaceBetweenCJKAndLatin(text) {
  // \p{Han} 匹配汉字（需 u 标志）
  // 后行断言：汉字后，先行断言：字母数字前
  return text
    .replace(/(?<=[\u4e00-\u9fa5])(?=[a-zA-Z0-9])/gu, ' ')
    .replace(/(?<=[a-zA-Z0-9])(?=[\u4e00-\u9fa5])/gu, ' ');
}

console.log(addSpaceBetweenCJKAndLatin('Hello世界World123'));
// 输出: 'Hello 世界 World 123'

console.log(addSpaceBetweenCJKAndLatin('使用Vue3开发'));
// 输出: '使用 Vue3 开发'

// 4. 智能大小写转换
function smartCapitalize(text) {
  // 负向后行断言：非句首或空格后的字母不大写
  // 仅在句首（^ 或句号+空格后）大写
  return text.replace(
    /(?<=^|[.!?]\s+)[a-z]/g,
    match => match.toUpperCase()
  );
}

console.log(smartCapitalize('hello world. this is a test. end!'));
// 输出: 'Hello world. This is a test. End!'

5.7 URL 参数提取

// 文件名: url-params.js
// 运行方式: node url-params.js

/**
 * 使用后行断言提取 URL 查询参数
 */

// 1. 提取单个参数
function getQueryParam(url, param) {
  const regex = new RegExp(`(?<=${param}=)[^&]+`);
  const match = url.match(regex);
  return match ? decodeURIComponent(match[0]) : null;
}

const url = 'https://example.com/page?id=123&name=test%20user&lang=zh';
console.log(getQueryParam(url, 'id'));     // '123'
console.log(getQueryParam(url, 'name'));   // 'test user' (已解码)
console.log(getQueryParam(url, 'page'));   // null

// 2. 提取所有参数
function getAllParams(url) {
  // 后行断言匹配 ? 或 & 之后的内容
  const paramRegex = /(?<=[?&])([^=&]+)=([^&]+)/g;
  const params = {};
  let match;
  while ((match = paramRegex.exec(url)) !== null) {
    params[decodeURIComponent(match[1])] = decodeURIComponent(match[2]);
  }
  return params;
}

console.log(getAllParams(url));
// 输出: { id: '123', name: 'test user', lang: 'zh' }

// 3. 提取 URL 各部分
function parseUrl(url) {
  // 协议
  const protocol = url.match(/(?<=^)[^:]+(?=:\/\/)/)?.[0];
  // 域名
  const host = url.match(/(?<=:\/\/)[^/]+/)?.[0];
  // 路径
  const path = url.match(/(?<=:\/\/[^/]+)[^?]*/)?.[0] || '/';
  // 查询串
  const query = url.match(/(?<=\?)[^#]*/)?.[0] || '';
  // 锚点
  const hash = url.match(/(?<=#).+$/)?.[0] || '';

  return { protocol, host, path, query, hash, params: getAllParams(url) };
}

console.log(parseUrl('https://api.example.com/v1/users?page=1&limit=20#section2'));
// 输出:
// {
//   protocol: 'https',
//   host: 'api.example.com',
//   path: '/v1/users',
//   query: 'page=1&limit=20',
//   hash: 'section2',
//   params: { page: '1', limit: '20' }
// }

5.8 词法分析器

// 文件名: lexer.js
// 运行方式: node lexer.js

/**
 * 使用断言实现简单的 JavaScript 词法分析器
 * 支持：数字、标识符、字符串、运算符、注释
 */

function tokenize(code) {
  const tokens = [];
  const patterns = [
    { type: 'WHITESPACE', regex: /\s+/y },
    { type: 'COMMENT',     regex: /\/\/[^\n]*|\/\*[\s\S]*?\*\//y },
    { type: 'NUMBER',      regex: /\d+\.?\d*(?:[eE][+-]?\d+)?/y },
    { type: 'STRING',      regex: /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/y },
    { type: 'KEYWORD',     regex: /\b(?:const|let|var|function|return|if|else|for|while|class|extends|new|this|import|export|from|default|async|await)\b/y },
    { type: 'IDENTIFIER',  regex: /[a-zA-Z_$][\w$]*/y },
    { type: 'OPERATOR',    regex: /[+\-*/=<>!&|%^~?:]+/y },
    { type: 'PUNCTUATION', regex: /[(){}\[\];,.]/y }
  ];

  let pos = 0;
  while (pos < code.length) {
    let matched = false;
    for (const { type, regex } of patterns) {
      regex.lastIndex = pos;
      const match = regex.exec(code);
      if (match && match.index === pos) {
        if (type !== 'WHITESPACE') {
          tokens.push({ type, value: match[0], position: pos });
        }
        pos += match[0].length;
        matched = true;
        break;
      }
    }
    if (!matched) {
      throw new Error(`Unexpected character at position ${pos}: ${code[pos]}`);
    }
  }

  return tokens;
}

// 使用断言增强词法分析：上下文敏感匹配
function tokenizeWithContext(code) {
  // 负向后行断言：关键字前不能有 . （避免 obj.return 误判为关键字）
  const keywordRegex = /(?<![.\w])\b(const|let|var|function|return|if|else)\b/g;

  const keywords = new Set();
  let match;
  while ((match = keywordRegex.exec(code)) !== null) {
    keywords.add(match[1]);
  }

  return { tokens: tokenize(code), keywords };
}

const code = `
  const x = 42;
  const obj = { return: 1 };
  function foo() { return x; }
`;

console.log(tokenizeWithContext(code));
// keywords: Set { 'const', 'function', 'return' }
// 注意: obj.return 中的 return 不会被识别为关键字

5.9 日志解析

// 文件名: log-parser.js
// 运行方式: node log-parser.js

/**
 * 使用断言解析结构化日志
 */

const log = `
[2026-07-21T10:30:45.123Z] INFO  [UserService] - User login: id=12345, ip=192.168.1.100
[2026-07-21T10:31:02.456Z] ERROR [PaymentService] - Payment failed: orderId=ORD-001, reason=insufficient_balance
[2026-07-21T10:31:15.789Z] WARN  [CacheService] - Cache miss: key=user:profile:67890
`;

// 1. 提取时间戳
const timestampRegex = /(?<=\[)[^\]]+(?=\])/g;
console.log('时间戳:', log.match(timestampRegex));
// 输出: ['2026-07-21T10:30:45.123Z', '2026-07-21T10:31:02.456Z', '2026-07-21T10:31:15.789Z']

// 2. 提取日志级别
const levelRegex = /(?<=\] )\w+(?= )/g;
console.log('日志级别:', log.match(levelRegex));
// 输出: ['INFO', 'ERROR', 'WARN']

// 3. 提取服务名
const serviceRegex = /(?<=\[)[^\]]+(?=\])/g;
// 注意：会同时匹配时间戳中的内容，需更精确
const preciseServiceRegex = /(?<=\] \w+\s+\[)[^\]]+(?=\])/g;
console.log('服务名:', log.match(preciseServiceRegex));
// 输出: ['UserService', 'PaymentService', 'CacheService']

// 4. 提取键值对
function extractKeyValues(line) {
  const kvRegex = /(\w+)=(?=\S)([^,\s]+)/g;
  const result = {};
  let match;
  while ((match = kvRegex.exec(line)) !== null) {
    result[match[1]] = match[2];
  }
  return result;
}

console.log(extractKeyValues('User login: id=12345, ip=192.168.1.100'));
// 输出: { id: '12345', ip: '192.168.1.100' }

// 5. 解析整条日志
function parseLog(logText) {
  const lines = logText.trim().split('\n');
  return lines.map(line => {
    const match = line.match(
      /\[(?<timestamp>[^\]]+)\]\s+(?<level>\w+)\s+\[(?<service>[^\]]+)\]\s+-\s+(?<message>.+)/
    );
    if (!match) return null;
    const { timestamp, level, service, message } = match.groups;
    return {
      timestamp: new Date(timestamp),
      level,
      service,
      message,
      fields: extractKeyValues(message)
    };
  }).filter(Boolean);
}

console.log(parseLog(log));
// 输出:
// [
//   {
//     timestamp: 2026-07-21T10:30:45.123Z,
//     level: 'INFO',
//     service: 'UserService',
//     message: 'User login: id=12345, ip=192.168.1.100',
//     fields: { id: '12345', ip: '192.168.1.100' }
//   },
//   ...
// ]

5.10 SQL 注入检测

// 文件名: sql-injection-detector.js
// 运行方式: node sql-injection-detector.js

/**
 * 使用断言检测常见 SQL 注入模式
 * 注意：正则不能替代参数化查询，仅用于辅助检测
 */

const suspiciousPatterns = [
  // 1. 联合查询注入
  {
    name: 'UNION injection',
    pattern: /(?i)\bunion\b(?=\s+select)/,
    severity: 'high'
  },
  // 2. 注释注入
  {
    name: 'Comment injection',
    pattern: /(?<=\w)--|(?<=\w)\/\*/,
    severity: 'medium'
  },
  // 3. 布尔盲注
  {
    name: 'Boolean blind injection',
    pattern: /(?i)\b(and|or)\b(?=\s+1=1|\s+1=2|\s+'a'='a')/,
    severity: 'high'
  },
  // 4. 时间盲注
  {
    name: 'Time blind injection',
    pattern: /(?i)\bsleep\b(?=\s*\()|\bbenchmark\b(?=\s*\()/,
    severity: 'high'
  },
  // 5. 堆叠查询
  {
    name: 'Stacked query',
    pattern: /;(?=\s*(?i:drop|insert|update|delete|create|alter))/,
    severity: 'critical'
  }
];

function detectSQLInjection(input) {
  const findings = [];
  for (const { name, pattern, severity } of suspiciousPatterns) {
    if (pattern.test(input)) {
      findings.push({ name, severity, input });
    }
  }
  return findings;
}

// 测试
console.log(detectSQLInjection('1 UNION SELECT password FROM users'));
// [{ name: 'UNION injection', severity: 'high' }]

console.log(detectSQLInjection('admin\'--'));
// [{ name: 'Comment injection', severity: 'medium' }]

console.log(detectSQLInjection('1; DROP TABLE users'));
// [{ name: 'Stacked query', severity: 'critical' }]

console.log(detectSQLInjection('1 AND 1=1'));
// [{ name: 'Boolean blind injection', severity: 'high' }]

console.log(detectSQLInjection('normal search query'));
// []

5.11 Node.js 服务端使用

// 文件名: server-side-usage.js
// 运行方式: node server-side-usage.js

/**
 * 在 Node.js 服务端使用断言处理文本
 */

const fs = require('fs');
const path = require('path');

// 1. 配置文件解析（INI 格式）
function parseINI(iniText) {
  const result = {};
  let currentSection = null;

  const lines = iniText.split('\n');
  for (const line of lines) {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith(';')) continue;

    // 节段标题 [section]
    const sectionMatch = trimmed.match(/(?<=^\[)[^\]]+(?=\]$)/);
    if (sectionMatch) {
      currentSection = sectionMatch[0];
      result[currentSection] = {};
      continue;
    }

    // 键值对 key = value
    const kvMatch = trimmed.match(/^([^=]+)=(.+)$/);
    if (kvMatch && currentSection) {
      const key = kvMatch[1].trim();
      const value = kvMatch[2].trim();
      result[currentSection][key] = value;
    }
  }

  return result;
}

const iniContent = `
[database]
host = localhost
port = 5432
username = admin

[server]
port = 3000
timeout = 30
`;

console.log(parseINI(iniContent));
// 输出:
// {
//   database: { host: 'localhost', port: '5432', username: 'admin' },
//   server: { port: '3000', timeout: '30' }
// }

// 2. Markdown 提取代码块
function extractCodeBlocks(md) {
  // 后行断言匹配 ```language 之后，先行断言匹配 ``` 之前
  const regex = /(?<=```[a-zA-Z]*\n)[\s\S]+?(?=```)/g;
  return md.match(regex) || [];
}

const markdown = `
Here is some code:

\`\`\`javascript
const x = 42;
console.log(x);
\`\`\`

And another:

\`\`\`python
print("hello")
\`\`\`
`;

console.log(extractCodeBlocks(markdown));
// 输出: ['const x = 42;\nconsole.log(x);\n', 'print("hello")\n']

// 3. 提取代码中的 TODO 注释
function extractTODOs(code) {
  // 匹配 TODO: 内容（直到行尾）
  const regex = /(?<=\/\/\s*TODO:\s).+$/gm;
  return code.match(regex) || [];
}

const sourceCode = `
function foo() {
  // TODO: implement error handling
  return null;
}

// TODO: add unit tests
function bar() {}
`;

console.log(extractTODOs(sourceCode));
// 输出: ['implement error handling', 'add unit tests']

5.12 浏览器端使用

// 文件名: browser-usage.js
// 运行方式: 在浏览器控制台运行

/**
 * 浏览器端使用断言处理 DOM 与用户输入
 */

// 1. 实时搜索高亮
function highlightSearch(text, query) {
  if (!query) return text;
  // 负向后行断言：不在 HTML 标签内
  // 负向先行断言：不在 HTML 标签内
  const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  const regex = new RegExp(`(?<=[^<>]|^)${escapedQuery}(?=[^<>]|$)`, 'gi');
  return text.replace(regex, match => `<mark>${match}</mark>`);
}

console.log(highlightSearch('<div>Hello World</div>', 'World'));
// 输出: '<div>Hello <mark>World</mark></div>'

// 2. 输入框验证
function validateEmail(email) {
  // 不使用断言，但展示对比
  const simpleRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return simpleRegex.test(email);
}

function validateEmailStrict(email) {
  // 使用断言确保用户名部分不含连续点号
  const regex = /^(?!.+\.\.)[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  return regex.test(email);
}

console.log(validateEmailStrict('user..name@example.com'));  // false (连续点号)
console.log(validateEmailStrict('user.name@example.com'));   // true

// 3. 自动补全输入
class AutoComplete {
  constructor(input, suggestions) {
    this.input = input;
    this.suggestions = suggestions;
    input.addEventListener('input', this.handleInput.bind(this));
  }

  handleInput(e) {
    const value = e.target.value;
    if (!value) return;

    // 使用断言匹配以输入值开头的建议
    const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    const regex = new RegExp(`^(?=${escapedValue}).+`, 'i');
    const matches = this.suggestions.filter(s => regex.test(s));

    if (matches.length > 0) {
      // 显示第一个匹配的补全
      const completion = matches[0];
      const newValue = value + completion.slice(value.length);
      this.input.value = newValue;
      this.input.setSelectionRange(value.length, newValue.length);
    }
  }
}

// 4. 代码高亮（简化版）
function highlightSyntax(code) {
  return code
    // 字符串
    .replace(/(?<=^|[^\w])("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g, '<span class="string">$1</span>')
    // 数字
    .replace(/(?<=^|[^\w])(\d+\.?\d*)/g, '<span class="number">$1</span>')
    // 关键字
    .replace(/(?<=^|[^\w])(const|let|var|function|return|if|else)(?=[^\w])/g, '<span class="keyword">$1</span>');
}

6. 对比分析

6.1 不同正则引擎的断言支持

关键差异分析：

1. Rust/Go 的限制：基于 DFA 的引擎为保证 $O(nm)$ 时间复杂度，不支持后行断言与回溯引用。需通过其他方式（如多步匹配）替代。

2. Python re vs regex：标准库 re 模块要求后行断言固定长度，第三方 regex 模块支持可变长度。

3. Java 的限制：java.util.regex 要求后行断言固定长度，且不支持后行断言中使用量词。

4. .NET 的优势：完整支持可变长度后行断言与嵌套断言，是功能最丰富的引擎之一。

6.2 断言 vs 非断言方案对比

以”提取价格数字”为例：

// 方案 1: 使用先行断言
const priceWithLookahead = (text) => text.match(/\d+(?=元)/g);

// 方案 2: 使用捕获组
const priceWithCapture = (text) => {
  const matches = [];
  const regex = /(\d+)元/g;
  let match;
  while ((match = regex.exec(text)) !== null) {
    matches.push(match[1]);
  }
  return matches;
};

// 方案 3: 使用字符串方法
const priceWithString = (text) => {
  return text
    .split('元')
    .slice(0, -1)
    .map(s => s.match(/\d+$/)?.[0])
    .filter(Boolean);
};

// 方案 4: 使用 replace 回调
const priceWithReplace = (text) => {
  const result = [];
  text.replace(/(\d+)元/g, (_, num) => { result.push(num); return ''; });
  return result;
};

结论：

• 简单场景优先使用断言，代码简洁。
• 复杂场景或对性能敏感时，使用捕获组。
• 不熟悉正则的团队成员，可考虑字符串方法。

6.3 断言 vs 捕获组的语义差异

const text = '价格：100元';

// 断言：match 返回的是数字本身
const withLookahead = text.match(/\d+(?=元)/);
console.log(withLookahead[0]); // '100'

// 捕获组：match 返回的是完整匹配 + 捕获组
const withCapture = text.match(/(\d+)元/);
console.log(withCapture[0]);    // '100元' (完整匹配)
console.log(withCapture[1]);    // '100' (捕获组)

核心差异：

• 断言：零宽，不消费字符，匹配结果是”纯目标”。
• 捕获组：消费字符，匹配结果是”目标+上下文”，需通过索引提取目标。

6.4 ECMAScript 各版本断言支持

6.5 框架对断言的使用

ESLint：

// ESLint 内部正则大量使用断言
// 例如：检测未使用的变量
const regex = /(?<=\bvar\s)\w+(?=\s*[;=])/g;

Babel：

// Babel 解析 JSX 时使用断言提取属性
const attrRegex = /(?<=\s)([\w-]+)(?==)/g;

Prettier：

// Prettier 格式化代码时使用断言识别模板字符串
const templateLiteralRegex = /(?<=`)[\s\S]+(?=`)/g;

7. 常见陷阱与反模式

7.1 陷阱：负向先行断言的贪婪问题

反模式：

// 错误：试图匹配不以 "px" 结尾的数字
const wrong = /\d+(?!px)/g;
console.log('12px 34em'.match(wrong));
// 期望: ['34']
// 实际: ['1', '34']
// 原因：负向先行断言只检查紧随其后的字符
// "12px" 中的 1 后面是 2，不是 px，所以 1 匹配

正确写法：

// 方法 1: 添加边界
const correct1 = /\b\d+(?!px\b)/g;
console.log('12px 34em'.match(correct1)); // ['34']

// 方法 2: 使用锚点
const correct2 = /\d+(?![\d]*px\b)/g;
console.log('12px 34em'.match(correct2)); // ['34']

// 方法 3: 显式排除
const correct3 = /(?:^|\D)(\d+)(?![\d]*px)/g;

7.2 陷阱：后行断言的固定长度限制

反模式（在某些引擎中）：

// Python re 模块中：以下正则会报错
// import re
// re.match(r'(?<=\d+)test', '123test')
// 错误: look-behind requires fixed-width pattern

// JavaScript ES2018+ 支持，但需注意兼容性
const regex = /(?<=\d+)test/;
console.log(regex.test('123test')); // true (V8)
// 在 Python re 中会报错

7.3 陷阱：嵌套断言导致回溯爆炸

反模式：

// 危险：嵌套断言 + 量词，可能导致回溯爆炸
const dangerous = /(?=(?=(?=a*)a*)a*)a/g;

// 测试：长字符串可能导致挂起
const longString = 'a'.repeat(100);
console.time('match');
longString.match(dangerous);
console.timeEnd('match');
// V8 会触发回溯上限，抛出异常或超时

正确做法：

// 简化正则，避免不必要嵌套
const safe = /a/g;

7.4 陷阱：断言中的捕获组行为

陷阱：

// 断言内的捕获组会被记录
const text = '2026-07-21';
const regex = /(?=(\d{4})-(\d{2})-(\d{2}))/;
const match = text.match(regex);
console.log(match);
// ['' (零宽匹配), '2026', '07', '21']
// 断言本身零宽，但内部捕获组仍被记录

这可能是期望行为，也可能不是。若不希望捕获，使用非捕获组 (?:...)：

const regex = /(?=(?:\d{4})-(?:\d{2})-(?:\d{2}))/;

7.5 陷阱：后行断言中的 ^ 锚点

反模式：

// 错误：后行断言中使用 ^ 不会按预期工作
const wrong = /(?<=^)\d+/g;
console.log('123\n456'.match(wrong));
// 期望: ['123', '456']
// 实际: ['123'] (仅第一行)
// 原因：^ 默认只匹配字符串开头

正确写法：

// 添加 m 标志使 ^ 匹配每行开头
const correct = /(?<=^)\d+/gm;
console.log('123\n456'.match(correct)); // ['123', '456']

// 或者使用更明确的写法
const alternative = /(?<=\n|^)\d+/g;

7.6 陷阱：Unicode 字符的断言

反模式：

// 错误：未考虑 Unicode 代理对
const wrong = /(?<=.)..(?=.)/g;
console.log('𝕏𝕐𝕑'.match(wrong));
// 期望: ['𝕐']
// 实际: 可能返回乱码
// 原因：𝕏 是代理对（两个 UTF-16 单元），. 默认不匹配完整字符

正确写法：

// 使用 u 标志
const correct = /(?<=.)..(?=.)/gu;
// 或者使用 Unicode Property Escapes
const better = /(?<=\p{L})\p{L}(?=\p{L})/gu;

7.7 陷阱：性能陷阱 - 全局搜索中的断言

反模式：

// 性能差：在长文本上使用含后行断言的全局搜索
const text = 'a'.repeat(1000000) + 'b';
console.time('match');
text.match(/(?<=a+)b/g);
console.timeEnd('match');
// 可能很慢，因为后行断言需在每个位置检查前缀

优化方案：

// 使用 indexOf 定位再断言
const idx = text.indexOf('b');
if (idx > 0 && /a+$/.test(text.slice(0, idx))) {
  console.log('found');
}

// 或使用更高效的正则
const optimized = /a+b/g;

7.8 陷阱：误用断言替代捕获组

反模式：

// 过度使用断言，导致正则难以理解
const overEngineered = /(?<=^)(?=\d)(?=\w+@)(?=\w+\.\w+).+/;
// 实际上可以简化
const simple = /^\w+@\w+\.\w+$/;

原则：断言用于”零宽上下文匹配”，而非简单的边界检查。若正则可读性下降，应简化。

8. 工程最佳实践

8.1 实践：断言使用决策树

在决定是否使用断言时，遵循以下决策树：

1. 是否需要"匹配但不消费"字符？
   ├─ 是 → 使用断言
   └─ 否 → 继续

2. 是否需要"上下文条件"？
   ├─ 是 → 使用断言
   └─ 否 → 使用普通匹配

3. 是否需要"多条件叠加"？
   ├─ 是 → 使用多个先行断言
   └─ 否 → 继续

4. 性能是否敏感？
   ├─ 是 → 避免后行断言，考虑替代方案
   └─ 否 → 可自由使用

5. 是否需要兼容旧引擎？
   ├─ 是 → 仅使用先行断言
   └─ 否 → 可使用后行断言

8.2 实践：性能测试基准

建立正则性能测试基准，确保断言使用不影响性能：

// 文件名: regex-benchmark.js

/**
 * 正则性能基准测试工具
 */
class RegexBenchmark {
  constructor() {
    this.results = [];
  }

  /**
   * 测量正则执行时间
   * @param {RegExp} regex - 正则表达式
   * @param {string} input - 输入字符串
   * @param {number} iterations - 迭代次数
   */
  measure(name, regex, input, iterations = 1000) {
    // 预热
    for (let i = 0; i < 100; i++) {
      regex.test(input);
    }

    const start = performance.now();
    for (let i = 0; i < iterations; i++) {
      regex.lastIndex = 0; // 重置全局正则
      regex.test(input);
    }
    const duration = performance.now() - start;

    this.results.push({
      name,
      iterations,
      duration,
      avgPerOp: duration / iterations,
      opsPerSec: (iterations / duration) * 1000
    });
  }

  report() {
    console.table(this.results);
  }
}

// 使用示例
const benchmark = new RegexBenchmark();
const text = '价格：100元，数量：50个'.repeat(100);

benchmark.measure('先行断言', /\d+(?=元)/g, text);
benchmark.measure('捕获组', /(\d+)元/g, text);
benchmark.measure('后行断言', /(?<=：)\d+/g, text);

benchmark.report();

8.3 实践：CI 集成正则检查

在 CI 流水线中集成正则安全检查：

// 文件名: scripts/regex-check.mjs

/**
 * CI 正则安全检查脚本
 * 检测代码中可能不安全的正则表达式
 */

import { readFileSync, readdirSync } from 'fs';
import { join, extname } from 'path';

const DANGEROUS_PATTERNS = [
  // 嵌套量词
  { name: 'nested-quantifiers', pattern: /(\+|\*|\?|\{)\s*(\+|\*|\?|\{)/ },
  // 过深的断言嵌套
  { name: 'deep-nested-assertion', pattern: /\(\?=(?=[^)]*\(\?=)/ },
  // 回溯风险模式
  { name: 'backtracking-risk', pattern: /(\w+\+)+\w+/ }
];

function checkFile(filePath) {
  const content = readFileSync(filePath, 'utf8');
  const findings = [];

  // 提取所有正则字面量
  const regexLiterals = content.match(/\/[^\s/]+\/[gimsuy]*/g) || [];

  for (const literal of regexLiterals) {
    for (const { name, pattern } of DANGEROUS_PATTERNS) {
      if (pattern.test(literal)) {
        findings.push({ file: filePath, regex: literal, issue: name });
      }
    }
  }

  return findings;
}

function scanDirectory(dir) {
  const findings = [];
  const entries = readdirSync(dir, { withFileTypes: true });

  for (const entry of entries) {
    const fullPath = join(dir, entry.name);
    if (entry.isDirectory()) {
      if (entry.name !== 'node_modules' && entry.name !== '.git') {
        findings.push(...scanDirectory(fullPath));
      }
    } else if (['.js', '.ts', '.jsx', '.tsx'].includes(extname(entry.name))) {
      findings.push(...checkFile(fullPath));
    }
  }

  return findings;
}

const findings = scanDirectory('./src');
if (findings.length > 0) {
  console.error('正则安全检查未通过:');
  console.table(findings);
  process.exit(1);
} else {
  console.log('正则安全检查通过');
}

8.4 实践：可读性优化

通过注释与变量命名提升正则可读性：

// 反模式：难以理解的正则
const bad = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$]).{8,}$/;

// 实践 1: 添加注释
const passwordRegex = /^
  (?=.*[a-z])           // 至少一个小写字母
  (?=.*[A-Z])           // 至少一个大写字母
  (?=.*\d)              // 至少一个数字
  (?=.*[!@#$%^&*])      // 至少一个特殊字符
  .{8,}                 // 至少 8 位
$/;

// 实践 2: 使用 RegExp 构造函数 + 注释
const patterns = {
  lowercase: '(?=.*[a-z])',
  uppercase: '(?=.*[A-Z])',
  digit: '(?=.*\\d)',
  special: '(?=.*[!@#$%^&*])',
  length: '.{8,}'
};
const passwordRegex = new RegExp(
  '^' + patterns.lowercase + patterns.uppercase + patterns.digit + patterns.special + patterns.length + '$'
);

// 实践 3: 封装为函数
function createPasswordRegex(options = {}) {
  const {
    minLength = 8,
    requireLower = true,
    requireUpper = true,
    requireDigit = true,
    requireSpecial = true
  } = options;

  const assertions = [
    requireLower && '(?=.*[a-z])',
    requireUpper && '(?=.*[A-Z])',
    requireDigit && '(?=.*\\d)',
    requireSpecial && '(?=.*[!@#$%^&*])'
  ].filter(Boolean).join('');

  return new RegExp(`^${assertions}.{${minLength},}$`);
}

8.5 实践：单元测试覆盖

为正则表达式编写充分的单元测试：

// 文件名: regex.test.js

const assert = require('assert');

describe('密码强度正则', () => {
  const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$/;

  it('应接受强密码', () => {
    assert.ok(passwordRegex.test('Abc12345!'));
    assert.ok(passwordRegex.test('P@ssw0rd'));
  });

  it('应拒绝缺少小写字母的密码', () => {
    assert.ok(!passwordRegex.test('ABC12345!'));
  });

  it('应拒绝缺少大写字母的密码', () => {
    assert.ok(!passwordRegex.test('abc12345!'));
  });

  it('应拒绝缺少数字的密码', () => {
    assert.ok(!passwordRegex.test('Abcdefgh!'));
  });

  it('应拒绝缺少特殊字符的密码', () => {
    assert.ok(!passwordRegex.test('Abc12345'));
  });

  it('应拒绝长度不足的密码', () => {
    assert.ok(!passwordRegex.test('Ab1!'));
  });

  it('应处理边界情况', () => {
    assert.ok(!passwordRegex.test(''));
    assert.ok(!passwordRegex.test(null));
  });
});

describe('CSV 解析正则', () => {
  const csvRegex = /,(?=(?:[^"]*"[^"]*")*[^"]*$)/;

  it('应正确分割简单 CSV', () => {
    const result = 'a,b,c'.split(csvRegex);
    assert.deepStrictEqual(result, ['a', 'b', 'c']);
  });

  it('应正确处理引号内的逗号', () => {
    const result = 'a,"b,c",d'.split(csvRegex);
    assert.deepStrictEqual(result, ['a', '"b,c"', 'd']);
  });

  it('应处理转义引号', () => {
    const result = '"a""b",c'.split(csvRegex);
    assert.deepStrictEqual(result, ['"a""b"', 'c']);
  });
});

8.6 实践：国际化与 Unicode 支持

// 文件名: i18n-regex.js

/**
 * 支持 Unicode 的断言正则
 */

// 1. 匹配汉字
const hanRegex = /\p{Han}/u;
console.log(hanRegex.test('中'));  // true
console.log(hanRegex.test('a'));   // false

// 2. 匹配 emoji
const emojiRegex = /\p{Emoji}/u;
console.log(emojiRegex.test('😀'));  // true
console.log(emojiRegex.test('a'));   // false

// 3. 中英文混排加空格
function addSpaceCJK(text) {
  return text
    .replace(/(?<=[\p{L}\p{N}])(?=[\p{Han}])/gu, ' ')
    .replace(/(?<=[\p{Han}])(?=[\p{L}\p{N}])/gu, ' ');
}

console.log(addSpaceCJK('Hello世界World123'));
// 'Hello 世界 World 123'

// 4. 匹配 Unicode 字母
const letterRegex = /^\p{L}+$/u;
console.log(letterRegex.test('Hello'));    // true
console.log(letterRegex.test('你好'));      // true
console.log(letterRegex.test('Hello123')); // false

// 5. 匹配数字（含其他书写系统）
const numberRegex = /^\p{N}+$/u;
console.log(numberRegex.test('123'));           // true
console.log(numberRegex.test('一二三'));         // false (汉字数字属 Han 类)
console.log(numberRegex.test('۱۲۳'));           // true (阿拉伯-印度数字)