跳到主要内容

正则表达式速查表

快速查阅正则表达式的语法和常用模式。

基础语法​

字符匹配​

模式说明示例
abc精确匹配/abc/ 匹配 "abc"
.任意字符（除换行）/a.c/ 匹配 "abc", "a1c"
\转义字符/a\*b/ 匹配 "a*b"
|或操作/a|b/ 匹配 "a" 或 "b"

字符类​

模式说明等价于
[abc]a、b 或 c 中的任意一个-
[^abc]除 a、b、c 外的任意字符-
[a-z]a 到 z 的任意小写字母-
[A-Z]A 到 Z 的任意大写字母-
[0-9]0 到 9 的任意数字-
[a-zA-Z]任意字母-
[a-zA-Z0-9]任意字母或数字-

预定义字符类​

模式说明等价于
\d数字[0-9]
\D非数字[^0-9]
\w单词字符[a-zA-Z0-9_]
\W非单词字符[^a-zA-Z0-9_]
\s空白字符[ \t\n\r\f\v]
\S非空白字符[^ \t\n\r\f\v]

控制字符与转义序列​

模式说明
\t水平制表符
\n换行符
\r回车符
\v垂直制表符
\f换页符
\0NUL 字符
[\b]退格符（仅在字符类内）
\cX控制字符（X 为 A-Z）
\xHH十六进制字符（两位）
\uHHHHUnicode 字符（四位）
\u{H...}Unicode 代码点（需 u 标志）

Python 特有转义​

模式说明
\A字符串开头（不受 MULTILINE 模式影响）
\Z字符串结尾（若以换行符结尾，匹配换行符之前的位置）
\z字符串绝对结尾（Python 3.14+，始终匹配真正的字符串末尾）

\A 与 ^ 的区别：

import re
text = "line1\nline2"

# ^ 在 MULTILINE 模式下匹配每行开头
re.findall(r'^\w+', text, re.M)  # ['line1', 'line2']

# \A 只匹配整个字符串的开头
re.findall(r'\A\w+', text, re.M)  # ['line1']

\Z 与 \z 的区别：

import re
text = "hello\n"

# $ 在 MULTILINE 模式下匹配每行结尾
re.search(r'o$', text, re.M)  # 匹配成功

# \Z 匹配换行符之前的位置
re.search(r'o\Z', text)  # 匹配成功

# \z（Python 3.14+）匹配字符串的绝对末尾
# re.search(r'\n\z', text)  # 匹配成功
# re.search(r'o\z', text)   # 匹配失败（末尾是 \n 不是 o）

量词​

模式说明示例
*零次或多次/a*/ 匹配 ""、"a"、"aaa"
+一次或多次/a+/ 匹配 "a"、"aaa"
?零次或一次/a?/ 匹配 ""、"a"
{n}恰好 n 次/a{3}/ 匹配 "aaa"
{n,}至少 n 次/a{2,}/ 匹配 "aa"、"aaa"
{n,m}n 到 m 次/a{2,4}/ 匹配 "aa"、"aaa"、"aaaa"
*?非贪婪零次或多次匹配尽可能少的字符
+?非贪婪一次或多次匹配尽可能少的字符
??非贪婪零次或一次匹配尽可能少的字符
*+占有量词（Python 3.11+/Java）匹配后不回溯
++占有量词（Python 3.11+/Java）匹配后不回溯
?+占有量词（Python 3.11+/Java）匹配后不回溯

位置锚点​

模式说明示例
^字符串开头/^abc/ 匹配以 abc 开头
$字符串结尾/abc$/ 匹配以 abc 结尾
\b单词边界/\bword\b/ 匹配完整单词
\B非单词边界/\Bword\B/ 匹配单词内部

分组与捕获​

