⌘ K
javascript · java pattern · two-way · local

Translate regex between JavaScript and Java

Convert between (?<name>) named groups, \Q...\E literal blocks, and inline flags. Warnings remind you to double backslashes for Java string literals.

JS ↔ Java Regex Converter
Direction
JavaScript regex
Java Pattern
Conversions & warnings (3)
  • infoJava Pattern supports (?<name>...) and \k<name> identically (Java 7+).
  • infoWhen embedding in a Java string literal, double every backslash: \d becomes "\\d".
  • infoJava supports \Q...\E literal blocks and inline (?i) flags JS lacks.
Quick Start

How to convert between JavaScript and Java regex

Paste your pattern, pick the direction, and the converter rewrites named groups and expands literal blocks.

  1. 01

    Pick direction

    JS → Java or Java → JS. Each form has a different idea about literal blocks.

    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 -> Java
    loaded · ECMAScriptPCRE · ready
  2. 02

    Paste regex

    Java 7+ named groups use the same syntax as JS, so most patterns transfer cleanly.

    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
    (?<id>[A-Z]{2})
    flags applied · liveECMA · live
  3. 03

    Read notes

    \Q...\E literal blocks expand when going to JS, and warnings call out inline flag differences.

    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
    \Qfile.txt\E
    matches · livediff · ready
  4. 04

    Copy result

    Drop the converted regex into your Java string literal — and remember to double the backslashes.

    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 Pcre ConverterJs Dotnet ConverterRegex Flavour DetectorRegex To JavaRegex TesterJs Go Converter
Use Cases

When JS regex meets Java

Reusing validators across front-end JS and Java back-ends.

Spring validators

Reuse a JS regex inside a @Pattern annotation. 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

Android apps

Translate web client patterns into Java/Kotlin Android code. 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.

ECMA-compliant

Codebase parity

Keep front-end and Java back-end regex in sync. 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

Literal blocks

Use \Q...\E to escape user input cleanly in Java. 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

Document patterns

Generate docs that show both flavours side-by-side. 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-stack debugging

Compare match behaviour between JS and Java implementations. 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

Yes — Java 7+ supports (?<name>...) identically to JavaScript.
Java's literal block — every character between the markers is treated literally. The converter expands them to escaped form when going to JS.
Java string literals need every backslash doubled. The converter shows the raw pattern; you double escape when pasting into Java source.
Java's inline (?i) flags are stripped going to JS — flags belong on the regex literal there. The notes panel explains the change.
No, the conversion runs entirely locally 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!