Flavours compared: porting a pattern safely

Python 3.14.8 · template/template.py

"""The same idea, "group 1, then the letter x", as Python replacement templates, on the subject 'ab'."""

import re

rows = [
    (r"(a)", "$1x"),
    (r"(a)", r"\1x"),
    (r"(a)", r"\g<1>x"),
    (r"(a)", r"\g<1>0"),
    (r"(a)", r"\10"),
    (r"(?P<g>a)", r"\g<g>x"),
]

for pattern, template in rows:
    try:
        result = re.sub(pattern, template, "ab", count=1)
    except re.PatternError as error:
        result = f"PatternError: {error}"
    print(f"{pattern:9} {template:7} -> {result}")

(a)       $1x     -> $1xb
(a)       \1x     -> axb
(a)       \g<1>x  -> axb
(a)       \g<1>0  -> a0b
(a)       \10     -> PatternError: invalid group reference 10 at position 1
(?P<g>a)  \g<g>x  -> axb

Go 1.27.1 · template/template.go

// The same idea, "group 1, then the letter x", as Go replacement templates, on the subject "ab".
package main

import (
	"fmt"
	"regexp"
)

func main() {
	group := regexp.MustCompile(`(a)`)
	named := regexp.MustCompile(`(?P<g>a)`)

	show := func(pattern, template, result string) {
		fmt.Printf("%-9s %-7s -> %s\n", pattern, template, result)
	}

	show("(a)", "$1x", group.ReplaceAllString("ab", "$1x"))
	show("(a)", "${1}x", group.ReplaceAllString("ab", "${1}x"))
	show("(a)", "${1}0", group.ReplaceAllString("ab", "${1}0"))
	show("(a)", "$10", group.ReplaceAllString("ab", "$10"))
	show("(a)", "$$1x", group.ReplaceAllString("ab", "$$1x"))
	show("(?P<g>a)", "$gx", named.ReplaceAllString("ab", "$gx"))
	show("(?P<g>a)", "${g}x", named.ReplaceAllString("ab", "${g}x"))
	show("(a)", "literal $1x", group.ReplaceAllLiteralString("ab", "$1x"))
}

(a)       $1x     -> b
(a)       ${1}x   -> axb
(a)       ${1}0   -> a0b
(a)       $10     -> b
(a)       $$1x    -> $1xb
(?P<g>a)  $gx     -> b
(?P<g>a)  ${g}x   -> axb
(a)       literal $1x -> $1xb

PHP 8.5.11 · template/template.php

<?php
// The same idea, "group 1, then the letter x", as PHP replacement templates, on the subject 'ab'.
$rows = [
    ['/(a)/', '$1x'],
    ['/(a)/', '${1}x'],
    ['/(a)/', '\1x'],
    ['/(a)/', '${1}1'],
    ['/(a)/', '$11'],
    ['/(?P<g>a)/', '${g}x'],
];

foreach ($rows as [$pattern, $template]) {
    $result = preg_replace($pattern, $template, 'ab', 1);
    printf("%-12s %-6s -> %s\n", $pattern, $template, $result);
}

/(a)/        $1x    -> axb
/(a)/        ${1}x  -> axb
/(a)/        \1x    -> axb
/(a)/        ${1}1  -> a1b
/(a)/        $11    -> b
/(?P<g>a)/   ${g}x  -> ${g}xb

Python 3.14.8 · rows/rows.py

"""Eight rows of the flavour matrix, asked of Python's re. Every row prints one line: what was asked, what came back.
A pattern the engine refuses prints the name of the error instead of a result."""

import json
import re


def attempt(label, run):
    try:
        outcome = run()
        if isinstance(outcome, bool):
            outcome = "true" if outcome else "false"
    except re.PatternError as error:
        outcome = f"error PatternError: {error}"
    print(f"{label:28} {outcome}")


attempt('b$ on "ab\\n"', lambda: bool(re.search(r"b$", "ab\n")))
attempt('b\\Z on "ab\\n"', lambda: bool(re.search(r"b\Z", "ab\n")))
attempt('b\\z on "ab\\n"', lambda: bool(re.search(r"b\z", "ab\n")))
attempt("replace a* by - in baac", lambda: re.sub(r"a*", "-", "baac"))
attempt("split ([,;]) on a,b;c", lambda: json.dumps(re.split(r"([,;])", "a,b;c")))
attempt("a{,2} in aaa", lambda: json.dumps(re.findall(r"a{,2}", "aaa")))
attempt("named group (?<n>a)", lambda: re.compile(r"(?<n>a)").pattern)
attempt("named group (?P<n>a)", lambda: re.compile(r"(?P<n>a)").pattern)
attempt("lookbehind (?<=a+)b", lambda: re.search(r"(?<=a+)b", "aab"))