模式说明示例
(abc)捕获分组/(\d+)-(\d+)/
(?:abc)非捕获分组/(?:\d{4})-(\d{2})/
(?<name>abc)命名分组/(?<year>\d{4})/
\1, \2反向引用/(")[^"]*\1/
\k<name>命名反向引用/(?<q>["'])[^\k<q>]*\k<q>/

零宽断言​

模式说明示例
(?=abc)正向先行断言/\d(?=px)/ 匹配后面是 px 的数字
(?!abc)负向先行断言/\d(?!px)/ 匹配后面不是 px 的数字
(?<=abc)正向后行断言/(?<=\$)\d+/ 匹配前面是 $ 的数字
(?<!abc)负向后行断言/(?<!\$)\d+/ 匹配前面不是 $ 的数字

标志（修饰符）​

标志说明JavaScriptPython
i忽略大小写/abc/ire.I
g全局匹配/abc/g-
m多行模式/abc/mre.M
sdotAll 模式/abc/sre.S
uUnicode 模式/abc/u默认
vUnicode Sets 模式（ES2024）/abc/v-
y粘性匹配/abc/y-
d匹配索引（ES2022）/abc/d-

v 标志新增特性（ES2024）​

特性说明示例
字符串属性匹配多码点字符使用 \p{RGI_Emoji}
差集运算排除特定字符使用 [\p{Greek}--Σ]
交集运算同时满足两个条件使用 [\p{Greek}&&\p{Uppercase}]
字符串字面量匹配多个字符串使用 [\q{ab|cd}]

Modifier（内联标志）​

模式说明示例
(?i:pattern)只在该分组内忽略大小写/(?i:hello) world/
(?-i:pattern)只在该分组内区分大小写/hello (?-i:world)/i
(?im-s:pattern)启用 i、m，禁用 s/(?im-s:^hello$)/

注意：Modifier 语法（ES2024）只支持 i、m、s 三个标志。

常用正则表达式模式​

验证类模式​

邮箱与联系方式​

// 邮箱（简化版）
/^[\w.-]+@[\w.-]+\.\w{2,}$/

// 邮箱（完整版）
/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/

// 中国手机号
/^1[3-9]\d{9}$/

// 固话号码（带区号）
/^0\d{2,3}-?\d{7,8}$/

身份证与银行卡​

// 中国大陆身份证号（18位）
/^[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]$/

// 银行卡号（16位，可能带空格或横线）
/^(\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4})$/

车牌号​

// 中国车牌号（普通）
/^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$/

// 新能源车牌（绿牌）
/^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z](([0-9]{5}[DF])|([DF][A-HJ-NP-Z0-9][0-9]{4}))$/

社交媒体账号​

// 微信号（6-20位，字母开头）
/^[a-zA-Z][a-zA-Z0-9_-]{5,19}$/

// QQ号（5-11位数字）
/^[1-9][0-9]{4,10}$/

// 微博昵称
/^[\u4e00-\u9fa5a-zA-Z0-9_]{1,20}$/

网络与技术​

// IPv4 地址
/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

// IPv6 地址（简化版）
/^([\da-fA-F]{1,4}:){7}[\da-fA-F]{1,4}$/

// URL
/^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$/

// 域名
/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/

// MAC 地址
/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/

// UUID
/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i

// Base64 字符串
/^[A-Za-z0-9+/]*={0,2}$/

日期与时间​

// 日期（YYYY-MM-DD）
/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/

// 时间（HH:MM:SS）
/^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/

// 邮政编码
/^\d{6}$/

// 版本号（语义化版本）
/^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/

密码强度​

// 至少8位，包含大小写字母和数字
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/

// 至少8位，包含大小写字母、数字和特殊字符
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/

颜色格式​

// 十六进制颜色
/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/

// RGB/RGBA 颜色
/^rgba?\(\s*(\d{1,3}%?)\s*,\s*(\d{1,3}%?)\s*,\s*(\d{1,3}%?)\s*(,\s*[\d.]+\s*)?\)$/

// HSL 颜色
/^hsl\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*\)$/

提取类模式​

// 提取 HTML 标签
/<(\w+)[^>]*>([^<]*)<\/\1>/g

// 提取 URL
/https?:\/\/[^\s]+/g

// 提取邮箱
/[\w.-]+@[\w.-]+\.\w{2,}/g

// 提取手机号
/1[3-9]\d{9}/g

// 提取中文
/[\u4e00-\u9fa5]+/g

// 提取 Markdown 链接
/\[([^\]]+)\]\(([^)]+)\)/g

// 提取图片地址
/<img[^>]+src=["']([^"']+)["'][^>]*>/gi

替换类模式​

// 去除所有 HTML 标签
str.replace(/<[^>]+>/g, "")

// 去除多余空白
str.replace(/\s+/g, " ")

// 驼峰命名转下划线
"helloWorld".replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase()
// 结果: "hello_world"

// 下划线转驼峰命名
"hello_world".replace(/_([a-z])/g, (_, char) => char.toUpperCase())
// 结果: "helloWorld"

