算法精讲--正则表达式（一）：入门必备语法算法精讲--正则表达式（一）：入门必备语法 🚀 引言：正则表达式到底是个啥？

算法精讲--正则表达式（一）：入门必备语法 🚀

千里之行，始于足下。掌握正则表达式，让文本处理事半功倍！

—— 作者：无限大

推荐阅读时间：25 分钟

适用人群：编程初学者、数据分析师、Web 开发者

引言：正则表达式到底是个啥？🤔

你是否也曾遇到过这样的场景：老板甩给你一个包含 1000 个邮箱的 Excel 表格，让你找出所有以"@company.com"结尾的邮箱？或者你想在一堆文本中快速找到所有的手机号？这时候，如果你还在用 Ctrl+F 逐个查找，那可就太 out 啦！🙅‍♂️

正则表达式（Regular Expression） 就是为了解决这些问题而生的！它能让你用最简洁的方式，完成复杂的文本匹配和处理任务。无论是数据清洗、文本验证还是信息提取，正则表达式都能帮你事半功倍。它不是某个编程语言的专利，而是一种通用的文本匹配模式，可以在 Python、JavaScript、Java 等几乎所有编程语言中使用。

正则表达式的语法虽然看起来有点晦涩，但只要掌握了基本规则，就能轻松驾驭。它就像是文本处理的“银弹”，功能强大，灵活多变。

今天，就让我们一起揭开正则表达式的神秘面纱，看看这个强大的文本处理工具到底有多酷！😎

正则表达式基础：入门必备语法 📚

正则表达式的基础语法是构建复杂模式的基石。本节将通过丰富的实例和详细解释，帮助你掌握正则表达式的核心概念，为后续学习打下坚实基础。

1 字符匹配：最基本的操作

正则表达式最基本的功能就是匹配字符。比如，如果你想匹配字符串"hello"，直接写 hello就可以了。这种精确匹配在验证固定格式的文本时非常有用，例如验证用户输入的特定命令或关键词。

但是，正则表达式的真正强大之处在于它能匹配一类字符，而不仅仅是固定的字符。这些特殊的匹配规则被称为元字符（Metacharacters），它们赋予了正则表达式强大的模式匹配能力。

元字符简介

元字符是在正则表达式中具有特殊含义的字符，它们用于定义匹配规则。掌握这些元字符是使用正则表达式的第一步，下方是一些常见的元字符和其详解。

常用字符匹配元字符详解

元字符	描述	例子	匹配结果	实际应用场景
`.`	匹配除换行符外的任意单个字符，相当于通配符	`h.t`	hat, hot, h*t, h@t, h1t	模糊搜索，如查找"h 开头 t 结尾的 3 个字母单词"
`[ ]`	匹配括号内的任意一个字符，字符集可以指定范围，如[a-z]表示所有小写字母	`[abc]`	a, b, 或 c	验证性别（[男女性]）或简单选项匹配
`[^ ]`	匹配不在括号内的任意一个字符，^表示取反	`[^0-9]`	除数字外的任意字符，如 a, B, @, 空格	过滤文本中的非数字字符
`\d`	匹配数字字符，等价于 `[0-9]`	`\d{3}`	123, 456, 789	匹配三位数，如验证码或区号
`\D`	匹配非数字字符，等价于 `[^0-9]`	`\D+`	abc, 张三, !@#	提取文本中的纯字母部分
`\w`	匹配字母、数字或下划线，等价于 `[a-zA-Z0-9_]`	`user\w+`	username, user123, user_name	匹配用户名（通常包含字母、数字和下划线）
`\W`	匹配非字母、数字或下划线，等价于 `[^a-zA-Z0-9_]`	`\W`	@, #, 空格, ￥	识别文本中的特殊符号
`\s`	匹配空白字符，包括空格、制表符(\t)、换行符(\n)、回车符(\r)等	`hello\s+world`	hello world, hello\tworld, hello\nworld	匹配带有空白分隔的短语
`\S`	匹配非空白字符	`\S{5}`	hello, world, 12345, Abc12	匹配长度为 5 的非空白字符串

字符集高级用法

字符集 []支持多种高级用法，让匹配更加灵活：