b$ on "ab\n"                 true
b\Z on "ab\n"                false
b\z on "ab\n"                false
replace a* by - in baac      -b--c-
split ([,;]) on a,b;c        ["a", ",", "b", ";", "c"]
a{,2} in aaa                 ["aa", "a", ""]
named group (?<n>a)          error PatternError: unknown extension ?<n at position 1
named group (?P<n>a)         (?P<n>a)
lookbehind (?<=a+)b          error PatternError: look-behind requires fixed-width pattern

Go 1.27.1 · rows/rows.go

// Eight rows of the flavour matrix, asked of Go's regexp. Every row prints one line: what was asked, what came back.
// A pattern the engine refuses prints the error Compile returned instead of a result.
package main

import (
	"encoding/json"
	"fmt"
	"regexp"
)

func attempt(label, pattern string, run func(re *regexp.Regexp) string) {
	re, err := regexp.Compile(pattern)
	outcome := ""
	if err != nil {
		outcome = "error " + err.Error()
	} else {
		outcome = run(re)
	}
	fmt.Printf("%-28s %s\n", label, outcome)
}

func list(values []string) string {
	text, _ := json.Marshal(values)
	return string(text)
}

func main() {
	attempt(`b$ on "ab\n"`, `b$`, func(re *regexp.Regexp) string { return fmt.Sprint(re.MatchString("ab\n")) })
	attempt(`b\Z on "ab\n"`, `b\Z`, func(re *regexp.Regexp) string { return fmt.Sprint(re.MatchString("ab\n")) })
	attempt(`b\z on "ab\n"`, `b\z`, func(re *regexp.Regexp) string { return fmt.Sprint(re.MatchString("ab\n")) })
	attempt("replace a* by - in baac", `a*`, func(re *regexp.Regexp) string { return re.ReplaceAllString("baac", "-") })
	attempt("split ([,;]) on a,b;c", `([,;])`, func(re *regexp.Regexp) string { return list(re.Split("a,b;c", -1)) })
	attempt("a{,2} in aaa", `a{,2}`, func(re *regexp.Regexp) string { return list(re.FindAllString("aaa", -1)) })
	attempt("named group (?<n>a)", `(?<n>a)`, func(re *regexp.Regexp) string { return re.String() })
	attempt("named group (?P<n>a)", `(?P<n>a)`, func(re *regexp.Regexp) string { return re.String() })
	attempt("lookbehind (?<=a+)b", `(?<=a+)b`, func(re *regexp.Regexp) string { return list(re.FindAllString("aab", -1)) })
}

b$ on "ab\n"                 false
b\Z on "ab\n"                error error parsing regexp: invalid escape sequence: `\Z`
b\z on "ab\n"                false
replace a* by - in baac      -b-c-
split ([,;]) on a,b;c        ["a","b","c"]
a{,2} in aaa                 null
named group (?<n>a)          (?<n>a)
named group (?P<n>a)         (?P<n>a)
lookbehind (?<=a+)b          error error parsing regexp: invalid named capture: `(?<=a+)b`

PHP 8.5.11 · rows/rows.php

<?php
// Eight rows of the flavour matrix, asked of PHP's preg functions (PCRE2). Every row prints one line: what was
// asked, what came back. A pattern PCRE2 refuses prints the warning text and "false".
set_error_handler(function (int $level, string $message): bool {
    echo "  warning: ", preg_replace('/^[a-z_]+\(\): /', '', $message), "\n";
    return true;
});

function attempt(string $label, callable $run): void
{
    $outcome = $run();
    if (is_bool($outcome)) {
        $outcome = $outcome ? 'true' : 'false';
    }
    printf("%-28s %s\n", $label, $outcome);
}

attempt('b$ on "ab\n"', fn() => preg_match('/b$/', "ab\n") === 1);
attempt('b\Z on "ab\n"', fn() => preg_match('/b\Z/', "ab\n") === 1);
attempt('b\z on "ab\n"', fn() => preg_match('/b\z/', "ab\n") === 1);
attempt('replace a* by - in baac', fn() => preg_replace('/a*/', '-', 'baac'));
attempt('split ([,;]) on a,b;c', fn() => json_encode(preg_split('/([,;])/', 'a,b;c')));
attempt('a{,2} in aaa', fn() => json_encode(preg_match_all('/a{,2}/', 'aaa', $found) ? $found[0] : null));
attempt('named group (?<n>a)', fn() => preg_match('/(?<n>a)/', 'a') === 1 ? '(?<n>a)' : 'no');
attempt('named group (?P<n>a)', fn() => preg_match('/(?P<n>a)/', 'a') === 1 ? '(?P<n>a)' : 'no');
attempt('lookbehind (?<=a+)b', fn() => preg_match('/(?<=a+)b/', 'aab') === 1);