// 手机号码脱敏
"13812345678".replace(/(\d{3})\d{4}(\d{4})/, "$1****$2")
// 结果: "138****5678"

// 身份证号脱敏
"110101199001011234".replace(/(\d{6})\d{8}(\d{4})/, "$1********$2")
// 结果: "110101********1234"

// 日期格式转换（YYYY-MM-DD -> DD/MM/YYYY）
"2024-03-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
// 结果: "15/03/2024"

文本处理模式​

// 移除 HTML 注释
/<!--[\s\S]*?-->/g

// 移除 JavaScript 注释（单行）
/\/\/.*$/gm

// 移除 JavaScript 注释（多行）
/\/\*[\s\S]*?\*\//g

// 匹配 Markdown 标题
/^#{1,6}\s+.+$/gm

// 匹配 Markdown 图片
/!\[([^\]]*)\]\(([^)]+)\)/g

// 匹配 Markdown 代码块
/```[\s\S]*?```/g

// 匹配 HTML 实体
/&[a-zA-Z]+;|&#\d+;|&#x[0-9a-fA-F]+;/g

各语言正则表达式用法​

JavaScript​

// 创建正则
const regex = /pattern/flags;
const regex = new RegExp("pattern", "flags");

// 测试
regex.test(string);           // 返回 true/false

// 匹配
string.match(regex);          // 返回数组或 null
string.matchAll(regex);       // 返回迭代器（ES2020）
regex.exec(string);           // 返回数组或 null

// 查找
string.search(regex);         // 返回索引或 -1

// 替换
string.replace(regex, replacement);
string.replaceAll(regex, replacement);

// 分割
string.split(regex);

// 新特性示例
// d 标志 - 获取匹配索引（ES2022）
const match = "hello world".match(/(world)/d);
console.log(match.indices);  // [[6, 11], [6, 11]]

// v 标志 - Unicode Sets 模式（ES2024）
/[\p{Emoji}]/v.test("👋");    // true
/[\p{Greek}--Σ]/v.test("α");  // true（差集运算）

// RegExp.escape() - 转义特殊字符（ES2025）
const safe = RegExp.escape("a*b+c");  // 安全转义后可用于构建正则表达式

Python​

import re

# 创建模式
pattern = re.compile(r"pattern", flags)

# 测试
pattern.match(string)      # 从开始匹配
pattern.search(string)     # 搜索第一个匹配
pattern.fullmatch(string)  # 完整匹配

# 匹配所有
pattern.findall(string)    # 返回列表
pattern.finditer(string)   # 返回迭代器

# 替换
pattern.sub(replacement, string)
pattern.subn(replacement, string)  # 返回 (新字符串, 替换次数)

# 分割
pattern.split(string)

# 常用标志
# re.I / re.IGNORECASE - 忽略大小写
# re.M / re.MULTILINE - 多行模式
# re.S / re.DOTALL - . 匹配换行
# re.X / re.VERBOSE - 详细模式
# re.A / re.ASCII - ASCII 模式

Java​

import java.util.regex.*;

// 创建模式
Pattern pattern = Pattern.compile("regex", flags);
Matcher matcher = pattern.matcher(input);

// 测试
matcher.matches();     // 完整匹配
matcher.find();        // 查找下一个匹配
matcher.lookingAt();   // 从开始匹配

// 获取结果
matcher.group();       // 完整匹配
matcher.group(1);      // 第1个分组
matcher.group("name"); // 命名分组

// 替换
matcher.replaceAll(replacement);
matcher.replaceFirst(replacement);

// 常用标志
// Pattern.CASE_INSENSITIVE - 忽略大小写
// Pattern.MULTILINE - 多行模式
// Pattern.DOTALL - . 匹配换行

Go​

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 创建正则
    re := regexp.MustCompile(`pattern`)

    // 测试
    re.MatchString(string)      // 返回 bool

    // 查找
    re.FindString(string)       // 返回第一个匹配
    re.FindAllString(string, n) // 返回所有匹配（n=-1 表示所有）
    re.FindStringSubmatch(string) // 返回分组匹配

    // 替换
    re.ReplaceAllString(string, replacement)

    // 分割
    re.Split(string, n)
}

Rust​

use regex::Regex;