范围表示：使用连字符 -表示字符范围
- [a-z]：匹配任意小写字母
- [A-Z]：匹配任意大写字母
- [0-9]：匹配任意数字
- [a-zA-Z0-9]：匹配任意字母或数字
- [\s\S]:匹配所有字符，包括换行符
组合匹配：在一个字符集中组合多个范围
- [a-zA-Z_]：匹配字母和下划线
- [0-9a-fA-F]：匹配十六进制数字
排除匹配：使用 ^在字符集开头表示排除
- [^aeiou]：匹配非元音字母
- [^0-9a-zA-Z]：匹配特殊符号

注意：正则表达式中的 ^ 在不同位置作用不同

在字符组 [] 内且为首字符时：表示排除指定字符。例如 [^abc] 匹配除 "a"、"b"、"c" 外的任意单个字符。

关键条件：必须紧贴左方括号 [ 后（如 [^）才生效。

若不在首位（如 [a^b]），则 ^ 被视为普通字符。

在 [] 外或正则表达式开头时：表示匹配字符串起始位置（定位符）。例如 ^abc 匹配以 "abc" 开头的字符串。

结论：^ 的排除作用仅限在字符组 [] 内且为首字符时；其他位置均表示字符串起始位置。

实用示例

示例 1：验证手机号码

中国手机号码通常是 11 位数字，可以使用 \d{11}来匹配：

// 创建手机号码验证正则表达式
// ^ 表示字符串开始位置，$ 表示字符串结束位置
// \d{11} 表示匹配 exactly 11位数字
// 整个表达式确保输入是纯11位数字，无其他字符
const phoneRegex = /^\d{11}$/;

// 测试合法手机号：11位数字，格式正确
console.log(phoneRegex.test("13812345678")); // true

// 测试不合法手机号：仅9位数字，长度不足
console.log(phoneRegex.test("123456789")); // false (位数不足)

示例 2：匹配邮箱地址中的用户名部分

邮箱地址的用户名通常允许字母、数字、点、下划线、连字符和加号，可以使用 [a-zA-Z0-9._+-]+来匹配：

// 导入Python正则表达式模块
import re

// 定义一个包含复杂用户名的邮箱地址
email = "john.doe+tag@example.com"

// 使用正则表达式提取用户名部分
// ^ 表示从字符串开始匹配
// [a-zA-Z0-9._+-] 匹配字母、数字、点、下划线、连字符和加号
//第二个在[]外部的 + 表示匹配前面的字符集一次或多次
username = re.search(r'^[a-zA-Z0-9._+-]+', email).group()

// 输出提取到的用户名
print(username)  # 输出: john.doe+tag

示例 3：提取 HTML 标签内容

使用 .匹配任意字符，*匹配零次或多次，可以提取 HTML 标签中的内容：

// 定义包含HTML标题标签的字符串
String html = "<title>正则表达式教程</title>";

// 编译正则表达式模式
// <title> 匹配开始标签
// (.*) 使用捕获组捕获任意字符(除换行符)零次或多次
// </title> 匹配结束标签
Pattern pattern = Pattern.compile("<title>(.*)</title>");

// 创建匹配器对象，用于在输入字符串中查找模式
Matcher matcher = pattern.matcher(html);

// 如果找到匹配项
if (matcher.find()) {
    // 输出第一个捕获组的内容（即<title>和</title>之间的文本）
    System.out.println(matcher.group(1)); // 输出: 正则表达式教程
}

通过这些元字符，我们可以构建出灵活而强大的匹配模式，解决各种文本处理问题。理解并熟练运用这些基础元字符是掌握正则表达式的第一步。

2 量词：控制匹配次数 ⏳

量词（Quantifiers）是正则表达式中控制匹配次数的核心机制，它们允许我们精确指定某个字符、字符集或子表达式应该出现的次数范围。掌握量词的使用是从基础正则表达式迈向高级应用的关键一步，能够极大提升文本处理的效率和准确性。

想象一下，如果没有量词，要匹配一个 8-20 位的密码，你可能需要写出像[a-zA-Z0-9][a-zA-Z0-9][a-zA-Z0-9]...这样冗长的表达式，而且无法灵活适应长度变化。有了量词，这一切变得简单而优雅。

在实际应用中，我们经常需要处理重复出现的模式：验证 11 位手机号码、提取 6 位验证码、匹配可变长度的用户名等。量词正是为解决这些问题而生，它们定义了正则表达式中元素的重复规则。

常用量词详解

正则表达式提供了多种量词来满足不同的匹配需求，从精确次数到模糊范围，从贪婪匹配到懒惰匹配，形成了一套完整的次数控制体系：

量词	描述	例子	匹配结果	不匹配结果
`*`	匹配前面的子表达式零次或多次（贪婪模式），等价于 `{0,}`	`ab*c`	ac, abc, abbc, abbbc...	aac, adc
`+`	匹配前面的子表达式一次或多次（贪婪模式），等价于 `{1,}`	`ab+c`	abc, abbc, abbbc...	ac, aabbc (中间有其他字符)
`?`	匹配前面的子表达式零次或一次（贪婪模式），等价于 `{0,1}`	`ab?c`	ac, abc	abbc, aabc
`{n}`	匹配前面的子表达式恰好 n 次	`ab{2}c`	abbc	abc, abbbc
`{n,}`	匹配前面的子表达式至少 n 次	`ab{2,}c`	abbc, abbbc, abbbbc...	abc
`{n,m}`	匹配前面的子表达式至少 n 次，至多 m 次	`ab{2,3}c`	abbc, abbbc	abc, abbbbc

同时注意：

在正则表达式中，当量词（如 *、+、?、{n}）出现在字符组 [] 内部时，它们仅表示普通字符本身，而非量词功能。

一、字符组 [] 的核心特性

原子性匹配单元
字符组 [] 在正则引擎中被视为单个匹配单元，其功能是匹配方括号内的任意一个字符（例如 [abc] 匹配 "a" 或 "b" 或 "c"），而非一个可重复的子模式。因此，其内部不允许出现控制重复行为的量词语法（如 a*）。

元字符语义的失效
在 [] 内部，大多数元字符（包括量词）会失去特殊含义，仅作为字面字符处理。例如：

[*] 匹配字符 * 本身，而非"重复前项"。

[+?] 匹配字符 + 或 ?，而非"至少一次"或"零次或一次"。

例外：字符 ^（在首位时表示排除）、-（表示范围）、]（结束符）需特殊处理，其他符号默认按字面解析。

二、量词在 [] 内外的语义对比

场景 量词示例 含义 证据来源
在 [] 内部 [a*] 匹配字符 a 或 *
[+{2}] 匹配 +、{、2、}之一
在 [] 外部 a* 匹配 a 出现 0 次或多次
(ab)+ 匹配子模式 ab 至少一次

三、技术原理解析

语法解析优先级
正则引擎在解析时，会优先识别 [] 作为字符组的边界。其内部内容被解析为字符列表，而非可量化的子表达式。量词需作用于其左侧的完整单元（如单个字符、分组 () 或字符类 \w 等），而 [] 本身已是独立单元，内部无法再嵌套量词控制的子结构。

设计意图
字符组的核心目的是定义候选字符集合（如 [0-9] 匹配数字），而非描述重复模式。重复行为需通过外部量词实现，例如：

正确：[0-9]+ → 匹配连续数字（[] 定义字符集，+ 控制重复）。

错误：[0-9+] → 匹配数字或 + 字符，无重复功能。

四、验证示例

匹配含量词的字符串
若需匹配字符串 "a*" 或 "1+"：

错误写法：[a*1+] → 会匹配 a、*、1、+ 中的任意单个字符（如 "a" 或 "*"）。

正确写法：a\*|1\+ → 使用转义符和分组匹配完整字符串。

量词字符的转义需求
在 [] 内部，量词字符通常无需转义（如 [*] 直接匹配 *），但若需匹配字面连字符 -，需置于首位或转义（如 [-a] 或 [a\-z]）。

五、例外与边界情况

{} 的特殊性：
在部分正则引擎中，{ 和 } 在 [] 内始终按字面处理（如 [{] 匹配 {），但若写成 {3} 形式，引擎仍会将其视为三个独立字符 {、3、}，而非量词语法。

字符组嵌套分组？
[] 内部不支持分组语法 ()。例如 [(a)] 匹配 (、a、) 之一，而非分组结构。

结论

量词在字符组 [] 内部仅作为普通字符匹配，绝不触发重复功能。这是由正则表达式的语法设计决定的：

[] 是原子级的字符匹配单元，内部无子结构。

量词需作用于其左侧的完整元素（字符、分组或字符类）。

若需实现字符的重复匹配，量词必须置于 [] 外部（如 [abc]+）或使用分组（如 (abc)*）。

场景	量词示例	含义
在 `[]` 内部	`[a*]`	匹配字符 `a` 或 `*`
	`[+{2}]`	匹配 `+`、`{`、`2`、`}`之一
在 `[]` 外部	`a*`	匹配 `a` 出现 0 次或多次
	`(ab)+`	匹配子模式 `ab` 至少一次

贪婪模式与非贪婪模式

⚠️ 核心概念：量词默认是贪婪的（Greedy），它们会尽可能多地匹配字符，直到无法匹配为止。而非贪婪模式（Non-greedy，也叫懒惰模式）则会尽可能少地匹配字符，只要满足条件就停止。在量词后面加上 ? 即可切换为非贪婪模式，如 *?、+?、??、{n,m}?。

贪婪模式就像一个贪心的孩子，会拿走盘子里所有的糖果；而非贪婪模式则像一个懂得节制的孩子，只拿满足需求的份量。理解这两种模式的区别和应用场景，是编写高效正则表达式的关键。

贪婪模式示例：

// 贪婪匹配：从第一个 <div> 开始，匹配到最后一个 </div> 结束
// 原理：.* 会尽可能多地匹配字符，包括中间的 </div><div> 部分
const text = "<div>第一个div</div><div>第二个div</div>";
const greedyRegex = /<div>.*<\/div>/; // .* 是贪婪匹配
const result = text.match(greedyRegex);
console.log(result[0]);
// 输出: <div>第一个div</div><div>第二个div</div>
// 注意：这可能不是我们想要的结果，因为它匹配了整个字符串而不是单个div标签

非贪婪模式示例：

// 非贪婪匹配：从第一个 <div> 开始，匹配到最近的 </div> 结束
// 原理：.*? 会尽可能少地匹配字符，找到第一个满足条件的结束标签就停止
const text = "<div>第一个div</div><div>第二个div</div>";
const nonGreedyRegex = /<div>.*?<\/div>/; // .*? 是非贪婪匹配
const result = text.match(nonGreedyRegex);
console.log(result[0]);
// 输出: <div>第一个div</div>
// 注意：这通常是处理HTML标签时期望的结果，只匹配单个完整标签

量词的应用场景

量词的应用几乎涵盖了所有文本处理场景，从简单的数据验证到复杂的信息提取，都离不开量词的灵活运用。以下是几个典型应用场景：

数据格式验证 量词最常见的用途是验证数据是否符合特定格式要求，确保输入数据的规范性和有效性：
- 邮政编码：\d{6}（精确匹配 6 位数字）
- 身份证号：\d{17}[\dXx]（17 位数字加 1 位数字或 X）
- IP 地址：\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}（简化版，每位 0-3 位数字）
- 手机号：1\d{10}（以 1 开头的 11 位数字）
- 密码强度：[A-Za-z\d@$!%*?&]{8,20}（8-20 位字母、数字或特殊符号）

提取重复模式

import re
# 示例文本，包含需要提取的敏感信息
text = "用户密码：******，验证码：1234"

# 使用量词 {6} 精确匹配6个星号（密码掩码）
# re.search() 在文本中查找第一个匹配项
# group() 方法返回匹配到的字符串
password_mask = re.search(r'\*{6}', text).group()

# 使用量词 \d{4} 匹配4位数字（验证码）
# \d 表示任意数字字符，等价于 [0-9]
verification_code = re.search(r'\d{4}', text).group()

# 输出提取结果
print(f"密码：{password_mask}，验证码：{verification_code}")
# 输出：密码：******，验证码：1234
# 应用场景：日志分析、数据清洗、敏感信息提取

处理可变长度文本

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class PriceExtractor {
    public static void main(String[] args) {
        // 包含多种价格格式的文本
        String text = "商品价格：$9.99，运费：$5，总价：$14.99";

        // 正则表达式解析：
        // \$ : 匹配美元符号（$是特殊字符，需要转义）
        // \d+ : 匹配一个或多个数字（整数部分）
        // \.? : 匹配0个或1个小数点（可选的小数点），因为 . 是元字符，这里需要的是小数点，所以需要 转义
        // \d* : 匹配0个或多个数字（小数部分，可选）
        Pattern pattern = Pattern.compile("\$\d+\.?\d*");

        // 创建Matcher对象用于在文本中查找匹配
        Matcher matcher = pattern.matcher(text);

        // 循环查找所有匹配项
        System.out.println("提取到的价格：");
        while (matcher.find()) {
            // group()方法返回当前匹配到的字符串
            System.out.println(matcher.group());
        }

        // 输出结果：
        // $9.99
        // $5
        // $14.99
        // 应用场景：电商数据处理、财务报表分析、价格监控系统
    }
}

量词是正则表达式的核心组成部分，它们赋予了正则表达式处理重复模式的能力。从简单的次数控制到复杂的匹配策略，量词为文本处理提供了强大而灵活的工具。

掌握量词的关键在于理解：

不同量词的精确含义和适用场景
贪婪与非贪婪模式的区别和切换
如何避免常见的性能陷阱和匹配问题

通过合理运用量词，你可以将复杂的文本处理任务简化为简洁而高效的正则表达式，大幅提升开发效率和代码质量。下一节我们将学习如何通过位置匹配进一步精确控制正则表达式的匹配行为。

3 位置匹配：不匹配字符，只匹配位置 📍

正则表达式不仅可以匹配字符，还可以匹配字符串中的特定位置。

位置匹配（Position Matching） 是正则表达式中一种特殊而强大的匹配方式，它不匹配具体字符，而是匹配字符串中的特定位置。

位置匹配不会消耗字符，只判断当前位置是否符合条件，因此也被称为零宽匹配（Zero-width Matching）。这种能力对于文本验证、格式化和替换操作非常有用，能帮助我们在不修改原有内容的情况下实现精确控制。

常用位置匹配元字符

元字符	描述	例子	匹配说明	实际应用场景
`^`	匹配字符串的开始位置，在多行模式下也匹配每行的开始	`^hello`	匹配以"hello"开头的字符串，如"hello world"	验证输入是否以特定前缀开头
`$`	匹配字符串的结束位置，在多行模式下也匹配每行的结束	`world$`	匹配以"world"结尾的字符串，如"hello world"	验证输入是否以特定后缀结尾
`\b`	匹配单词边界，即单词与非单词字符之间的位置	`\bword\b`	精确匹配单词"word"，不匹配"words"或"sword"	查找或替换独立的单词
`\B`	匹配非单词边界，即两个单词字符之间或两个非单词字符之间的位置	`\Bword\B`	在单词内部匹配"word"，如"swordfish"中的"word"	查找单词中的特定子串

位置匹配的实际应用

1. 完整匹配验证

结合 ^和 $可以确保整个字符串完全符合预期格式，这在表单验证中非常有用：

// 验证邮箱格式（简化版）
function isValidEmail(email) {
  // ^匹配开始，$匹配结束，确保整个字符串都是邮箱格式
  const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  return regex.test(email);
}

console.log(isValidEmail("test@example.com")); // true
console.log(isValidEmail(" test@example.com ")); // false（前后有空格）
console.log(isValidEmail("test@example")); // false（缺少顶级域名）

2. 单词精确匹配

单词边界 \b是文本处理中的重要工具，它能帮助我们精确匹配完整单词，避免匹配到单词的一部分。

import re

# 测试文本：包含多个包含"word"的词汇
text ="word words sword wording"

# 示例1：匹配独立的"word"单词
# \b 表示单词边界，确保"word"前后都是非单词字符
# 这样可以避免匹配到"words"、"sword"等其他包含"word"的词
# 匹配独立的word
pattern = re.compile(r'\bword\b')
matches = pattern.findall(text)
print(matches)  # 输出: ['word']

# 示例2：匹配"word"作为单词的一部分
# \B 表示非单词边界，确保"word"前后都是单词字符或者非单词字符
pattern = re.compile(r'\Bword\B')
matches = pattern.findall(text)
print(matches)  # 输出: []

3. 多行文本处理

在处理多行文本时，^和 $默认匹配整个字符串的开始和结束。

使用多行模式（在 JavaScript 中添加 m标志）可以让它们匹配每行的开始和结束：

const text = "apple\nbanana\norange\napplepie";

// 匹配以apple开头的行（不启用多行模式）
// 示例1：不启用多行模式
//^apple 只匹配整个字符串开头的"apple"
// 即使后面行也有"apple" 也不会匹配
const singleLineRegex = /^apple/g;
console.log(text.match(singleLineRegex)); // 输出: ['apple']

// 启用多行模式
// 示例2：启用多行模式
// /^apple/m 匹配每行开头的"apple"
const multiLineRegex = /^apple/gm;
console.log(text.match(multiLineRegex)); // 输出: ['apple', 'apple']（匹配两行）

4. 文本格式化

位置匹配在文本格式化中展现出独特优势，它允许我们在特定位置插入内容，而无需修改原有文本本身。

下面是一个使用正向后行断言进行数字格式化的例子：

// 原始数字字符串：10位连续数字（无分隔符）
String text = "1234567890";

/**

 * 第一步：在索引3位置插入短横线（生成"123-4567890"）

 * 正则表达式解析：

 *   (?<=\\d{3})  → 正向后行断言(lookbehind)：匹配前面有连续3位数字的位置

 *   (?=\\d{7})   → 正向先行断言(lookahead)：匹配后面有连续7位数字的位置

 * 组合逻辑：仅在原始字符串索引3处（第3位与第4位之间）满足：

 *   - 前方"123"满足3位数字

 *   - 后方"4567890"满足7位数字

 * 注意：该操作不消耗字符，仅定位插入点

 */
String step1 = text.replaceAll("(?<=\\d{3})(?=\\d{7})", "-");

/**

 * 第二步：在索引7位置插入短横线（生成"123-4567-890"）

 * 正则表达式解析：

 *   (?<=\\d{4})  → 匹配前面有连续4位数字的位置

 *   (?=\\d{3})   → 匹配后面有连续3位数字的位置

 * 组合逻辑：在step1结果（"123-4567890"）中定位：

 *   - 前方数字段"4567"（跳过短横线后连续4位）

 *   - 后方数字段"890"（连续3位）

 * 关键机制：首次插入的短横线不影响数字连续性判断

 */
String formatted = step1.replaceAll("(?<=\\d{4})(?=\\d{3})", "-");  

// 输出最终格式化结果（符合xxx-xxxx-xxx格式要求）
System.out.println(formatted); // 输出: 123-4567-890

高级位置匹配技巧

1. 零宽断言（Lookaround Assertions）

零宽断言是位置匹配的高级形式，它们允许我们基于位置周围的内容来匹配位置，而不消耗这些内容。这极大地扩展了正则表达式的表达能力：

-(?=pattern)：正向先行断言，匹配 pattern 前面的位置（向右看）

-(?!pattern)：负向先行断言，匹配不在 pattern 前面的位置

-(?<=pattern)：正向后行断言，匹配 pattern 后面的位置（向左看）

-(?<!pattern)：负向后行断言，匹配不在 pattern 后面的位置

💡 记忆技巧：先行断言（Lookahead）向右看，断言内容在位置之后；后行断言（Lookbehind）向左看，断言内容在位置之前。

示例：密码强度验证

下面的例子使用多个正向先行断言来验证密码是否满足复杂要求：

// 密码强度验证正则表达式

// 要求：至少包含一个大写字母、一个小写字母、一个数字和一个特殊符号，长度8-20

constpasswordRegex=

  /^(?=.*[a-z])      // 正向先行断言：确保字符串中至少有一个小写字母

   (?=.*[A-Z])      // 正向先行断言：确保字符串中至少有一个大写字母

   (?=.*\d)         // 正向先行断言：确保字符串中至少有一个数字

   (?=.*[@$!%*?&])  // 正向先行断言：确保字符串中至少有一个特殊符号

   [A-Za-z\d@$!%*?&]{8,20}$/; // 匹配8-20位允许的字符


// 测试1：符合要求的密码（包含大小写字母、数字和特殊符号）

console.log(passwordRegex.test("Passw0rd!")); // true


// 测试2：不符合要求的密码（全小写，无数字和特殊符号）

console.log(passwordRegex.test("password")); // false（缺少大写字母、数字和特殊符号）

2. 位置匹配组合

通过组合不同的位置匹配元字符和断言，我们可以实现更复杂的匹配需求。下面的例子展示了如何使用正向后行断言提取邮箱地址中的域名部分：

import re

# 包含两个邮箱地址的文本

text ="hello@example.com world@test.org"


# 提取域名部分（@后面，.前面的内容）

# (?<=@) 正向后行断言：匹配@符号后面的位置

# [^.]+ 匹配除了.之外的任意字符一次或多次

pattern = re.compile(r'(?<=@)[^.]+')
matches = pattern.findall(text)


# 输出提取结果：['example', 'test']
# 成功提取了两个邮箱中的域名部分
print(matches)  # 输出: ['example', 'test']

位置匹配是正则表达式中一项精妙而强大的技术，它让我们能够超越简单的字符匹配，精确控制匹配发生的位置。理解和掌握位置匹配，标志着你正则表达式水平的重要提升。

位置匹配的核心价值在于：

-非侵入式操作：可以在不修改原始文本的情况下进行验证和分析

-精确控制：能够精确定位到字符串中的特定位置

-复杂模式构建：结合断言可以创建复杂而精确的匹配模式

-性能优化：有时比字符匹配更高效，因为不需要消耗字符

无论是表单验证、日志分析、数据提取还是文本格式化，位置匹配都能发挥关键作用。随着实践的深入，你会发现越来越多场景中位置匹配能提供优雅而高效的解决方案。

4 常见问题与解决方案

量词虽然强大，但如果使用不当，可能会导致意外结果或性能问题。以下是开发中最常见的问题及解决方案：

问题 1：过度匹配（贪婪陷阱）

当使用 .* 等贪婪量词时，容易出现匹配范围超出预期的情况，特别是在处理 HTML、XML 等嵌套结构文本时。

解决方案：

使用非贪婪模式 .*? 代替贪婪模式 .*
使用更具体的字符集代替通配符 .，如 [^<>]* 代替 .* 匹配 HTML 标签内容
结合上下文边界进行匹配

示例：

// 问题：过度匹配
const html = "<p>第一段</p><p>第二段</p>";
const greedyRegex = /<p>.*<\/p>/; // 匹配整个字符串

// 解决方案1：使用非贪婪模式
const nonGreedyRegex = /<p>.*?<\/p>/; // 只匹配第一个<p>标签

// 解决方案2：使用具体字符集
const specificRegex = /<p>[^<>]*<\/p>/; // 更精确，性能更好

问题 2：性能问题（灾难性回溯）

复杂的量词组合（尤其是嵌套量词）可能导致正则表达式引擎进入"灾难性回溯"状态，在处理长文本时性能急剧下降，甚至导致程序崩溃。

常见性能陷阱：

嵌套量词：(a+)*b
重叠可选匹配：(a|a)*b
宽泛匹配后接具体匹配：.*abc

解决方案：

使用具体量词代替模糊量词（如 \d{3} 代替 \d+ 当知道确切长度时）
避免嵌套量词和重叠模式
使用占有量词（某些语言支持）：a++、a{2,}++
为重复模式设置明确边界

优化示例：

// 性能较差的写法
const badRegex = /(\d+)+b/; // 嵌套量词
const slowRegex = /.*abc/; // 宽泛匹配在前

// 优化后的写法
const goodRegex = /\d+b/; // 简化嵌套
const fastRegex = /[^\n]*abc/; // 限制匹配范围

问题 3：边界匹配问题

量词只控制匹配次数，不控制匹配位置，可能导致部分匹配（字符串的一部分符合模式）而非完全匹配（整个字符串符合模式）。

解决方案：

使用位置锚点 ^（字符串开头）和 $（字符串结尾）
使用单词边界 \b 确保完整单词匹配
使用环视断言控制匹配位置

示例：

// 问题：部分匹配
const regex = /\d{11}/; // 可能匹配长文本中的任意11位数字序列
console.log(regex.test("我的手机号是13812345678，请联系我")); // true（意外成功）

// 解决方案：使用位置锚点
const strictRegex = /^\d{11}$/; // 确保整个字符串是11位数字
console.log(strictRegex.test("我的手机号是13812345678，请联系我")); // false（正确拒绝）
console.log(strictRegex.test("13812345678")); // true（正确接受）

正则表达式语法总结表

1. 字符匹配元字符

元字符	描述	例子	匹配结果	实际应用场景
`.`	匹配除换行符外的任意单个字符，相当于通配符	`h.t`	hat, hot, h* t, h@t, h1t	模糊搜索，如查找"h 开头 t 结尾的 3 个字母单词"
`[ ]`	匹配括号内的任意一个字符，字符集可以指定范围，如[a-z]表示所有小写字母	`[abc]`	a, b, 或 c	验证性别（[男女性]）或简单选项匹配
`[^ ]`	匹配不在括号内的任意一个字符，^表示取反	`[^0-9]`	除数字外的任意字符，如 a, B, @, 空格	过滤文本中的非数字字符
`\d`	匹配数字字符，等价于 `[0-9]`	`\d{3}`	123, 456, 789	匹配三位数，如验证码或区号
`\D`	匹配非数字字符，等价于 `[^0-9]`	`\D+`	abc, 张三, !@#	提取文本中的纯字母部分
`\w`	匹配字母、数字或下划线，等价于 `[a-zA-Z0-9_]`	`user\w+`	username, user123, user_name	匹配用户名（通常包含字母、数字和下划线）
`\W`	匹配非字母、数字或下划线，等价于 `[^a-zA-Z0-9_]`	`\W`	@, #, 空格, ￥	识别文本中的特殊符号
`\s`	匹配空白字符，包括空格、制表符(\t)、换行符(\n)、回车符(\r)等	`hello\s+world`	hello world, hello\tworld, hello\nworld	匹配带有空白分隔的短语
`\S`	匹配非空白字符	`\S{5}`	hello, world, 12345, Abc12	匹配长度为 5 的非空白字符串

2. 量词

量词	描述	例子	匹配结果	不匹配结果
`*`	匹配前面的子表达式零次或多次（贪婪模式），等价于 `{0,}`	`ab*c`	ac, abc, abbc, abbbc...	aac, adc
`+`	匹配前面的子表达式一次或多次（贪婪模式），等价于 `{1,}`	`ab+c`	abc, abbc, abbbc...	ac, aabbc (中间有其他字符)
`?`	匹配前面的子表达式零次或一次（贪婪模式），等价于 `{0,1}`	`ab?c`	ac, abc	abbc, aabc
`{n}`	匹配前面的子表达式恰好 n 次	`ab{2}c`	abbc	abc, abbbc
`{n,}`	匹配前面的子表达式至少 n 次	`ab{2,}c`	abbc, abbbc, abbbbc...	abc
`{n,m}`	匹配前面的子表达式至少 n 次，至多 m 次	`ab{2,3}c`	abbc, abbbc	abc, abbbbc

3. 位置匹配元字符

元字符	描述	例子	匹配说明	实际应用场景
`^`	匹配字符串的开始位置，在多行模式下也匹配每行的开始	`^hello`	匹配以"hello"开头的字符串，如"hello world"	验证输入是否以特定前缀开头
`$`	匹配字符串的结束位置，在多行模式下也匹配每行的结束	`world$`	匹配以"world"结尾的字符串，如"hello world"	验证输入是否以特定后缀结尾
`\b`	匹配单词边界，即单词与非单词字符之间的位置	`\bword\b`	精确匹配单词"word"，不匹配"words"或"sword"	查找或替换独立的单词
`\B`	匹配非单词边界，即两个单词字符之间或两个非单词字符之间的位置	`\Bword\B`	在单词内部匹配"word"，如"swordfish"中的"word"	查找单词中的特定子串

算法精讲--正则表达式（一）：入门必备语法