⌘ K
javascript · ruby · onigmo · two-way · local

Translate regex between JavaScript and Ruby

Convert named groups, inline flags, and possessive quantifiers in both directions. Warnings flag Ruby-only features like atomic groups and \\A/\\Z anchors that JavaScript lacks.

JS ↔ Ruby Regex Converter
Direction
JavaScript regex
Ruby regex
Conversions & warnings (2)
  • info(?<name>...) works identically in Ruby (1.9+). Ruby also accepts (?'name'...).
  • infoRuby Onigmo supports possessive quantifiers (*+, ++) and atomic groups (?>...) JS lacks.
Quick Start

How to convert between JavaScript and Ruby

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 → Ruby or Ruby → 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 -> Ruby
    loaded · ECMAScriptPCRE · ready
  2. 02

    Paste pattern

    Drop your regex in. Named groups (?<n>) / (?'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 and Ruby-only features. Warnings call out possessive quantifiers (++) and \A/\Z that JS 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
    (?<name>\w+)
    matches · livediff · ready
  4. 04

    Copy result

    Grab the converted pattern with one click and drop it into your Ruby code.

    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 Perl ConverterJs Pcre ConverterRegex Flavour DetectorRegex TesterRegex BuilderRegex Flavour Matrix
Use Cases

When you need Onigmo-aware translation

Bridging JavaScript regex with Ruby's Onigmo engine — used in Ruby, mruby, and many CRubies.

Port to Ruby

Reuse a JS validator inside a Rails model or Sinatra route. 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

Rails validations

Translate JS form-validation patterns into Active Record format validators. 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

Migration scripts

Lift JS data-cleanup regex into rake tasks during a migration. 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 Ruby-specific features won't survive a JS roundtrip. 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 possessive quantifiers

Catch ++ and *+ in Ruby code before porting to a JS frontend. 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 Ruby. 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

The regex engine inside Ruby 2.0+ — a fork of Oniguruma with extra features. It's a backtracking engine that supports almost everything PCRE does plus a few Ruby-only constructs.
Possessive quantifiers (++, *+, ?+), atomic groups ((?>...)), and \A/\Z absolute anchors. The converter warns when these are detected going to JS.
Yes. JS uses (?<name>...). Ruby accepts both (?<name>) and (?'name'), normalised to (?<name>) when going to JS.
Yes. Ruby's (?i), (?m), (?x) inline flags are stripped when going to JS, with a warning explaining the implicit flag change.
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!