正则表达式生成器

在浏览器中通过可视化词法模块与经过验证的开发预设规则构建正则表达式。

无需上传无需注册即时结果
13 个经验证的 RFC 与开发正则模板可视化规则与量词构建器JS · Python · Go · Rust 代码片段
生成正则表达式
离线引擎就绪浏览器内 100% 隐私安全 • 零云端上传
100% 保护隐私 • 零服务器文件上传

为什么使用 Utiliome 免费的 正则表达式生成器?

专为严格隐私保护、即时执行和零门槛体验而构建。无需订阅、无付费墙、无需注册账号。

可组合的可视化词法模块

通过串联首尾锚点、字符类、有界量词、非捕获分组((?:...))以及命名捕获组((?<name>...)),分步构建高可读性的正则表达式。

符合 RFC 规范的开发预设模板

内置经过实战验证的预设规则,涵盖实用的 RFC 5322 邮箱地址、严格定界的 IPv4/IPv6 地址、ISO-8601 / RFC 3339 时间戳、SemVer 2.0.0 版本号、RFC 9562 UUID、URL、URL 别名(Slug)及 CSS 十六进制颜色。

多语言代码片段一键导出

直接导出可直接编译的 JavaScript(RegExp)、Python(re.compile 原始字符串)、Go(regexp.MustCompile 原生字面量)与 Rust(regex::Regex)代码,并自动适配各引擎的命名捕获组语法。

实时用例验证与本地隐私保护

在调整词法模块的同时实时验证正例与反例样本。所有预设规则定制、样本校验与代码导出均 100% 在本地客户端执行,零网络请求。

Utiliome 与传统云端工具对比

对比我们本地优先的 WebAssembly 引擎与传统云端转换工具。

特性 Utiliome (本地浏览器) 传统云端转换器
可组合的可视化词法模块 通过串联首尾锚点、字符类、有界量词、非捕获分组((?:...))以及命名捕获组((?<name>...)),分步构建高可读性的正则表达式。 仅提供基础选项,缺乏高级自定义能力
符合 RFC 规范的开发预设模板 内置经过实战验证的预设规则,涵盖实用的 RFC 5322 邮箱地址、严格定界的 IPv4/IPv6 地址、ISO-8601 / RFC 3339 时间戳、SemVer 2.0.0 版本号、RFC 9562 UUID、URL、URL 别名(Slug)及 CSS 十六进制颜色。 依赖外部软件或繁琐的手动处理
数据隐私与本地处理 100% 浏览器本地运行(零服务器上传,绝不外泄) 将数据上传至第三方云服务器(存在泄露风险)
使用成本与账号要求 永久 100% 免费 · 无需注册登录 · 无水印 强制要求注册登录或购买付费会员
工作原理

只需 3 步轻松使用 正则表达式生成器

无需安装任何软件。一切均在您的网页浏览器中直接运行。

1

选择预设模板或添加词法模块

挑选经过 RFC 校验的预设模板(邮箱、IPv4/IPv6、ISO-8601 日期、SemVer、UUID、URL、Slug 或十六进制颜色),或以可视化方式逐步追加锚点、字符集、字面量与量词。

2

配置锚点、捕获分组与测试字符串

在整串精确校验(^...$)与子串提取模式之间自由切换,指定命名捕获组((?<name>...))或非捕获分组((?:...))包装器,并实时核对正反测试用例。

3

复制原始正则或多语言代码片段

导出原始正则表达式,或一键复制已完成原始字符串转义与特定引擎捕获语法适配的 JavaScript、Python、Go 及 Rust 地道代码。

从可视化词法模块到多语言生产级代码的构建流程

快速解答: 按顺序串联带锚点的词法模块,使用命名捕获组((?<name>...))赋予字段语义化名称,结合正例与边界反例样本完成验证,并导出针对 JavaScript、Python、Go 与 Rust 定制的原始字符串代码片段。

