Why is JS to Perl such a smooth conversion?

ECMAScript regex is heavily inspired by Perl, so most constructs map one-to-one. Character classes, quantifiers, named groups (? ), lookarounds, and backreferences all transfer unchanged.

What is Perl's (?{...}) and why is it removed?

(?{...}) executes arbitrary Perl code mid-match — a feature unique to Perl. The converter strips it because no other engine, including JavaScript, can run embedded code.

How are inline flags reconciled?

Perl accepts (?imsx) inline and per-group; JavaScript only accepts flags on the literal. The converter pulls inline flags out and lists them as a separate flag argument.

Does anything get uploaded?

No. Conversion runs entirely in your browser.

javascript · perl · two-way · local

Translate regex between JavaScript and Perl

Convert named groups, inline flags, and modifier-heavy patterns in both directions. Warnings flag Perl-only features like embedded code (?{...}) that JavaScript cannot represent.

JS ↔ Perl Regex Converter

Direction

JavaScript regex

Perl regex

^(?<word>\w+)\b

Conversions & warnings (3)

infoJS regex is largely Perl-compatible — most patterns transfer unchanged.
infoPerl uniquely supports embedded code (?{...}) and dynamic (??{...}) — JS has no equivalent.
infoModifier letters /i /m /s /x /g match. Perl's /x ignores whitespace; JS has no /x.

Quick Start

How to convert between JavaScript and Perl

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

01
Pick a direction
Choose JS → Perl or Perl → 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 -> Perl
```
loaded · ECMAScriptPCRE · ready
02
Paste pattern
Drop your regex in. Named groups (?<n>), inline flags (?i), and Perl-specific modifiers 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
03
Read translation
Conversions list rewrites. Warnings call out embedded code blocks (?{...}) and Perl-only modifiers JS cannot express.
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
```
(?<name>\w+)
```
matches · livediff · ready
04
Copy result
Grab the converted pattern with one click and drop it into your Perl script.
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’t parsers

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

Use Cases

When you need Perl-aware translation

Bridging JavaScript regex with Perl's PCRE-ancestor engine — the spec that birthed PCRE.

Port to Perl

Reuse a JS validator inside a legacy Perl script. 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

CPAN modules

Translate JS patterns for Mojolicious / Dancer routes. 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

Sysadmin scripts

Lift JS log-parsing regex into Perl one-liners. 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 Perl modifiers won't survive the JS conversion. 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 embedded code

Catch (?{...}) and (??{...}) before exposing them in any web context. 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 Perl. 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

How similar are JS and Perl regex?

Perl is the historical source of most modern regex flavours, including JavaScript. Common features work nearly identically — the differences are in niche constructs like embedded code, modifier letters, and named-group aliases.

What's (?{...})?

Embedded Perl code — executed mid-match. There is no JS equivalent. The converter emits a warning when it appears and strips the construct from the JS output.

Are named groups converted?

Yes. JS uses (?<name>...) and Perl 5.10+ accepts both (?<name>...) and (?'name'...). Both are normalised to (?<name>) when going to JS.

Are inline flags handled?

Yes. Perl-specific flag groupings like (?ix) are stripped when going to JS, with a warning explaining the implicit flag change.

Is anything sent to a server?

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.

47 in queue·8 shipped this month

Request queued. Thanks!