正则表达式完全入门与常用技巧

会说码库网技术团队 2026年6月 编程教程 阅读约15分钟

正则表达式语法基础：字符、量词与转义（附PCRE2标准）

换个角度看，正则表达式（Regular Expression，简称 Regex）本质上就是一门专门用来处理字符串的微型编程语言。你别看它有时候写出来像乱码，其实只要搞清楚它的底层逻辑，这玩意儿比你看那些厚厚的技术文档要直观得多。

咱们得先聊聊标准。很多新手会问：“正则有没有版本号啊？” 其实正则本身没有统一的版本，它是一套标准，由 IEEE POSIX 定义，然后各大编程语言自己去实现。目前咱们在市面上看到的主流实现，基本都是基于 Perl 5.34+ 的 PCRE2 标准。这个 PCRE2 的最新稳定版是 10.42（2022年发布的），像 PHP、Apache 这些大家伙都在用它。所以咱们下面聊的语法，默认都是基于这个 PCRE2 标准来的，保证你在大多数环境下都能跑通。

字符匹配：从“点”开始

最基础的肯定是匹配字符。最简单的就是abc匹配abc。但咱们不可能每次都写死，这时候就需要元字符。

反斜杠 \ 在正则里是个“转义符”。如果你想匹配一个真实的 . 或者 * 怎么办？那就得在前面加个 \，比如 \. 就是匹配那个小数点，而不是“任意字符”。

量词：控制次数

光匹配字符不够，你还得控制它出现几次。这就是量词的作用：

字符类与转义

当你想匹配一组特定的字符时，就用方括号 []。比如 [aeiou] 匹配任意一个元音字母。你还可以取反，[^0-9] 就是匹配非数字。

这里有个⚡ 效率提示：在写正则的时候，特别是涉及到路径或者特殊符号，千万别忘了转义。比如你想匹配一个文件后缀 .js，如果你写成 .js，那个点会匹配任意字符，万一有个 xjs 也被匹配上了，那就尴尬了。一定要写成 \.js。

下面是一段 Python 代码，演示一下基础语法的使用。咱们用 Python 的 re 模块，它底层就是基于 PCRE 的那套逻辑。

import re # 定义一个测试字符串 text = "我的电话是123-4567，邮箱是test@example.com，还有个备用号9876543。" # 1. 匹配任意数字（使用 \d+） # 这里 \d+ 表示匹配连续的数字 pattern_digits = r"\d+" digits_found = re.findall(pattern_digits, text) print(f"找到的数字: {digits_found}") # 输出: ['123', '4567', '9876543'] # 2. 匹配连字符（注意转义，虽然这里-在[]外不需要，但展示一下概念） # 匹配 "123-4567" 这种格式 pattern_phone_simple = r"\d{3}-\d{4}" phone_found = re.search(pattern_phone_simple, text) if phone_found: print(f"找到的简单电话: {phone_found.group()}") # 输出: 123-4567 # 3. 字符类演示：匹配元音字母 vowels = "hello world" pattern_vowels = r"[aeiou]" vowels_found = re.findall(pattern_vowels, vowels) print(f"找到的元音: {vowels_found}") # 输出: ['e', 'o', 'o']

实战演练：表单验证与数据清洗（邮箱、手机号、日志提取）

做全栈开发，正则最爽的地方就是能直接用在表单验证和数据清洗上。简单来说，这就是把一堆乱七八糟的字符串，用规则“过滤”出你想要的东西。

表单验证：别再写死手机号了

很多新手写手机号正则，上来就写 1\d{10}。这太粗糙了！现在号段早就放开了。虽然咱们不需要把 199 号段这种细节背下来，但至少得知道现在的手机号是 11 位，且第二位是 3-9 之间的数字（因为 1 开头，第二位没有 0、1、2 的号段）。

⚡ 效率提示：在真实项目中，正则验证只是第一道防线。比如手机号，正则过了，还得发个短信验证码确认。所以正则不用写得过于变态，够用就行，别把用户挡在门外。

邮箱验证：经典案例

邮箱验证是正则里的“Hello World”。标准邮箱格式太复杂了（RFC 5322 标准），咱们平时用的都是简化版。核心逻辑就是：用户名@域名.后缀。

数据清洗：从日志里挖东西

除了验证，正则最强大的地方在于提取。比如你有一堆服务器日志，想提取出所有的 IP 地址或者访问路径，用正则比写一堆 if-else 要快得多。

下面这个例子，咱们用 JavaScript 来演示，因为前端表单验证和 Node.js 后端清洗数据都很常见。

