⌘ K
javascript · go · re2 · two-way · local

Translate regex between JavaScript and Go

Convert named groups and inline flags in both directions. Warnings flag JS-only features — lookarounds, backreferences — that Go's RE2 engine cannot express.

JS ↔ Go Regex Converter
Direction
JavaScript regex
Go regexp (RE2)
Conversions & warnings (1)
  • convert(?<name>) → (?P<name>) (Go uses Python-style syntax)
Quick Start

How to convert between JavaScript and Go

Paste a regex in either flavour, pick the direction, and read the translated pattern alongside a list of conversions and warnings.

  1. 01

    Pick a direction

    Choose JS → Go or Go → JS. The shell switches placeholders and labels automatically.

    Patterns are parsed with the JavaScript RegExp constructor, so syntax errors surface immediately and engine quirks like Unicode property escapes (\p{L}) work when the u flag is on.

    patternECMAScriptliteralregex
    input · literaldirection · regex
    JS -> Go
    loaded · ECMAScriptPCRE · ready
  2. 02

    Paste pattern

    Drop your regex in. Named groups (?<n>) ↔ (?P<n>) and inline flags are examined.

    Each flag character mirrors the ECMAScript literal: g enables iteration, i folds case, m anchors per line, s lets . match newlines, u unlocks proper Unicode, y is sticky, and d emits indices.

    flagsoptionsg · i · mlive
    config · optionsregex · flags
    (?<name>\w+)
    flags applied · liveECMA · live
  3. 03

    Read translation

    Conversions list rewrites like (?<name>) becoming (?P<name>). Warnings flag lookarounds and backreferences that RE2 rejects.

    Conversions translate flavour-specific constructs (lookarounds, named groups, character classes) — the converter flags anything that has no equivalent in the target engine.

    convertflavourPCRE · RE2diff
    run · outputdiff · converted
    (?P<name>\w+)
    matches · livediff · ready
  4. 04

    Copy result

    Grab the converted pattern with one click and drop it into your Go service.

    Copy writes via navigator.clipboard.writeText; downloads use a Blob and object URL, so nothing transits the network and the output is byte-identical to what you see on screen.

    copyexportclipboardblob
    export · exportedready · saved
    Copied
    ready to shipsuccess
Pro tips

Regex patterns that don't melt down

Use named groups

(?<year>\d{4}) reads better than $1 and survives reordering. Supported in ECMAScript 2018+.

Anchor strictly

Use ^/$ with the m flag when matching whole lines. Without anchors, partial matches sneak through.

Avoid catastrophic backtracking

Nested quantifiers like (a+)+ can explode. Run patterns through ReDoS Detector first.

Escape every literal

Backslash any meta character you want literally: \.\$\^\*\+\?\(\)\[\]\{\}\|\\.

Test edge cases

Empty string, single character, unicode, the maximum length you expect — write fixtures for each.

Patterns aren&rsquo;t parsers

Don’t parse HTML, JSON, or balanced parens with regex. Use a proper parser when the grammar is recursive.

Related toolsJs Rust ConverterJs Pcre ConverterRegex Flavour DetectorRegex TesterRegex BuilderRegex Flavour Matrix
Use Cases

When you need RE2-safe translation

Bridging JavaScript regex with Go's RE2 engine — same engine used in CockroachDB, Kubernetes, gVisor.

Port to Go

Reuse a JS regex inside a Go HTTP handler without RE2 surprises. Compiles through the JavaScript RegExp constructor — engine quirks (Unicode property escapes, sticky matching, named groups) work when their flags are on. Error messages cite the exact position of any syntax issue.

ReDoS-safe

Kubernetes configs

Translate path patterns for Ingress rules and admission controllers. Pairs with the ReDoS detector to catch catastrophic backtracking before you deploy. A pattern that handles 1k-character input fine can become a denial-of-service vector on attacker-controlled 1M-character input.

k8s

CockroachDB filters

Lift JS regex into SQL queries running RE2 under the hood. Output exports as JavaScript, Python re, Java util.regex, .NET System.Text.RegularExpressions, PCRE, and POSIX — language quirks are highlighted on conversion so you don't ship a JS-only pattern to a Go service.

spec-grade

Document differences

Show colleagues which JS features RE2 refuses to compile. Capture groups (named or numbered) round-trip cleanly into replacement strings, JSON output, or CSV extraction without re-typing. Backreferences ($1, ${name}) preserve semantics across languages.

cross-engine

Audit lookarounds

Catch (?=...) and \1 backrefs before deploying to RE2 systems. Test against edge cases — empty input, single character, max length, multibyte boundaries — to catch off-by-one and zero-length match bugs before they reach production.

test-ready

Cross-language tests

Verify the same pattern behaves identically in JS and Go. All matching runs client-side so secret patterns never leave the browser. Useful when the pattern itself is sensitive (PII regexes, internal data formats, security filters).

production-ready
FAQ

Frequently asked questions

Google's linear-time regex engine — used by Go's standard library, Cloudflare WAF, Vitess, and many others. It guarantees no catastrophic backtracking by rejecting features that need it.
RE2 doesn't support backreferences (\1, \k<name>) or lookarounds ((?=...), (?<=...), (?!...), (?<!...)). The converter emits warnings when these appear.
Yes. JS uses (?<name>...) while Go's RE2 uses (?P<name>...). The converter rewrites between the two forms automatically.
Yes. Inline flags like (?i) work in both engines and pass through unchanged when supported.
No. The conversion runs entirely in your browser.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!