b$ on "ab\n"                 true
b\Z on "ab\n"                true
b\z on "ab\n"                false
replace a* by - in baac      -b--c-
split ([,;]) on a,b;c        ["a","b","c"]
a{,2} in aaa                 ["aa","a",""]
named group (?<n>a)          (?<n>a)
named group (?P<n>a)         (?P<n>a)
  warning: Compilation failed: length of lookbehind assertion is not limited at offset 0
lookbehind (?<=a+)b          false

PCRE2 10.49 · rows/rows_pcre2.py

"""The pattern rows of the matrix in PCRE2 10.49, through pcre2test. A matched line starts with " 0:"; "No match"
means the pattern compiled and found nothing; "Failed:" means the pattern was refused."""

from pcre2_session import run

run(r'''
/b$/
    ab\n

/b\Z/
    ab\n

/b\z/
    ab\n

/a{,2}/g
    aaa

/(?<n>a)/
    a

/(?P<n>a)/
    a

/(?<=a+)b/
    aab
''')

$ pcre2test -q patterns.txt   (PCRE2 10.49)
/b$/
    ab\n
 0: b

/b\Z/
    ab\n
 0: b

/b\z/
    ab\n
No match

/a{,2}/g
    aaa
 0: aa
 0: a
 0: 

/(?<n>a)/
    a
 0: a
 1: a

/(?P<n>a)/
    a
 0: a
 1: a

/(?<=a+)b/
Failed: error 125 at offset 0: length of lookbehind assertion is not limited
        here: |-->| (?<=a+)b
    aab

Python 3.14.8 · silent/silent.py

"""The same patterns as the JavaScript run, asked of Python's re: refused, or a different meaning."""

import json
import re


def show(label, run):
    try:
        outcome = json.dumps(run())
    except re.PatternError as error:
        outcome = f"PatternError: {error}"
    print(f"{label:26} {outcome}")


show(r'\Ga on "Ga"', lambda: re.findall(r"\Ga", "Ga"))
show(r'\Ga on "aab"', lambda: re.findall(r"\Ga", "aab"))
show(r'b\Z on "abZ"', lambda: bool(re.search(r"b\Z", "abZ")))
show(r'b\z on "abz"', lambda: bool(re.search(r"b\z", "abz")))
show(r'^a{,2}$ on "aa"', lambda: bool(re.search(r"^a{,2}$", "aa")))
show(r'^a{,2}$ on "a{,2}"', lambda: bool(re.search(r"^a{,2}$", "a{,2}")))
show(r'^a{0,2}$ on "aa"', lambda: bool(re.search(r"^a{0,2}$", "aa")))

\Ga on "Ga"                PatternError: bad escape \G at position 0
\Ga on "aab"               PatternError: bad escape \G at position 0
b\Z on "abZ"               false
b\z on "abz"               false
^a{,2}$ on "aa"            true
^a{,2}$ on "a{,2}"         false
^a{0,2}$ on "aa"           true

Go 1.27.1 · silent/silent.go

// The same patterns as the JavaScript run, asked of Go's regexp: refused, or a different meaning.
package main

import (
	"encoding/json"
	"fmt"
	"regexp"
)

func show(label, pattern string, run func(re *regexp.Regexp) any) {
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Printf("%-26s %s\n", label, err)
		return
	}
	text, _ := json.Marshal(run(re))
	fmt.Printf("%-26s %s\n", label, text)
}

func main() {
	find := func(subject string) func(re *regexp.Regexp) any {
		return func(re *regexp.Regexp) any { return re.FindAllString(subject, -1) }
	}
	test := func(subject string) func(re *regexp.Regexp) any {
		return func(re *regexp.Regexp) any { return re.MatchString(subject) }
	}

	show(`\Ga on "Ga"`, `\Ga`, find("Ga"))
	show(`\Ga on "aab"`, `\Ga`, find("aab"))
	show(`b\Z on "abZ"`, `b\Z`, test("abZ"))
	show(`b\z on "abz"`, `b\z`, test("abz"))
	show(`^a{,2}$ on "aa"`, `^a{,2}$`, test("aa"))
	show(`^a{,2}$ on "a{,2}"`, `^a{,2}$`, test("a{,2}"))
	show(`^a{0,2}$ on "aa"`, `^a{0,2}$`, test("aa"))
}