// 1. 手机号验证（考虑主流号段） // 1[3-9] 表示第一位是1，第二位是3到9 // \d{9} 表示后面跟9个数字 const phoneRegex = /^1[3-9]\d{9}$/; console.log(phoneRegex.test("13800138000")); // true console.log(phoneRegex.test("12345678901")); // false (第二位2不合法) console.log(phoneRegex.test("1380013800")); // false (只有10位) // 2. 邮箱验证（简化版，覆盖99%场景） // ^ 和 $ 表示严格匹配整个字符串 const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/; console.log(emailRegex.test("user.name+tag@example.co.uk")); // true console.log(emailRegex.test("invalid-email@")); // false // 3. 数据清洗：从日志中提取关键信息 const logData = ` 127.0.0.1 - - [10/Oct/2023:13:55:36] "GET /api/user HTTP/1.1" 200 192.168.1.1 - - [10/Oct/2023:13:56:40] "POST /api/login HTTP/1.1" 401 `; // 提取 IP 地址和请求路径 // (\d+\.\d+\.\d+\.\d+) 捕获IP // "([A-Z]+) ([^ ]+) 捕获请求方法和路径 const logRegex = /(\d+\.\d+\.\d+\.\d+).*?"([A-Z]+) ([^ ]+)/g; let match; while ((match = logRegex.exec(logData)) !== null) { console.log(`IP: ${match[1]}, Method: ${match[2]}, Path: ${match[3]}`); } // 输出: // IP: 127.0.0.1, Method: GET, Path: /api/user // IP: 192.168.1.1, Method: POST, Path: /api/login

看到没，用正则处理日志，简直就是降维打击。不用去 split 逗号或者空格，直接定义规则，一把梭哈。

进阶技巧：分组捕获、贪婪/惰性匹配与零宽断言详解

当你觉得正则不过如此的时候，说明你还没遇到复杂的文本处理需求。进阶技巧能让你从“会用”变成“大神”。

分组与捕获：给匹配的内容“打标签”

用括号 () 括起来的部分，就是分组。它有两个作用：

在 PCRE2 标准中，如果你用了 (?:...) 这种写法，那就是非捕获分组。换个角度看，就是我想用括号来组织逻辑，但不想把这部分内容单独存下来，这样能省点内存，性能稍微好一丢丢。

贪婪与惰性：到底是“能吃多少吃多少”还是“够吃就行”？

这是新手最容易避雷经验的地方。