fn main() {
    // 创建正则
    let re = Regex::new(r"pattern").unwrap();

    // 测试
    re.is_match(string);           // 返回 bool

    // 查找
    re.find(string);               // 返回 Option<Match>
    re.find_iter(string);          // 返回迭代器
    re.captures(string);           // 返回捕获分组
    re.captures_iter(string);      // 返回分组迭代器

    // 替换
    re.replace(string, replacement);
    re.replace_all(string, replacement);

    // 分割
    re.split(string);              // 返回迭代器

    // 编译选项
    use regex::RegexBuilder;
    let re = RegexBuilder::new(r"pattern")
        .case_insensitive(true)
        .build()
        .unwrap();
}

C# (.NET)​

using System.Text.RegularExpressions;

// 创建正则
Regex regex = new Regex(@"pattern", RegexOptions.IgnoreCase);

// 测试
regex.IsMatch(input);                    // 返回 bool

// 查找
Match match = regex.Match(input);        // 返回第一个匹配
MatchCollection matches = regex.Matches(input); // 返回所有匹配

// 替换
regex.Replace(input, replacement);
regex.Replace(input, match => ...);      // 使用委托

// 分割
regex.Split(input);

// 常用选项
// RegexOptions.IgnoreCase - 忽略大小写
// RegexOptions.Multiline - 多行模式
// RegexOptions.Singleline - . 匹配换行
// RegexOptions.Compiled - 编译为 IL 代码
// RegexOptions.Timeout - 设置超时

// .NET 7+ Source Generator
[GeneratedRegex(@"\d{4}")]
private static partial Regex YearRegex();

性能优化建议​

1. 避免回溯灾难​

// 危险：重叠量词导致指数级回溯
/(a+)+b/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaa!");

// 安全：使用具体的字符类
/a+b/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaa!");

2. 使用具体的字符类​

// 较慢
/.*?/

// 较快
/[^\n]*?/

3. 预编译模式​

import re

# 不推荐：每次都重新编译
for text in texts:
    re.match(r"\d+", text)

# 推荐：预先编译
pattern = re.compile(r"\d+")
for text in texts:
    pattern.match(text)

4. 使用锚点限制搜索范围​

// 如果确知模式在开始位置
/^\d+/.exec(str);  // 比 /\d+/ 更快

调试工具​

  • RegExr - 在线正则表达式测试和学习工具
  • Regex101 - 支持多种引擎的正则表达式测试
  • Debuggex - 可视化正则表达式执行过程
  • RegexPal - 简洁的正则表达式测试工具

常见错误​

错误原因解决
. 不匹配换行默认行为使用 [\s\S] 或 s 标志
* 和 + 过度匹配贪婪匹配使用非贪婪量词 *? +?
特殊字符未转义$ * 等有特殊含义使用 \ 转义
字符类中 - 的位置- 在中间表示范围将 - 放在开头或结尾
Unicode 字符问题\w 等不匹配中文使用 \p{Han} 或 Unicode 范围

中文相关模式​

// 匹配中文字符（基本汉字）
/[\u4e00-\u9fa5]/

// 匹配中文标点
/[\u3000-\u303f\uff00-\uffef]/

// 匹配中文姓名（2-4个汉字）
/^[\u4e00-\u9fa5]{2,4}$/

// 匹配中文手机号
/^1[3-9]\d{9}$/

// 匹配中文身份证号（18位）
/^[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]$/

// 匹配中文邮编
/^\d{6}$/

// 匹配中文固定电话（带区号）
/^0\d{2,3}-?\d{7,8}$/

// 匹配中文车牌号
/^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$/

金融相关模式​

// 银行卡号（16位，可能带空格或横线）
/^(\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4})$/

// 价格格式（带小数）
/^\d+(\.\d{1,2})?$/

// 货币格式（带千位分隔符）
/^\d{1,3}(,\d{3})*(\.\d{1,2})?$/

// 股票代码（A股）
/^(sh|sz|SH|SZ)\d{6}$/

// 统一社会信用代码
/^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/

文件路径相关模式​

// Windows 文件路径
/^[a-zA-Z]:\\(?:[^\\]+\\)*[^\\]*$/

// Linux/Unix 文件路径
/^\/(?:[^/]+\/)*[^/]*$/

// 文件扩展名
/\.[^.]+$/

// 文件名（不含扩展名）
/^[^.]*/

// URL 文件名
/[^/]+$/

// 匹配图片文件
/\.(jpg|jpeg|png|gif|webp|svg|bmp)$/i

