JavaScript RegExp constructor Property

What You’ll Learn

Every RegExp object exposes a constructor property pointing at the built-in RegExp function. This guide shows how to read it, use it for type checks, compare it with instanceof, and know when simpler patterns are better.

Introduction

When you write /hello/i or new RegExp("hello", "i"), JavaScript builds a RegExp object. Like arrays and dates, that object carries a constructor property inherited from RegExp.prototype.

The property answers a simple question: which function created this object? For normal regexes the answer is RegExp. That is useful when you validate inputs, debug in the console, or read library code that inspects object types.

Understanding the constructor Property

The constructor property on a RegExp instance is a reference to the RegExp function itself:

• Read-only in practice — every standard RegExp reports RegExp unless code manually overrides the property (rare and discouraged).
• Same for literals and new — /abc/.constructor and new RegExp("abc").constructor both equal RegExp.
• Not the pattern — the pattern lives in source and flags; constructor identifies the object type, not its contents.
• Callable again — because it is the RegExp function, you can invoke new regex.constructor(pattern, flags), though direct new RegExp(...) reads better.

📝 Syntax

regex.constructor

What it returns

• The RegExp function for genuine RegExp instances.
• Another constructor (such as Object) for plain objects that merely look like regexes.

Common checks

regex.constructor === RegExp   // type hint
regex instanceof RegExp        // preferred check
typeof regex === "object" && regex instanceof RegExp

Examples Gallery

Open DevTools Console (F12) or use Try-it links. All examples use small RegExp objects you can inspect immediately.

const regex = /hello/i;

console.log(regex.constructor);           // [Function: RegExp]
console.log(regex.constructor === RegExp); // true

[Function: RegExp]
true

const regex = new RegExp("\\d+", "g");
const plain = { source: "fake", flags: "g" };

console.log(regex.constructor === RegExp);  // true
console.log(plain.constructor === RegExp);  // false
console.log(plain.constructor === Object);  // true

true
false
true

const regex = /test/;

console.log(regex instanceof RegExp);     // true
console.log(regex.constructor === RegExp); // true

function isRegExp(value) {
  return value instanceof RegExp;
}

true
true

const template = /placeholder/;
const built = new template.constructor("\\w+", "g");

console.log(built.source);       // \w+
console.log(built.flags);        // g
console.log(built.test("abc123")); // true

\w+
g
true

function runMatch(input, pattern) {
  if (!(pattern instanceof RegExp)) {
    return "Expected a RegExp instance.";
  }
  return pattern.test(input) ? "Match" : "No match";
}

console.log(runMatch("hello", /hel/));     // Match
console.log(runMatch("hello", "hel"));     // Expected a RegExp instance.

Match
Expected a RegExp instance.

🚀 Common Use Cases

• Console inspection — confirm an unknown value is a real RegExp while debugging.
• API validation — ensure helper functions receive RegExp instances, not strings.
• Library generics — clone or rebuild patterns via value.constructor when the type must stay dynamic.
• Learning prototypes — connect RegExp instances back to the constructor function concept.
• Reject impostors — plain objects mimicking source/flags fail constructor checks.
• Documentation reading — recognize constructor checks in open-source regex utilities.

📝 Notes

• constructor names the function that created the object—not the pattern string.
• Prefer instanceof RegExp over constructor === RegExp in application code.
• Literals and new RegExp() both yield RegExp as the constructor.
• Cross-realm regexes (e.g., from an iframe) may fail instanceof checks in some environments.
• Overriding constructor manually is possible but breaks expectations—avoid it.
• For duck-typed checks, also verify methods like test exist if you cannot use instanceof.

💡 Best Practices