也吃掉，直到最后。
  • 惰性匹配（Lazy）：在量词后面加个 ?，比如 *?、+?。意思是“匹配到第一个符合条件的就停”。用 <.*?> 就能精准匹配到
    和
    两个标签。

    • 零宽断言：只匹配位置，不匹配字符

    这个听起来有点玄学，其实很实用。比如你想匹配一个单词，但这个单词后面必须跟着某个特定字符（比如 @），但你又不希望这个特定字符出现在匹配结果里。这时候就用前瞻 (?=...)。

    值得留意的是，零宽断言不匹配任何字符，它只匹配一个“位置”。就像你在排队，它只检查你后面是不是站着个穿红衣服的人，但它不把那个人算进你的队伍里。

    🔧 实战技巧：遇到复杂的嵌套结构（比如 HTML），别硬上正则。虽然零宽断言很牛，但解析 HTML 最好还是用专门的解析器（Parser），比如 Python 的 BeautifulSoup。正则适合处理非嵌套的、有固定格式的文本，否则容易写出导致 Catastrophic Backtracking（灾难性回溯） 的正则，把服务器 CPU 跑满（这就是 ReDoS 攻击的原理）。

    看代码，咱们用 Python 演示一下这几个高级特性：

    import re text = "价格：100元，库存：50件，价格：200元" # 1. 贪婪 vs 惰性 html = "<div>Hello</div><div>World</div>" # 贪婪匹配：会匹配从第一个 <div> 到最后一个 </div> greedy_pattern = r"<div>.*</div>" # 惰性匹配：匹配到第一个 </div> 就停 lazy_pattern = r"<div>.*?</div>" print(f"贪婪结果: {re.search(greedy_pattern, html).group()}") # 输出: <div>Hello</div><div>World</div> print(f"惰性结果: {re.search(lazy_pattern, html).group()}") # 输出: <div>Hello</div> # 2. 分组捕获与命名分组 # 提取价格和库存 # (?P<name>...) 是 Python 的命名分组写法，PCRE2 也支持类似语法 pattern_capture = r"价格：(?P<price>\d+)元，库存：(?P<stock>\d+)件" match = re.search(pattern_capture, text) if match: print(f"价格: {match.group('price')}, 库存: {match.group('stock')}") # 也可以直接用序号 print(f"完整匹配: {match.group(0)}") # 3. 零宽断言 # 需求：匹配后面跟着 "元" 的数字 text_price = "100元 200美元 300元" # 正向前瞻：匹配数字，且后面必须跟着 "元" assert_pattern = r"\d+(?=元)" print(f"后面是'元'的数字: {re.findall(assert_pattern, text_price)}") # 输出: ['100', '300'] # 需求：匹配前面是 "价格：" 的数字 # 正向后顾：匹配数字，且前面必须是 "价格：" # 注意：JS 不支持后顾，但 Python 和 PCRE2 支持 lookbehind_pattern = r"(?<=价格：)\d+" print(f"前面是'价格：'的数字: {re.findall(lookbehind_pattern, text)}") # 输出: ['100', '200']

    4. 跨语言差异与性能优化：如何避免ReDoS攻击与回溯陷阱

    换个角度看，很多新手以为正则是一门通用的语言，写出来在哪都能跑。这绝对是个大坑！虽然正则标准由 IEEE POSIX 定义，但现实是各个编程语言在实现上都有自己的“方言”。比如你写惯了 JavaScript，突然去写 Python 的 re 模块，可能会发现很多高级特性用不了，或者匹配结果让你一脸懵逼。

    那些年我们踩过的跨语言坑

    最典型的差异就在零宽断言的支持上。JavaScript 在 ES2018 之前，根本不支持后顾（Lookbehind），也就是 (?<=...) 这种写法。如果你要在前端处理复杂的字符串切片，以前只能靠分组捕获，写出来的表达式丑得要命。

    来看个例子，我们要匹配 price: 100 中的 100，但不想要前面的 price: 。

    在 Python 中（支持后顾）：

    import re text = "price: 100, discount: 20" # 后顾断言，匹配前面是 "price: " 的数字 pattern = r"(?<=price: )\d+" result = re.search(pattern, text) print(result.group()) # 输出: 100

    在老版本 JS 或者某些不支持后顾的环境里，你可能得这么写：

    const text = "price: 100, discount: 20"; // 不支持后顾，只能用分组捕获 const pattern = /price: (\d+)/; const match = text.match(pattern); if (match) { console.log(match[1]); // 输出: 100 }

    关键点：PCRE2 10.42（2022年发布）是目前很多现代语言底层用的引擎，它支持递归匹配和非常复杂的断言，但 JavaScript 的正则引擎是基于 ECMAScript 标准的，两者在底层逻辑上完全不同。比如 JavaScript 里没有“命名组引用”的某些高级玩法，或者 s 修饰符（dotAll 模式）的支持时间也不一样。

    回溯陷阱与 ReDoS 攻击

    这部分是重中之重，直接关系到你服务器的生死。换个角度看，正则引擎的工作方式有两种：一种是确定性有限自动机（DFA），一种是非确定性有限自动机（NFA）。大部分编程语言（Java, Python, JS, PHP）用的都是 NFA。

    NFA 有个特点，它会“试错”，也就是回溯。当你的正则里有嵌套量词（比如 (a+)+）时，如果输入的字符串稍微变态一点（比如 aaaaaaaaaaaaaaaaaaaaaaaaaaaaX），引擎就会陷入疯狂的回溯计算中。

    来个真实的“灾难级”代码示例（千万别在生产环境跑）：

    import re import time # 这是一个典型的会造成 Catastrophic Backtracking 的正则 # 它试图匹配一个或多个 'a'，然后重复这个组一次或多次 evil_pattern = re.compile(r'(a+)+$') # 正常的字符串，匹配很快 good_text = "aaaaaaaaaa" # 恶意构造的字符串，结尾有个不匹配的字符 evil_text = "aaaaaaaaaaX" print("开始匹配正常文本...") start = time.time() evil_pattern.match(good_text) print(f"正常文本耗时: {time.time() - start:.6f} 秒") print("开始匹配恶意文本（回溯地狱）...") start = time.time() try: # 这可能会导致 CPU 飙升，甚至卡死 evil_pattern.match(evil_text) except Exception as e: print(e) print(f"恶意文本耗时: {time.time() - start:.6f} 秒")

    当你运行这个代码时，你会发现匹配 evil_text 的时间会指数级上升。这就是 ReDoS（正则拒绝服务攻击）。攻击者只需要提交一个这样的字符串，就能把你服务器的 CPU 打满。

    如何避免回溯陷阱

    🔧 实战技巧：在写正则做表单验证时，一定要给输入长度做限制。比如验证手机号，别直接上正则，先判断字符串长度是不是 11 位。另外，对于复杂的文本解析（比如解析 HTML），别用正则！这是社区里吵得最凶的话题之一。HTML 不是正则语言，用正则去解析 HTML 不仅容易出 Bug，还容易引发 ReDoS。老老实实上解析器（Parser），比如 Python 的 BeautifulSoup 或者 JS 的 DOMParser。

    ---

    5. 2024趋势：AI辅助生成正则与可视化调试工具推荐

    到了 2024 年，如果你还在对着一堆符号死磕，那真的有点“原始”了。现在的技术趋势是让写正则变得更人性化，甚至不需要你亲手写。作为写了 5 年全栈的开发者，我深刻感觉到工具链的进化对效率的提升有多恐怖。

    AI 辅助生成：从“人肉翻译”到“自然语言”

    以前我们要写一个匹配“除了空格和换行之外的所有字符”的正则，得去查手册看是不是用 \S 还是 . 加上修饰符。现在？直接问 AI。

    现在的 LLM（大语言模型） 已经非常擅长这个了。你只需要描述需求，它就能生成精准的正则，甚至还能帮你考虑跨语言的差异。

    实战场景：我想写一个 Java 用的正则，用来从日志里提取用户 ID 和 时间戳，日志格式是 [2023-10-01 12:00:00] UserID: 12345。

    直接问 AI 的 Prompt：

    提示："帮我写一个 Java 兼容的正则表达式，从字符串 `[2023-10-01 12:00:00] UserID: 12345` 中提取时间戳和 UserID。要求使用命名捕获组。"

    AI 生成的代码（Java 示例）：

    import java.util.regex.Matcher; import java.util.regex.Pattern; public class LogParser { public static void main(String[] args) { String log = "[2023-10-01 12:00:00] UserID: 12345"; // AI 生成的正则，使用了命名组 <timestamp> 和 <userId> // 注意 Java 字符串里反斜杠需要转义 String regex = "\\[(?<timestamp>\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2})] UserID: (?<userId>\\d+)"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(log); if (matcher.find()) { String timestamp = matcher.group("timestamp"); String userId = matcher.group("userId"); System.out.println("时间戳: " + timestamp); // 输出: 2023-10-01 12:00:00 System.out.println("用户ID: " + userId); // 输出: 12345 } } }

    AI 不仅能生成代码，还能解释为什么这么写。比如它会告诉你 Java 里中括号 [ 需要转义，或者提醒你 PCRE2 10.42 支持的一些新语法在 Java 里可能用不了。这比你自己去 Stack Overflow 翻半天快多了。

    可视化调试工具：把“黑盒”打开

    正则的另一大痛点是调试。一串乱码，你根本不知道它匹配到了哪，或者为什么没匹配上。2024 年的趋势是 IDE 集成实时解释 和 Web 端可视化工具。

    我强烈推荐大家试试 Regex101 或者 RegExr。这些工具现在都支持把匹配过程像动画一样展示出来。

    📖 学习建议：如果你在用 VS Code 或者 WebStorm，一定要装正则可视化插件。

    实操演示：

    假设我们有个正则 (\d{3})-(\d{4})-(\d{4})，用来匹配电话号码。

    我们可以在 Regex101 上输入：

    你会看到右侧直接解析出了三个捕获组：

    而且，现在的工具还能预测性能。如果它检测到你的正则可能存在 Catastrophic Backtracking 风险，会直接在旁边给你标红警告。这在 2024 年已经是标配功能了。

    性能与未来：WASM 与流式匹配

    还有一个比较硬核的趋势，就是 WebAssembly (WASM) 的移植。以前高性能的正则引擎都跑在服务端（比如 C++ 写的 PCRE2），现在通过 WASM，浏览器端也能跑高性能的正则了。

    这意味着什么？意味着你可以在前端网页上直接处理几百万行的日志文件，而不用担心把浏览器卡死。像 Rust 编写的 regex crate 已经被编译成 WASM，性能比原生的 JavaScript 正则快了好几倍。

    代码示例（伪概念，展示 WASM 正则的潜力）：

    // 假设我们引入了一个基于 WASM 的高性能正则库 // import { WasmRegex } from 'high-perf-regex-wasm'; // 模拟一个超大的 DNA 序列字符串（几百万个字符） const dnaSequence = "ATCGATCG...".repeat(100000); // 传统的 JS 正则可能直接卡死或耗时很久 // const jsRegex = /A(T|C|G)+G/; // 使用 WASM 引擎（概念代码） // const wasmRegex = new WasmRegex("A(T|C|G)+G", "g"); // const matches = wasmRegex.exec(dnaSequence); // 流式匹配，不会爆栈

    简单来说，未来的正则不仅仅是用来验证邮箱格式，它会在生物信息学（DNA序列匹配）和大数据日志分析中发挥更大作用。作为开发者，我们要拥抱这些变化，利用 AI 生成初稿，利用可视化工具调试细节，最后再关注底层的性能优化。别再死记硬背那些符号了，工具才是第一生产力。