// 匹配视频文件
/\.(mp4|avi|mov|wmv|flv|mkv|webm)$/i

// 匹配音频文件
/\.(mp3|wav|ogg|flac|aac|m4a)$/i

代码相关模式​

// 匹配 JavaScript 变量名
/^[a-zA-Z_$][a-zA-Z0-9_$]*$/

// 匹配 CSS 类名
/^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/

// 匹配 HTML 标签名
/^[a-zA-Z][a-zA-Z0-9-]*$/

// 匹配 JSON 字符串
/^("(?:[^"\\]|\\.)*"|true|false|null|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)$/

// 匹配 SQL 注入风险字符
/(union|select|insert|delete|update|drop|truncate|exec|execute|xp_|sp_|0x)/i

// 匹配 HTML 注释
/<!--[\s\S]*?-->/

// 匹配 JavaScript 单行注释
/\/\/.*$/gm

// 匹配 JavaScript 多行注释
/\/\*[\s\S]*?\*\//

// 匹配 CSS 注释
/\/\*[\s\S]*?\*\//

社交媒体相关模式​

// 匹配 @用户名
/@[\w]+/

// 匹配 #标签
/#[\w\u4e00-\u9fa5]+/

// 匹配 Twitter 用户名
/^@?[a-zA-Z0-9_]{1,15}$/

// 匹配 GitHub 用户名
/^[a-zA-Z0-9]([a-zA-Z0-9-]{0,38})?$/

// 匹配 Discord 用户名
/^[a-zA-Z0-9_]{2,32}$/

密码强度模式​

// 弱密码：至少 6 位
/^.{6,}$/

// 中等密码：至少 8 位，包含数字和字母
/^(?=.*[a-zA-Z])(?=.*\d).{8,}$/

// 强密码：至少 8 位，包含大小写字母、数字和特殊字符
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/

// 非常强密码：至少 12 位，包含大小写字母、数字和多种特殊字符
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])(?=.*[#$%^&*])[A-Za-z\d@$!%*?&#$%^&*]{12,}$/

时间相关模式​

// 匹配 12 小时制时间
/^(0?[1-9]|1[0-2]):[0-5]\d(?::[0-5]\d)?\s*(?:[AP]M)?$/i

// 匹配 24 小时制时间
/^([01]?\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/

// 匹配时间戳（Unix）
/^\d{10}$/

// 匹配时间范围（如 09:00-18:00）
/^([01]?\d|2[0-3]):[0-5]\d-([01]?\d|2[0-3]):[0-5]\d$/

// 匹配 ISO 8601 日期时间
/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/

网络安全相关模式​

// 匹配 XSS 攻击特征
/<script[^>]*>[\s\S]*?<\/script>/gi

// 匹配 SQL 注入特征
/(union.*select|select.*from|insert.*into|delete.*from|drop.*table)/i

// 匹配常见的敏感文件
/\.(env|git|svn|htaccess|htpasswd|config|ini|log)$/i

// 匹配邮箱欺骗头
/(from|to|reply-to|return-path):\s*<[^>]+>/i

// 匹配 IP 地址（可能用于访问控制）
/^(\d{1,3}\.){3}\d{1,3}$/

数据格式模式​

// 匹配 JSON
/^(?:\{[\s\S]*\}|\[[\s\S]*\])$/

// 匹配 XML 标签
/<([^>]+)>[\s\S]*?<\/\1>/

// 匹配 CSV 行
/(?:"([^"]*)"|([^,]*))(?:,|$)/g

// 匹配 Markdown 标题
/^#{1,6}\s+.+$/gm

// 匹配 Markdown 列表
/^(\s*)[-*+]\s+.+$/gm

// 匹配 Markdown 代码块
/^```[\s\S]*?```$/gm

// 匹配 Markdown 图片
/!\[([^\]]*)\]\(([^)]+)\)/g

// 匹配 YAML 键值对
/^(\s*)([^:]+):\s*(.*)$/

文本处理模式​

// 匹配连续空白
/\s+/

// 匹配换行符
/\r\n|\r|\n/

// 匹配制表符
/\t/

// 匹配所有空白行
/^\s*$/gm

// 匹配重复单词
/\b(\w+)\s+\1\b/gi

// 匹配重复行
/^(.+)(\n\1)+$/gm

// 匹配首尾空白
/^\s+|\s+$/g

// 匹配中英文混合单词
/[\u4e00-\u9fa5\w]+/

学习资源​