1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import Foundation

// ① 字面量 /.../（Swift 5.7+；Swift 6 语言模式默认开启，Swift 5 模式要 -enable-bare-slash-regex）
//    扩展定界符 #/.../# 可以少写反斜杠
let date = /(?<y>\d{4})-(?<m>\d{2})/
if let m = try? date.wholeMatch(in: "2026-09") {
    print(m.output.y, m.output.m)                              // 2026 09
}
let hash = #/\d+/#
print(try! hash.firstMatch(in: "ab12") != nil)                 // true

// ② 自研 Regex 是回溯引擎：前向环视、反向引用、原子组、占有量词都有
print(try! Regex(#"(a)\1"#).firstMatch(in: "aa") != nil)       // true
print(try! Regex(#"(?=foo)foo"#).firstMatch(in: "foo") != nil) // true
print(try! Regex(#"(?>a*)a"#).firstMatch(in: "aaa") != nil)    // false（原子组阻断回溯）
print(try! Regex(#"a*+a"#).firstMatch(in: "aaa") != nil)       // false（占有量词）

// ③ 但后向环视在 Swift 6.4 仍未落地（SE-0448 已接受，引擎尚未实现）
do { _ = try Regex(#"(?<=foo)bar"#) }
catch { print("lookbehind:", error) }                          // lookbehind is not currently supported

// ④ \p{...} 可用；\d 是 Unicode 语义
print(try! Regex(#"^\p{Greek}+$"#).firstMatch(in: "αβγ") != nil) // true
print(try! Regex(#"^\d+$"#).firstMatch(in: "٣") != nil)          // true

// ⑤ 字符类集合运算：交集 && 与差集 --（ICU 风格）
print(try! Regex(#"^[\w--\d]+$"#).wholeMatch(in: "x") != nil)            // true
print(try! Regex(#"^[\w--\d]+$"#).wholeMatch(in: "5") != nil)            // false
print(try! Regex(#"^[a-z&&[^aeiou]]+$"#).wholeMatch(in: "bcdfg") != nil) // true

// ⑥ 条件分支与递归：不支持
for p in [#"(?(1)a|b)"#, #"(?R)"#] {
    do { _ = try Regex(p); print(p, "=> OK") } catch { print(p, "=> ERR") }
}

// ⑦ 另一套引擎：NSRegularExpression 走 ICU，后向环视可用
let icu = try! NSRegularExpression(pattern: #"(?<=foo)bar"#)
let text = "foobar"
print(icu.firstMatch(in: text, range: NSRange(text.startIndex..., in: text)) != nil) // true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
	"fmt"
	"regexp"
)

func main() {
	// ① \d \w \s 只有 ASCII 语义，\p{...} 才认 Unicode
	fmt.Println(regexp.MustCompile(`^\d+$`).MatchString("٣"))         // false
	fmt.Println(regexp.MustCompile(`^\w+$`).MatchString("汉字"))       // false
	fmt.Println(regexp.MustCompile(`^\s$`).MatchString("\u00a0"))     // false
	fmt.Println(regexp.MustCompile(`^\p{Han}+$`).MatchString("汉字"))  // true

	// ② 命名组 (?P<name>...) 与 (?<name>...) 都接受
	re := regexp.MustCompile(`(?P<y>\d{4})-(?<m>\d{2})`)
	fmt.Println(re.SubexpNames()[1:], re.FindStringSubmatch("2026-09")) // [y m] [2026-09 2026 09]

	// ③ 内联标志 (?i)(?m)(?s)(?U)
	fmt.Println(regexp.MustCompile(`(?i)go`).MatchString("GO"))       // true
	fmt.Println(regexp.MustCompile(`(?s)^a.b$`).MatchString("a\nb"))  // true
	fmt.Println(regexp.MustCompile(`(?U)a+`).FindString("aaa"))       // a

	// ④ 环视 / 反向引用 / 原子组 / 占有量词 / 嵌套重复：编译期报错
	for _, p := range []string{`(?=x)`, `(?<=x)`, `(a)\1`, `(?>a)`, `a*+`} {
		_, err := regexp.Compile(p)
		fmt.Println(p, "=>", err)
	}
	// ⚠️ && 不是交集：Go 当普通字符处理，连 ] 都变成字面量，悄悄编译通过
	fmt.Println(regexp.MustCompile(`[a-z&&[^aeiou]]`).MatchString("q]")) // true

	// ⑤ POSIX 方言：CompilePOSIX 走 ERE 且取最左最长
	fmt.Println(regexp.MustCompilePOSIX(`a|ab`).FindString("ab")) // ab
	fmt.Println(regexp.MustCompile(`a|ab`).FindString("ab"))      // a
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import re

# ① \d \w \s 对 str 默认就是 Unicode 语义，re.ASCII / (?a) 才退回 ASCII
print(bool(re.match(r"^\d+$", "٣")))            # True
print(bool(re.match(r"^\w+$", "汉字")))          # True
print(bool(re.match(r"^\d+$", "٣", re.ASCII)))   # False

# ② \p{...} 不支持：那是第三方 regex 模块的能力
try:
    re.compile(r"\p{Greek}")
except re.error as e:
    print("p-brace:", e)                        # p-brace: bad escape \p at position 0

# ③ 反向引用、命名组、环视都支持；后向环视必须定长
print(bool(re.match(r"(a)\1", "aa")))                 # True
print(bool(re.match(r"(?P<w>\w+) (?P=w)", "ha ha")))  # True
print(bool(re.match(r"(?<=x)y", "xy")))               # True

# ④ 原子组 (?>...) 与占有量词 *+ 自 Python 3.11 起可用
print(re.match(r"(?>a*)a", "aaa"))   # None
print(re.match(r"a*+a", "aaa"))      # None

# ⑤ 条件分支、递归：编译期报错；字符类减集在 3.14 只给 FutureWarning，仍按字面量解析
for p in [r"(?(1)a|b)", r"(?R)", r"[\w--\d]"]:
    try:
        re.compile(p)
        print(p, "=> OK")
    except re.error as e:
        print(p, "=>", e)

# ⑥ 标志位全枚举：A/ASCII、DEBUG、I/IGNORECASE、L/LOCALE、M/MULTILINE、NOFLAG、S/DOTALL、U/UNICODE、X/VERBOSE
print(bool(re.match(r"(?i)abc", "ABC")), bool(re.match(r"(?a)\d", "٣")))  # True False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// ① 没有正则字面量：用 Regex("...") 或 String.toRegex()
val re = Regex("""(?<y>\d{4})-(?<m>\d{2})""")   // 原始字符串可少写反斜杠
re.find("2026-09")!!.groups["y"]!!.value          // 2026
"^\\d+$".toRegex().matches("123")                 // true

// ② 选项是 RegexOption 枚举（全 7 个：IGNORE_CASE, MULTILINE, LITERAL,
//    UNIX_LINES, COMMENTS, DOT_MATCHES_ALL, CANON_EQ）；JS 目标只有前两个
Regex("abc", RegexOption.IGNORE_CASE).matches("ABC")                  // true
Regex("a.b", setOf(RegexOption.DOT_MATCHES_ALL)).matches("a\nb")      // true

// ③ \d \w \s 的语义随平台走：JVM 沿用 Java，默认 ASCII
Regex("""^\d+$""").matches("٣")        // false
Regex("""(?U)^\d+$""").matches("٣")    // true（(?U) 是 Java 的 Unicode 字符类标志）

// ④ 支持：反向引用、环视、原子组、占有量词、\p{...}、字符类交集（JVM/Native 上）
Regex("""(a)\1""").matches("aa")                     // true
Regex("""(?<=x)y""").containsMatchIn("xy")           // true
Regex("""(?>a*)a""").matches("aaa")                  // false
Regex("""a*+a""").matches("aaa")                     // false
Regex("""\p{Greek}+""").containsMatchIn("αβγ")       // true
Regex("""[a-z&&[^aeiou]]""").matches("b")            // true

// ⑤ 不支持（继承 Java Pattern）：条件分支、递归；也没有超时参数
// Regex("""(?(1)a|b)""")   // 🛑 PatternSyntaxException（JVM 上）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import java.util.regex.*;

// ① 命名组是 (?<name>...)，不是 Python 的 (?P<name>...)
Matcher m = Pattern.compile("(?<y>\\d{4})-(?<m>\\d{2})").matcher("2026-09");
m.matches();
m.group("y");                                                    // 2026

// ② \d \w \s 默认 ASCII；UNICODE_CHARACTER_CLASS 或 (?U) 才 Unicode
Pattern.compile("^\\d+$").matcher("٣").matches();                 // false
Pattern.compile("^\\d+$", Pattern.UNICODE_CHARACTER_CLASS)
       .matcher("٣").matches();                                   // true
Pattern.compile("(?U)^\\d+$").matcher("٣").matches();             // true

// ③ 回溯引擎的全套：反向引用、环视、原子组、占有量词、字符类集合运算
Pattern.compile("(a)\\1").matcher("aa").matches();                // true
Pattern.compile("(?<=x)y").matcher("xy").find();                  // true
Pattern.compile("(?>a*)a").matcher("aaa").matches();              // false（原子组）
Pattern.compile("a*+a").matcher("aaa").matches();                 // false（占有量词）
Pattern.compile("[a-z&&[^aeiou]]").matcher("b").matches();        // true（交集写法）

// ④ 内联标志 (?idmsuxU-idmsuxU) 与作用域写法 (?i:...)
Pattern.compile("(?i)abc").matcher("ABC").matches();              // true
Pattern.compile("(?idmsuxU-idmsuxU:x)").matcher("x").matches();   // true

// ⑤ 官方明确列为"不支持"的 Perl 构造：条件分支
Pattern.compile("(?(1)a|b)");   // 🛑 PatternSyntaxException

// ⑥ 编译标志共 9 个
int f = Pattern.CANON_EQ | Pattern.CASE_INSENSITIVE | Pattern.COMMENTS | Pattern.DOTALL
      | Pattern.LITERAL | Pattern.MULTILINE | Pattern.UNICODE_CASE
      | Pattern.UNICODE_CHARACTER_CLASS | Pattern.UNIX_LINES;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>
#include <regex>
#include <string>
using namespace std;

// 默认语法是 ECMAScript；换方言只要给构造函数传第二个参数
static bool ok(const string& p) { try { regex r(p); return true; } catch (const regex_error&) { return false; } }

int main() {
    // ① 支持：前向环视、反向引用、懒惰量词
    cout << regex_search("a",  regex("(?=a)a"))        << "\n";  // 1
    cout << regex_search("aa", regex("(a)\\1"))        << "\n";  // 1
    cout << regex_search("abc", regex("a.*?b"))        << "\n";  // 1

    // ② 不支持：命名组、后向环视、\p{...}、内联标志、原子组、占有量词、字符类交集
    cout << ok("(?<n>a)") << ok("(?<=a)b") << ok("\\p{L}") << ok("(?i)abc")
         << ok("(?>a*)a") << ok("a*+a") << ok("[a-z&&[^aeiou]]") << "\n";  // 0000000

    // ③ \d \w \s 是 ASCII 语义，也没有 Unicode 开关
    cout << regex_search("5", regex("\\d")) << regex_search("٣", regex("\\d"))
         << regex_search("汉", regex("\\w")) << "\n";           // 100

    // ④ 语法选项 11 个：ECMAScript、basic、extended、awk、grep、egrep、
    //    icase、nosubs、optimize、collate、multiline（multiline 自 C++17 起）
    cout << regex_search("aaa", regex("^a+$", regex::extended)) << "\n";  // 1
    cout << regex_search("aaa", regex("^a+$", regex::grep))     << "\n";  // 0（grep 是 BRE，+ 是字面量）
    cout << regex_search("ABC", regex("abc", regex::icase))     << "\n";  // 1
    cout << regex_search("a\nb", regex("^b", regex::multiline)) << "\n";  // 1
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <stdio.h>
#include <regex.h>

/* 0 表示匹配成功，REG_NOMATCH 表示不匹配，regcomp 非 0 表示模式非法 */
static void t(const char *pat, int flags, const char *s) {
    regex_t re;
    int rc = regcomp(&re, pat, flags);
    if (rc != 0) {
        char e[128]; regerror(rc, &re, e, sizeof e);
        printf("%-16s => regcomp 失败: %s\n", pat, e);
        return;
    }
    printf("%-16s vs %-6s => %s\n", pat, s,
           regexec(&re, s, 0, NULL, 0) == 0 ? "匹配" : "不匹配");
    regfree(&re);
}

int main(void) {
    /* ① BRE（默认语法）：分组写 \( \)，反向引用 \1 可用 */
    t("^\\(a\\)\\1$", 0, "aa");
    /* ② BRE 里 + 是普通字符，^a+$ 只匹配字面量 a+ */
    t("^a+$", 0, "aaa");
    /* ③ ERE（REG_EXTENDED）：() + ? | {} 才是元字符 */
    t("^(ab)+$", REG_EXTENDED, "abab");
    /* ④ ERE 没有反向引用：\1 退化成八进制转义 */
    t("^(a)\\1$", REG_EXTENDED, "aa");
    /* ⑤ 没有 \d：ERE 里 \d 就是字面量 d */
    t("^\\d+$", REG_EXTENDED, "123");
    t("^\\d+$", REG_EXTENDED, "d");
    /* ⑥ 没有命名组 / 非贪婪 / 环视 / 内联标志 */
    t("(?<n>a)", REG_EXTENDED, "a");
    t("a*?b", REG_EXTENDED, "aab");
    t("(?=a)a", REG_EXTENDED, "a");
    t("(?i)abc", REG_EXTENDED, "ABC");
    /* ⑦ regcomp 的编译标志只有四个，另有 REG_NOTBOL / REG_NOTEOL 供 regexec 使用 */
    t("^abc$", REG_EXTENDED | REG_ICASE, "ABC");
    printf("REG_EXTENDED=%d REG_ICASE=%d REG_NEWLINE=%d REG_NOSUB=%d REG_NOTBOL=%d REG_NOTEOL=%d\n",
           REG_EXTENDED, REG_ICASE, REG_NEWLINE, REG_NOSUB, REG_NOTBOL, REG_NOTEOL);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# ① r"..." 字面量，标志写在结尾引号之后；也可以用 Regex(pattern, flags)
r"^a+$"                       # 无标志
r"^a+$"i                      # i = 大小写不敏感
r"^a.b$"s                     # s = 让 . 匹配换行
r"^a+$"im                     # 可以连写多个标志
Regex(raw"^\d+$", "im")       # 构造函数写法，pattern 需要转义（raw"" 省事）

# ② Unicode 默认开启（PCRE2 以 UTF + UCP 编译）：\d \w \s 都是 Unicode 语义
occursin(r"^\d+$", "٣")              # true
occursin(Regex(raw"^\d+$", "a"), "٣") # false（a = ASCII 模式，关掉 UTF 与 UCP）

# ③ \p{...} 可用；命名组三种拼写都认，取组用 m[:name]
occursin(r"^\p{Greek}+$", "αβγ")                       # true
match(r"(?<y>\d{4})-(?<m>\d{2})", "2026-09")[:y]       # "2026"

# ④ PCRE2 全套：反向引用、环视、原子组、占有量词、条件分支、递归子模式
occursin(r"(a)\1", "aa")                        # true
occursin(r"(?<=x)y", "xy")                      # true
occursin(r"(?>a*)a", "aaa")                     # false（原子组阻断回溯）
occursin(r"a*+a", "aaa")                        # false（占有量词）
occursin(r"(a)(?(1)b|c)", "ab")                 # true（条件分支）
occursin(r"^(\((?:[^()]|(?1))*\))$", "(a(b))")  # true（(?1) 递归子模式）

# ⑤ 字符类交集/减法：PCRE2 10.45 起才有，且必须开 PCRE2_ALT_EXTENDED_CLASS
#    编译选项（没有对应的 (*VERB)）；Julia 只暴露 i m s x a，开不了，
#    所以这里的 && 是普通字符，和 Go / JavaScript 是同一个坑
occursin(r"^[a-z&&[^aeiou]]$", "&]")            # true（不是减法！）
occursin(r"^[a-z&&[^aeiou]]$", "b")             # false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

using System.Text.RegularExpressions;

// ① 命名组两种拼写：(?<name>...) 与 (?'name'...)
var re = new Regex(@"(?<y>\d{4})-(?<m>\d{2})");
re.Match("2026-09").Groups["y"].Value;                    // 2026

// ② 默认回溯；RegexOptions.NonBacktracking 换成线性时间引擎（.NET 7+）
var linear = new Regex(@"a+", RegexOptions.NonBacktracking);

// ③ 后向环视允许变长（官方快速参考就举了 (?<=.+and.+) 这样的例子）
Regex.IsMatch("Tom and Jane", @"(?<=Tom and )Jane");       // true

// ④ \p{...}、原子组、条件分支、平衡组都在
Regex.IsMatch("αβγ", @"^\p{Greek}+$");                     // true
Regex.IsMatch("aaa", @"(?>a*)a");                          // false（原子组）
Regex.IsMatch("ab", @"(a)(?(1)b|c)");                      // true（条件分支）
Regex.IsMatch("m", @"^[a-z-[djp]]$");                      // true（字符类减法）

// ⑤ 不支持占有量词（会当成非法的嵌套量词抛 ArgumentException）
// new Regex(@"a*+a");                                     // 🛑 不支持

// ⑥ 内联选项字母只有 i m n s x（n = ExplicitCapture）
Regex.IsMatch("ABC", @"(?i)abc");                          // true
Regex.IsMatch("a b", @"(?x)a b");                          // true

// ⑦ 超时：默认 Regex.InfiniteMatchTimeout，必须显式设置才有效
var bounded = new Regex(@"a+", RegexOptions.None, TimeSpan.FromSeconds(1));

// ⑧ RegexOptions 在 .NET 10 共 11 个
var opts = RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.ExplicitCapture
         | RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace
         | RegexOptions.RightToLeft | RegexOptions.ECMAScript | RegexOptions.CultureInvariant
         | RegexOptions.NonBacktracking;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// ① 构造：RegExp(source, {multiLine, caseSensitive, unicode, dotAll})
//    惯例是传 raw string，避免 Dart 自己先吃掉一层反斜杠
final re = RegExp(r'(\w+)');
re.firstMatch('Parse my string')![0];                 // Parse

// ② unicode 标志：默认按 UTF-16 码元，开了才按码点（代理对算一个字符）
RegExp(r'^..$').hasMatch('😀');                        // true（代理对 = 2 个码元）
RegExp(r'^.$').hasMatch('😀');                         // false
RegExp(r'^.$', unicode: true).hasMatch('😀');          // true
// \p{...} 只在 unicode: true 下可用
RegExp(r'^\p{L}$', unicode: true).hasMatch('汉');      // true
RegExp(r'^\p{L}$', unicode: false).hasMatch('汉');     // false
// ⚠️ 但 \d \w \s 即使在 unicode: true 下仍是 ASCII 语义（ECMAScript 规定）
RegExp(r'^\d+$', unicode: true).hasMatch('٣');         // false

// ③ 支持：反向引用、前后向环视、命名组、懒惰量词
RegExp(r'(a)\1').hasMatch('aa');                       // true
RegExp(r'(?<=foo)bar').hasMatch('foobar');             // true
RegExp(r'(?<y>\d{4})').firstMatch('2026')!.namedGroup('y');  // 2026
RegExp(r'a+?b').firstMatch('aaab')![0];                // aaab

// ④ Dart 3.12 起支持 modifier spans 与重复命名组（ECMAScript 2025 语法）
RegExp(r'(?i:abc)').hasMatch('ABC');                   // true
RegExp(r'(?<x>a)|(?<x>b)').hasMatch('b');              // true

// ⑤ 不支持：原子组、占有量词、条件分支、递归、字符类交集
//    官方文档原话："Neither Dart nor ECMAScript have general 'atomic grouping'"
// RegExp(r'(?>a)');    // 🛑 FormatException
// RegExp(r'a*+');      // 🛑 FormatException

// ⑥ RegExp.escape 自 Dart 2.0.0 起；先把字面量转义再嵌进模式
final escaped = RegExp.escape('a.b*c');
RegExp('^$escaped\$').hasMatch('a.b*c');                // true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# ① 默认引擎是 TRE（POSIX ERE + 扩展）；perl = TRUE 才切到 PCRE2
grep("[0-9]+", c("a1", "bb"))                  # [1] 1        ERE 语法
grep("\\d+",   c("a1", "bb"))                  # [1] 1        \d 是 TRE 的扩展
grepl("(?<=a)b", c("ab", "cb"))                # 🛑 TRE 不支持环视，报 invalid regular expression
grepl("(?<=a)b", c("ab", "cb"), perl = TRUE)   # [1]  TRUE FALSE

# ② perl = TRUE 才有的：环视、\p{...}、命名捕获、内联标志
grepl("^\\p{Greek}+$", "αβγ", perl = TRUE)     # [1] TRUE
grepl("(?i)^abc$", "ABC", perl = TRUE)         # [1] TRUE

# ③ perl = TRUE 默认仍然不做 Unicode 属性匹配：\d \w \s 还是 ASCII
grepl("^\\d+$", "٣", perl = TRUE)              # [1] FALSE
grepl("^(*UCP)\\d+$", "٣", perl = TRUE)        # [1] TRUE（模式开头加 (*UCP) 才切到 Unicode）

# ④ 默认引擎自带懒惰量词与 \1-\9 反向引用（R 对 POSIX 的扩展）
sub("a+?", "X", "aaa")                         # [1] "Xaa"
sub("a+",  "X", "aaa")                         # [1] "X"
grep("^(a)\\1$", "aa")                         # [1] 1

# ⑤ fixed = TRUE 退化成字面量匹配；useBytes = TRUE 退化成逐字节
grep("a.b", c("axb", "a.b"), fixed = TRUE)     # [1] 2
grep("a.b", c("axb", "a.b"))                   # [1] 1 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

-- ① 字符类用 % 前缀：%d %a %w %s 是 Lua 写法，不是 \d \w \s
print(("a1b2"):match("%a%d"))                    -- a1
print(("  42"):match("^%s*(%d+)$"))              -- 42（有捕获时 match 返回捕获值）

-- ② * + ? 取最长，- 取最短（Lua 的非贪婪写法）
print(("aaa"):match("a*"))                       -- aaa
print(("aaa"):match("a-"))                       -- （空串）

-- ③ %n 是本模式内的"匹配第 n 个捕获到的子串"，gsub 替换串里用 %n 与 %0
print(("ha ha"):match("(%a+) %1"))               -- ha
print(("2026-09"):gsub("(%d+)-(%d+)", "%2/%1"))  -- 09/2026	1

-- ④ %b（配对匹配）与 %f（frontier 边界）是 Lua 独有
print(("(a(b)c)"):match("%b()"))                 -- (a(b)c)
print(("THE (quick) fox"):match("%f[%a]%a+"))    -- THE

-- ⑤ 没有 | 交替：竖线是普通字符，模式只能匹配字面量
print(("cat"):match("cat|dog"))                  -- nil
print(("cat|dog"):match("cat|dog"))              -- cat|dog

-- ⑥ 按字节工作、字符类按当前 locale，不认 Unicode
print(("汉"):match("%a"))                        -- nil
print(("汉"):match("."))                         -- 一个字节（UTF-8 三个字节里的第一个）
print(#("汉"))                                   -- 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// ① 字面量就是 JS 的；TypeScript 5.5 起会对正则做语法检查
const re: RegExp = /(?<y>\d{4})-(?<m>\d{2})/u;
const m = re.exec("2026-09")!;
m.groups!.y;                                   // "2026"

// TS 5.5+ 能抓到的两类错（运行时才报的错前移到编译期）：
// const bad = /@robot(\s+(please|immediately)))?/;  // 🛑 Unexpected ')'
// const br  = /(a)\2/u;                             // 🛑 反向引用指向不存在的组

// ② 标志位与 JavaScript 完全一致：d g i m s u v y，u 与 v 互斥
"a1".match(/(?<x>\d)/d)!.indices!.groups!.x;         // [1, 2]（d = ES2022）
/^[\p{Lowercase}&&\p{Script=Greek}]+$/v.test("αβ");  // true（v = ES2024）
RegExp.escape("a.b*c");                              // ES2025 标准方法
// new RegExp("a", "uv");                            // 🛑 SyntaxError: u 与 v 不能同时用

// ③ ES2025 的修饰符组：只支持 i m s，且必须带作用域
new RegExp("(?i:abc)").test("ABC");                  // true
new RegExp("(?-i:abc)").test("ABC");                 // false
// new RegExp("(?i)abc");                            // 🛑 SyntaxError（无作用域的 (?i) 非法）

// ④ \d \w 永远是 ASCII，\s 不是；\p{...} 需要 u 或 v
/^\d+$/u.test("٣");                                   // false
/^\w+$/u.test("汉字");                                // false
/^\s$/.test("\u00a0");                                // true（NBSP 属于 ECMAScript 的 WhiteSpace）
/^\p{Script=Han}+$/u.test("汉字");                    // true

// ⑤ TS 不降级正则；target 只被部分检查使用（命名组要 ES2018+），
//    ES2025 的重复命名组与修饰符组不看 target（TypeScript#63682）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// ① 字面量 /.../ 与 RegExp 构造；命名组、前后向环视、反向引用都有
const re = /(?<y>\d{4})-(?<m>\d{2})/;
re.exec("2026-09").groups.y;                     // "2026"
/(?<=a)b/.test("ab");                             // true（后向环视，长度可变）
/(a)\1/.test("aa");                               // true

// ② 标志位 d g i m s u v y 与各自加入的规范版本
"a1".match(/(?<x>\d)/d).indices.groups.x;        // [1, 2]（d = ES2022）
"xy".match(/y/y);                                 // null（y = 粘性，只从 lastIndex 处开始匹配）
/^[\p{Lowercase}&&\p{Script=Greek}]+$/v.test("αβ"); // true（v = ES2024）
RegExp.escape("a.b*c");                           // "\x61\.b\*c"（ES2025；Node 24 实测）

// ③ ES2025 修饰符组：只有带作用域的形式才合法
new RegExp("(?i:abc)").test("ABC");               // true
new RegExp("(?-i:abc)").test("ABC");              // false
// new RegExp("(?i)abc");                         // 🛑 SyntaxError: Invalid group

// ④ 不支持：原子组、占有量词、条件分支、递归
// new RegExp("(?>a)");        // 🛑 Invalid group
// new RegExp("a*+");          // 🛑 Nothing to repeat
// new RegExp("(?(1)a|b)");    // 🛑 Invalid group

// ⑤ \d \w 永远 ASCII，\s 不是；\p{...} 要 u 或 v
/^\d+$/.test("٣");                                // false
/^\w+$/u.test("汉字");                            // false
/^\s$/.test("\u00a0");                            // true（NBSP 属于 WhiteSpace）
/^\d+$/u.test("٣");                               // false（加了 u 也一样）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// ① 定界符 + 修饰符：/pattern/flags
preg_match('/^(?<y>\d{4})-(?<m>\d{2})$/', '2026-09', $m);
echo $m['y'];                                     // 2026

// ② 修饰符 13 个：i m s x A D S U X J u n r
preg_match('/abc/i', 'ABC');                      // 1    忽略大小写
preg_match('/^b/m', "a\nb");                      // 1    多行
preg_match('/a.b/s', "a\nb");                     // 1    . 匹配换行
preg_match('/a b/x', 'ab');                       // 1    扩展模式
preg_match('/\w/u', '汉');                        // 1    u = UTF-8 + UCP
preg_match('/\w/', '汉');                         // 0    不加 u 时 \w 是 ASCII

// ③ PCRE2 全套：环视、原子组、占有量词、条件分支、递归
preg_match('/(?<=foo)bar/', 'foobar');            // 1    后向环视（可以变长）
preg_match('/(?>a*)a/', 'aaa');                   // 0    原子组
preg_match('/a*+a/', 'aaa');                      // 0    占有量词
preg_match('/(a)(?(1)b|c)/', 'ab');               // 1    条件分支
preg_match('/^(\((?:[^()]|(?1))*\))$/', '(a(b))'); // 1  递归子模式

// ④ PHP 8.5 起 \K 不能再出现在环视里（扩展的默认编译选项不再包含 PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK）
// preg_match('/(?=a\K)/', 'a');                  // 🛑 编译错误

// ⑤ 字符类交集/减法：PHP 8.5 打包 PCRE2 10.44，而 && -- ~~ 要 PCRE2 10.45+
preg_match('/^[a-z&&[^aeiou]]$/', '&]');          // 1（&& 被当普通字符，不是减法）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# ① 字面量 /.../ 与 Regexp.new；引擎是 Onigmo
re = /(?<y>\d{4})-(?<m>\d{2})/
re.match("2026-09")[:y]                        # "2026"
Regexp.new("a+", Regexp::IGNORECASE)           # /a+/i

# ② \d \w \s 默认是 ASCII；Unicode 只能走 \p{...}
/\d/.match?("٣")                               # false
/\w/.match?("汉")                              # false
/\s/.match?("\u00a0")                          # false
/\p{Greek}+/.match?("αβγ")                     # true
/\p{Han}+/.match?("汉字")                      # true

# ③ 回溯引擎的全套
/(a)\1/.match?("aa")                           # true
/(?<=foo)bar/.match?("foobar")                 # true
/(?>a*)a/.match?("aaa")                        # false（原子组阻断回溯）
/a*+a/.match?("aaa")                           # false（占有量词）
/(a)(?(1)b|c)/.match?("ab")                    # true（条件分支）
/\A(\((?:(\g<1>)?\)))\z/.match?("(())")        # true（\g<1> 子表达式调用）
/[a-z&&[^aeiou]]/.match?("b")                  # true（字符类交集）
/[a-z&&[^aeiou]]/.match?("a")                  # false

# ④ 后向环视必须定长
# /(?<=a+)b/                                   # 🛑 SyntaxError: invalid pattern in look-behind

# ⑤ 模式修饰符 i m x o 与常量
/abc/imx.options                               # 7（IGNORECASE=1 | EXTENDED=2 | MULTILINE=4）
Regexp::FIXEDENCODING; Regexp::NOENCODING      # 编码相关常量

# ⑥ 超时与线性时间判定（均自 Ruby 3.2 起）
Regexp.timeout                                 # nil（默认不超时）
Regexp.new("a+", timeout: 1.5).timeout         # 1.5
Regexp.linear_time?(/a/)                       # true
Regexp.linear_time?(/(a)\1/)                   # false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import Foundation

let s = "订单 A12 与 B7"
let re = #/\d+/#                                             // #/.../# 是无歧义的正则字面量

print(s.contains(re))                                        // true   部分匹配
print(s.wholeMatch(of: re) != nil, "12".wholeMatch(of: re) != nil)          // false true
print("12ab".prefixMatch(of: re) != nil, "a12".prefixMatch(of: re) != nil)  // true false

if let m = s.firstMatch(of: re) {                            // 返回 Regex<Output>.Match
    print(m.0, m.range.lowerBound.utf16Offset(in: s), m.range.upperBound.utf16Offset(in: s))
}                                                            // 12 4 6
print(s.matches(of: re).map { String($0.0) })                // ["12", "7"]
print(s.ranges(of: re).map { s.distance(from: s.startIndex, to: $0.lowerBound) })   // [4, 10]

print("a1".matches(of: #/\d*/#).map { ($0.range.lowerBound.utf16Offset(in: "a1"), String($0.0)) })
// [(0, ""), (1, "1"), (2, "")]   空匹配在推进时也算一次结果

print("a\nb".matches(of: #/^\w+$/#.anchorsMatchLineEndings()).count)                // 2
print("a\nb".contains(#/a.b/#), "a\nb".contains(#/a.b/#.dotMatchesNewlines()))      // false true
print("ABC".contains(#/abc/#.ignoresCase()))                                        // true

let ns = try! NSRegularExpression(pattern: "[0-9]+")                                // 另一套老 API
let hits = ns.matches(in: s, range: NSRange(s.startIndex..., in: s))
print(hits.map { ($0.range.location, $0.range.length) })                            // [(4, 2), (10, 1)]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import (
	"fmt"
	"regexp"
)

func main() {
	s := "订单 A12 与 B7"
	re := regexp.MustCompile(`\d+`)

	fmt.Println(re.MatchString(s))            // true    部分匹配
	fmt.Println(re.FindString(s))             // 12
	fmt.Println(re.FindStringIndex(s))        // [8 10]  字节下标
	fmt.Println(re.FindAllString(s, -1))      // [12 7]  n < 0 表示全部
	fmt.Println(re.FindAllString(s, 1))       // [12]    n >= 0 表示最多 n 个
	fmt.Println(re.FindAllStringIndex(s, -1)) // [[8 10] [16 17]]

	full := regexp.MustCompile(`^\d+$`)                // Go 没有 fullmatch，只能锚定
	fmt.Println(full.MatchString("12"), full.MatchString("12a"))   // true false

	empty := regexp.MustCompile(`\d*`)
	fmt.Println(empty.FindAllStringIndex("a1", -1))   // [[0 0] [1 2]]
	fmt.Println(empty.FindAllStringIndex("ab", -1))   // [[0 0] [1 1] [2 2]]

	ci := regexp.MustCompile(`(?i)abc`)
	ml := regexp.MustCompile(`(?m)^\w+$`)
	fmt.Println(ci.MatchString("ABC"), len(ml.FindAllString("a\nb", -1)))   // true 2

	u := regexp.MustCompile(`\w+`)
	fmt.Println(u.FindString("中"), u.FindStringIndex("中"))   // (空) []   \w 在 Go 里只含 ASCII

	fmt.Println(regexp.MustCompile(`a|ab`).FindString("ab"))   // a   左边优先（leftmost-first）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import re

s = "订单 A12 与 B7"
re.search(r"\d+", s).group()        # '12'   部分匹配：任意位置命中
re.match(r"\d+", s)                  # None   match 只从下标 0 开始，且不要求到结尾
re.match(r"\d+", "12abc").group()    # '12'
re.fullmatch(r"\d+", "12abc")        # None   fullmatch 才要求整串
re.fullmatch(r"\d+", "12").group()   # '12'
re.search(r"\d+\z", "12\n")          # None   \z 是 3.14 新增的串尾锚，\Z 现在与它同义

m = re.search(r"\d+", s)
(m.span(), m.start(), m.end())       # ((4, 6), 4, 6)   按码点计，不是字节
re.findall(r"\d+", s)                # ['12', '7']
[x.span() for x in re.finditer(r"\d+", s)]      # [(4, 6), (10, 11)]
[x.span() for x in re.finditer(r"\d*", "a1")]   # [(0, 0), (1, 2), (2, 2)]

bool(re.search(r"abc", "ABC", re.I))        # True   忽略大小写
len(re.findall(r"^\w+$", "a\nb", re.M))     # 2      多行：^ $ 按行
len(re.findall(r"^\w+$", "a\nb"))           # 0      默认 ^ $ 只匹配串首尾
bool(re.search(r"a.b", "a\nb", re.S))       # True   dotall
bool(re.search(r"a b  # 注释", "ab", re.X))  # True   扩展模式：空白与注释被忽略
re.fullmatch(r"\w", "中", re.A)             # None   关掉 Unicode 后 \w 只剩 ASCII
bool(re.fullmatch(r"\w", "中"))             # True   str 模式默认就是 Unicode

p = re.compile(r"\d+")               # 预编译一次，反复复用
(p.pattern, bool(p.flags & re.UNICODE))     # ('\\d+', True)
re.escape("a.b*c")                   # 'a\\.b\\*c'
re.search(r"(\d)(\d)", "x12").regs   # ((1, 3), (1, 2), (2, 3))   每个组的 (start, end)