\Ga on "Ga"                error parsing regexp: invalid escape sequence: `\G`
\Ga on "aab"               error parsing regexp: invalid escape sequence: `\G`
b\Z on "abZ"               error parsing regexp: invalid escape sequence: `\Z`
b\z on "abz"               false
^a{,2}$ on "aa"            false
^a{,2}$ on "a{,2}"         true
^a{0,2}$ on "aa"           true

PHP 8.5.11 · silent/silent.php

<?php
// The same patterns as the JavaScript run, asked of PHP's preg functions (PCRE2).
function show(string $label, mixed $result): void
{
    printf("%-26s %s\n", $label, json_encode($result));
}

show('\Ga on "Ga"', preg_match_all('/\Ga/', 'Ga', $found) ? $found[0] : []);
show('\Ga on "aab"', preg_match_all('/\Ga/', 'aab', $found) ? $found[0] : []);
show('b\Z on "abZ"', preg_match('/b\Z/', 'abZ') === 1);
show('b\z on "abz"', preg_match('/b\z/', 'abz') === 1);
show('^a{,2}$ on "aa"', preg_match('/^a{,2}$/', 'aa') === 1);
show('^a{,2}$ on "a{,2}"', preg_match('/^a{,2}$/', 'a{,2}') === 1);
show('^a{0,2}$ on "aa"', preg_match('/^a{0,2}$/', 'aa') === 1);

\Ga on "Ga"                []
\Ga on "aab"               ["a","a"]
b\Z on "abZ"               false
b\z on "abz"               false
^a{,2}$ on "aa"            true
^a{,2}$ on "a{,2}"         false
^a{0,2}$ on "aa"           true

Python 3.14.8 · harness/port_check.py

"""A differential test: the same six cases as the JavaScript run, run against Python's re.
Each case is a pattern, a subject and the result it is meant to give. "copied" is the JavaScript pattern and template
as they stand; "ported" is the rewrite. One line per case, in the same layout in every engine."""

import re

cases = [
    # name, op, subject, want, (copied pattern, template), (ported pattern, template)
    ("swap-groups", "replace", "ab@cd", "cd_ab", (r"(\w+)@(\w+)", "$2_$1"), (r"(\w+)@(\w+)", r"\2_\1")),
    ("word-scope", "test", "café", "false", (r"^\w+$", None), (r"^[A-Za-z0-9_]+$", None)),
    ("final-newline", "test", "42\n", "false", (r"^\d+$", None), (r"^\d+\Z", None)),
    ("named-groups", "replace", "7314-05", "05/7314",
     (r"(?<head>\d{4})-(?<tail>\d{2})", "$<tail>/$<head>"), (r"(?P<head>\d{4})-(?P<tail>\d{2})", r"\g<tail>/\g<head>")),
    ("keep-separators", "split", "a,b;c", "a|,|b|;|c", (r"([,;])", None), (r"([,;])", None)),
    ("after-prefix", "find", "Rs 40, Rs 250 and 7", "40|250", (r"(?<=Rs )\d+", None), (r"(?<=Rs )\d+", None)),
]

ops = {
    "replace": lambda p, t, s: re.sub(p, t, s),
    "test": lambda p, t, s: str(bool(re.search(p, s))).lower(),
    "split": lambda p, t, s: "|".join(re.split(p, s)),
    "find": lambda p, t, s: "|".join(re.findall(p, s)),
}


def attempt(op, version, subject, want):
    pattern, template = version
    try:
        got = ops[op](pattern, template, subject)
    except re.PatternError:
        return False, "error PatternError"
    return got == want, got


print("case                 copied  ported")
wrong = []
for number, (name, op, subject, want, copied, ported) in enumerate(cases, 1):
    first = attempt(op, copied, subject, want)
    second = attempt(op, ported, subject, want)
    print(f"{number} {name:18} {'ok' if first[0] else 'DIFF':7} {'ok' if second[0] else 'DIFF'}")
    if not first[0]:
        wrong.append(f"{number} {name:18} got {first[1]!r}, want {want!r}")
print("copied patterns that differ:" + ("\n" + "\n".join(wrong) if wrong else " none"))