凭记忆手写高密度的正则表达式极易引入隐蔽缺陷——例如漏写转义的点号(导致 . 匹配任意字符而非字面量 .)、遗漏首尾锚点,或是产生前导零匹配漏洞。借助可视化词法组合,假设你需要构建一个符合语义化版本 2.0.0(SemVer)规范的严格校验器,要求支持可选的 v 前缀,并分别提取 major(主版本号)、minor(次版本号)、patch(修订号)、prerelease(先行版本号)与 build(构建元数据)标识符。

每一项结构化规则都能清晰地映射为一组有序的词法模块序列:

{
  "anchoring": "exact_line (^...$)",
  "blocks": [
    { "type": "literal", "value": "v", "quantifier": "optional (?)" },
    { "type": "named_capture", "name": "major", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "minor", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "patch", "pattern": "0|[1-9]\\d*" },
    {
      "type": "non_capturing",
      "pattern": "-(?<prerelease>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    },
    {
      "type": "non_capturing",
      "pattern": "\\+(?<build>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    }
  ]
}

注意其中的 0|[1-9]\d* 严格落实了 SemVer 2.0.0 第 2 节规范:既允许单独的 0,又拒绝了 01 这类非法前导零;而非捕获包装器 (?:...)? 则用于包裹 - 与 + 分隔符,避免产生多余的编号捕获组。通过正反测试用例验证并导出多语言代码后,工具会自动生成契合各语言引擎语法的声明:

# 合成的 ECMAScript / Rust 正则模式
^v?(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$

# 正向测试用例(成功匹配)
1.0.0
v2.14.3-rc.1+build.5114f85

# 反向测试用例(拒绝匹配:核心数字版本号包含前导零)
v01.2.0
1.02.3

# Python (re.compile 原始字符串 + (?P<name>...) 命名捕获组语法)
SEMVER_RE = re.compile(r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$")

# Go (RE2 regexp.MustCompile 反引号原始字面量 + (?P<name>...) 语法)
var semverRe = regexp.MustCompile(`^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$`)

由于生成器在标准预设规则中规避了反向引用与环视断言(Lookarounds),导出的表达式既能在 Go 与 Rust 的线性时间 RE2 运行时中直接编译,也能无缝运行于 JavaScript 与 Python 的回溯引擎中。

跨语言正则引擎可移植性、RFC 校验细节与转义规则

快速解答: 正则表达式运行时主要分为回溯型 NFA(JavaScript RegExp、Python re)与线性时间 Thompson NFA / DFA 引擎(Go regexp、Rust regex)。具备高可移植性的正则规则应避免环视断言与反向引用,优先采用宿主语言原生原始字符串字面量,并严格约束 RFC 字节与半字节(Nibble)边界。

回溯型 NFA 与线性时间自动机(Go RE2 与 Rust `regex`)

生产环境中的正则表达式引擎遵循两种截然不同的执行模型:

  1. 回溯型 NFA(JavaScript RegExp、Python re):以递归方式探索分支选择,支持反向引用(\1、\k<name>)及任意前瞻/后顾环视断言((?=...)、(?!...)、(?<=...)、(?<!...)),但在处理存在歧义的复杂模式时,最坏情况下面临指数级时间复杂度风险(ReDoS)。
  2. Thompson NFA / 惰性 DFA(Go regexp、Rust regex):按每个输入字节或码点同步推进所有活跃自动机状态,严格保证最坏时间复杂度为 O(m * n)(其中 m 为模式长度,n 为输入长度)。为维持有限状态边界,Go regexp 与 Rust regex 在架构设计上直接排除了反向引用与环视断言。

此外,各标准库的命名捕获组语法也存在差异:ECMAScript 规范要求使用 (?<name>...);Python re 与 Go regexp 要求使用 (?P<name>...);而 Rust regex(1.9+ 版本)则同时兼容 (?<name>...) 与 (?P<name>...)。

宿主语言原始字符串(Raw String)转义规则

若将正则表达式嵌入普通的双引号字符串中,宿主语言编译器会优先解析反斜杠转义序列,迫使开发者将 \d+\.\d+ 双重转义为 "\\d+\\.\\d+",稍有不慎便会引发静默解析错误(例如 "\b" 会被宿主解析为 ASCII 0x08 退格符,而非正则词边界)。因此,本工具导出的代码片段均采用各语言的原生原始字面量格式:

  • JavaScript:使用 /pattern/flags 字面量语法(仅将未转义的正斜杠转义为 \/),或在动态构建时采用 new RegExp(String.raw..., flags)。
  • Python:使用 re.compile(r"...") 原始字符串字面量(需注意 Python 原始字符串末尾不能包含奇数个反斜杠)。
  • Go:使用 regexp.MustCompile 搭配反引号原始字面量;若需匹配字面量反引号字符,则自动替换为十六进制转义 \x60。
  • Rust:使用 regex::Regex::new(r"..."),当正则模式本身包含双引号时则自动切换为 r#"..."# 井号原始字面量。

开发预设模板中的 RFC 精度边界

  • IPv4 与 IPv6(RFC 4291 / RFC 5952):简陋的 \d{1,3}(?:\.\d{1,3}){3} 会放行高达 999 的非法十进制段。严格的 IPv4 校验必须通过 (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d) 将每个十进制八位组限制在 0–255 之间;而 IPv6 预设则完整覆盖了单次 :: 零压缩语法以及 IPv4 映射尾部(如 ::ffff:192.0.2.128)。
  • UUID(RFC 9562,取代 RFC 4122):标准 8-4-4-4-12 十六进制布局 ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$ 严格约束了版本号半字节(1–8,涵盖最新的 UUIDv7 与 UUIDv8)以及 IETF 变体位(8、9、a、b),并提供可选的宽松模式以兼容全零 Nil(00000000-...)与全一 Max(ffffffff-...)哨兵值。
  • ISO-8601 / RFC 3339 日期与实用邮箱校验:词法表达式负责严格约束月份(0[1-9]|1[0-2])、日期(0[1-9]|[12]\d|3[01])、小时([01]\d|2[0-3])与时区偏移量(Z|[+-](?:[01]\d|2[0-3]):[0-5]\d),同时将格里高利历闰年推算(如拦截 2 月 30 日)及 SMTP 邮箱真实投递验证交由下游解析逻辑处理。

正则表达式生成器 vs 正则测试工具:该如何选择?

快速解答: 当你需要通过可视化词法模块从零构建新正则、定制经过验证的 RFC 预设规则,或导出适用于 JavaScript、Python、Go 与 Rust 的转义代码时,请使用正则表达式生成器;当你需要排查匹配偏移量、查看捕获组字典及实时预览字符串替换结果时,请使用正则表达式测试与调试工具。

在这两款工具之间如何抉择,取决于你当前的核心任务是构建(Authoring)表达式还是诊断(Diagnosing)现有模式。正则表达式生成器专注于结构化规则合成、RFC 预设定制与跨语言代码生成。一旦你生成了表达式,并希望在多行日志负载中逐一检查每个匹配项的起止偏移量、切换有状态的 ECMAScript 标志位,或实时预览 $<name> 字符串替换效果,请直接打开正则表达式测试与调试工具。

功能维度 正则表达式生成器 正则表达式测试与调试工具
核心工程任务 可视化构建新正则模式或定制经过验证的 RFC 预设 调试现有正则模式、匹配偏移量、修饰符标志与替换结果
规则组装方式 可组合词法模块(锚点、字符类、量词、命名捕获组) 自由编写与直接编辑原始正则表达式
权威预设模板库 内置 Email、IPv4/IPv6、ISO-8601、SemVer、UUID、URL、Slug、Hex 预设 专注于用户自定义的任意正则模式与多行文本负载
多语言代码导出 生成可直接复制的 JavaScript、Python、Go 与 Rust 代码片段 输出 JavaScript / ECMAScript 正则字面量
捕获组与偏移量检查 正例与反例测试样本的实时通过性校验 逐项展示 [start, end) 区间、$1–$99 编号捕获及 (?<name>...) 字典
实时替换预览 不用于字符串替换模板预览 实时预览 replace / replaceAll 替换输出(支持 $1、$<name>、$&、$$)

推荐工程工作流

首先在正则表达式生成器中通过模块组装基础表达式或加载 RFC 预设模板,以获得清晰的分组结构、线性时间的安全量词边界以及适配前后端语言的标准化转义代码。当你需要深入测试该模式在多行日志文件、lastIndex 状态流转、Unicode 代理对(Surrogate Pairs)或 replaceAll 替换模板下的具体表现时,可将生成的表达式无缝移交至正则表达式测试与调试工具进行深度验证。

常见问题

正则表达式生成器 常见问题解答与技术指南

了解使用 Utiliome 免费在线 正则表达式生成器 的一切须知。

为什么生成的正则表达式语法在 JavaScript、Python、Go 和 Rust 之间存在差异?

虽然基础字符类与量词在各语言中保持一致,但命名捕获组语法与自动机底层约束存在显著差异。JavaScript 要求使用 (?<name>...),而 Python 的 re 模块与 Go 的 regexp 包则要求使用 (?P<name>...)(Rust 的 regex crate 同时支持这两种写法)。此外,Go 与 Rust 会将正则模式编译为线性时间的 Thompson NFA / DFA 状态机,在设计上主动舍弃了反向引用(\1)与环视断言((?=...)、(?<=...)),而 JavaScript 与 Python 的回溯引擎则支持这些特性。

我应该使用完整实现 RFC 5322 语法的正则表达式来校验邮箱地址吗?

不建议。逐字照搬 RFC 5322 语法的正则表达式长达数千字节,旨在兼容早已被现代邮件服务器废弃的引号内空白符、嵌套注释及 IP 字面量域名,却依然无法证明该邮箱是否真实存在并能接收邮件。生产环境的最佳实践是:将精简的结构化模式(^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$)与 RFC 5321 字节长度限制(本地部分不超过 64 字节,完整地址不超过 254 字节)相结合,并通过发送验证邮件完成最终确认。

各语言的原始字符串字面量(Raw String Literals)是如何避免反斜杠双重转义错误的?

在普通的引号字符串中,宿主语言编译器会在将字符串传递给正则编译器之前先行解析反斜杠转义,迫使开发者将 \d+\s+ 双重转义为 "\\d+\\s+",还会把 "\b" 误解析为 ASCII 退格符而非词边界。原生原始字符串字面量能够跳过宿主编译器的反斜杠转义:在 JavaScript 中使用 /\d+\s+/ 字面量,在 Python 中使用 r"\d+\s+",在 Go 中使用反引号字面量,在 Rust 中使用 r"\d+\s+" 或 r#"..."#。

整串精确校验(Exact String Validation)与子串提取(Substring Extraction)有什么区别?

整串精确校验会将整个表达式包裹在首尾锚点中(^...$,或在 Python、Go 与 Rust 中使用更严格的 \A...\z,因为 Python re 中的 $ 默认还会匹配末尾换行符 \n 之前的位置)。若不加首尾锚点,像 \d{4}-\d{2}-\d{2} 这样的日期表达式就会退化为子串搜索,导致 foo-2026-11-01-bar 这类畸形输入也能通过校验。在进行 API 载荷与表单验证时请务必开启整串锚定;若需测试无锚点的子串提取区间,可前往正则表达式测试与调试工具。

RFC 9562 UUID 预设模板是如何区分合法 UUID 与普通 36 字符十六进制字符串的?

RFC 9562(取代了 RFC 4122)将 4 位版本号编码在第三组的高位半字节中([1-8] 对应 UUIDv1 至 UUIDv8),并将 IETF 变体标识编码在第四组的高位半字节中([89abAB],对应二进制 10xx)。如果你的数据库还需要存储全零的 Nil UUID(00000000-0000-0000-0000-000000000000)或全一的 Max UUID(ffffffff-ffff-ffff-ffff-ffffffffffff),可以启用宽松十六进制模式或显式添加分支选择。