JavaScript RegExp Constructor

What Is the RegExp Constructor?

new RegExp(pattern, flags?) creates a RegExp object from a pattern string and optional flags. Use it when the pattern is built at runtime; use a literal for fixed patterns.

new RegExp(pattern, flags?)

new RegExp("cat", "i")  →  /cat/i
new RegExp("\\d+")      →  /\d+/

literal (fixed):     /cat/i
constructor (dynamic): new RegExp(word, "gi")

regex.constructor === RegExp  →  true

How to Use new RegExp()

Pass a pattern string, optional flags, then use test / exec.

1. Build the pattern as a string (escape metacharacters if it comes from user input).
2. Call new RegExp(pattern, flags) — flags like "g", "i", "m".
3. Use the result with test(), exec(), or string methods like match.
4. For a constant pattern, prefer a literal /pattern/flags instead.

Pseudocode

pattern = string pattern
flags = optional flags string

if pattern is invalid:
    throw SyntaxError

return new RegExp object with that pattern and flags
// same kind of object as /pattern/flags

Cheat Sheet

Keep these facts handy while creating regexes.

Live Preview

Build a RegExp with the constructor and test it against sample text.

regex = new RegExp("cat", "i")
→ /cat/i

test("The Cat sat") → true

JavaScript Examples

Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.

const regex = new RegExp("cat", "i");

console.log(regex.toString());     // "/cat/i"
console.log(regex.test("The Cat")); // true
console.log(regex.constructor === RegExp); // true

/cat/i
true
true

const word = "fun";
const regex = new RegExp(word, "i");

console.log(regex.test("CodeToFun")); // true
console.log(regex.test("boring"));    // false

true
false

const fromLiteral = /\d+/;
const fromCtor = new RegExp("\\d+");

console.log(fromLiteral.test("42")); // true
console.log(fromCtor.test("42"));    // true
console.log(fromLiteral instanceof RegExp); // true
console.log(fromCtor instanceof RegExp);    // true

true
true
true
true

Performance Notes

Creating a RegExp has a compile cost. Build it once outside a hot loop when the pattern does not change. Literals are fine and often clearer for constants.

Key Takeaways