case                 copied  ported
1 swap-groups        DIFF    ok
2 word-scope         DIFF    ok
3 final-newline      DIFF    ok
4 named-groups       DIFF    ok
5 keep-separators    ok      ok
6 after-prefix       ok      ok
copied patterns that differ:
1 swap-groups        got '$2_$1', want 'cd_ab'
2 word-scope         got 'true', want 'false'
3 final-newline      got 'true', want 'false'
4 named-groups       got 'error PatternError', want '05/7314'

Go 1.27.1 · harness/port_check.go

// A differential test: the same six cases as the JavaScript run, run against Go's regexp.
// "copied" is the JavaScript pattern and template as they stand; "ported" is the rewrite. One line per case,
// in the same layout in every engine.
package main

import (
	"fmt"
	"regexp"
	"strings"
)

type version struct{ pattern, template, op string }

type testCase struct {
	name, subject, want string
	copied, ported      version
}

// splitKeep is the port of JavaScript's split with a captured separator: Go's Split drops the separators.
func splitKeep(re *regexp.Regexp, subject string) string {
	var parts []string
	last := 0
	for _, at := range re.FindAllStringIndex(subject, -1) {
		parts = append(parts, subject[last:at[0]], subject[at[0]:at[1]])
		last = at[1]
	}
	return strings.Join(append(parts, subject[last:]), "|")
}

func run(v version, subject string) (got string, failed bool) {
	re, err := regexp.Compile(v.pattern)
	if err != nil {
		return "error compile", true
	}
	switch v.op {
	case "replace":
		return re.ReplaceAllString(subject, v.template), false
	case "test":
		return fmt.Sprint(re.MatchString(subject)), false
	case "split":
		return strings.Join(re.Split(subject, -1), "|"), false
	case "split-keep":
		return splitKeep(re, subject), false
	default: // find: group 1 when the pattern has a group, else the whole match
		var found []string
		for _, m := range re.FindAllStringSubmatch(subject, -1) {
			if len(m) > 1 {
				found = append(found, m[1])
			} else {
				found = append(found, m[0])
			}
		}
		return strings.Join(found, "|"), false
	}
}

func main() {
	cases := []testCase{
		{"swap-groups", "ab@cd", "cd_ab", version{`(\w+)@(\w+)`, "$2_$1", "replace"}, version{`(\w+)@(\w+)`, "${2}_${1}", "replace"}},
		{"word-scope", "café", "false", version{`^\w+$`, "", "test"}, version{`^\w+$`, "", "test"}},
		{"final-newline", "42\n", "false", version{`^\d+$`, "", "test"}, version{`^\d+$`, "", "test"}},
		{"named-groups", "7314-05", "05/7314", version{`(?<head>\d{4})-(?<tail>\d{2})`, "$<tail>/$<head>", "replace"}, version{`(?<head>\d{4})-(?<tail>\d{2})`, "${tail}/${head}", "replace"}},
		{"keep-separators", "a,b;c", "a|,|b|;|c", version{`([,;])`, "", "split"}, version{`([,;])`, "", "split-keep"}},
		{"after-prefix", "Rs 40, Rs 250 and 7", "40|250", version{`(?<=Rs )\d+`, "", "find"}, version{`Rs (\d+)`, "", "find"}},
	}

	fmt.Println("case                 copied  ported")
	var wrong []string
	for i, c := range cases {
		first, firstFailed := run(c.copied, c.subject)
		second, _ := run(c.ported, c.subject)
		mark := func(got string) string {
			if got == c.want {
				return "ok"
			}
			return "DIFF"
		}
		fmt.Printf("%d %-18s %-7s %s\n", i+1, c.name, mark(first), mark(second))
		if first != c.want || firstFailed {
			wrong = append(wrong, fmt.Sprintf("%d %-18s got %q, want %q", i+1, c.name, first, c.want))
		}
	}
	if len(wrong) == 0 {
		fmt.Println("copied patterns that differ: none")
		return
	}
	fmt.Println("copied patterns that differ:\n" + strings.Join(wrong, "\n"))
}

case                 copied  ported
1 swap-groups        DIFF    ok
2 word-scope         ok      ok
3 final-newline      ok      ok
4 named-groups       DIFF    ok
5 keep-separators    DIFF    ok
6 after-prefix       DIFF    ok
copied patterns that differ:
1 swap-groups        got "ab", want "cd_ab"
4 named-groups       got "$<tail>/$<head>", want "05/7314"
5 keep-separators    got "a|b|c", want "a|,|b|;|c"
6 after-prefix       got "error compile", want "40|250"