JavaScript RegExp ignoreCase Property

What You’ll Learn

The ignoreCase property is true when a RegExp was built with the i flag. That tells JavaScript to treat uppercase and lowercase letters as equivalent—so /hello/i matches "Hello", "HELLO", and "hello".

Introduction

By default, regular expressions are case-sensitive. The pattern /javascript/ matches lowercase "javascript" but not "JavaScript" or "JAVASCRIPT".

The ignoreCase (i) flag removes that restriction for letters. The ignoreCase property reports whether that flag is active. You set it at creation with /pattern/i or new RegExp("pattern", "i"), then read regex.ignoreCase in your code.

Understanding the ignoreCase Property

RegExp.prototype.ignoreCase is a read-only boolean:

• true — the i flag is set; letters match regardless of case.
• false — default behavior; A and a are different characters.
• Reflects flags — also visible in regex.flags when it contains "i".
• Immutable — you cannot flip ignoreCase after construction; create a new RegExp instead.
• Letters only — digits, spaces, and punctuation are unaffected by the i flag.

/hello/.test("Hello");   // false (case-sensitive)
/hello/i.test("Hello");  // true  (ignoreCase)

const regex = /error/i;
console.log(regex.ignoreCase); // true

How to Use ignoreCase in JavaScript

Set the flag at creation, then use normal RegExp methods. The engine handles case folding automatically:

const keyword = /warning/i;

keyword.test("WARNING");              // true
"Error and ERROR".match(/error/i);    // ["Error"]
"Yes YES yes".replace(/yes/gi, "ok"); // "ok ok ok"

Pair i with g when you need every case-variant match in a string, or with m for multiline text that also ignores case.

📝 Syntax

regex.ignoreCase

How to set ignoreCase mode (at creation)

/pattern/i
new RegExp("pattern", "i")
new RegExp("pattern", "gi")   // global + ignoreCase

Return value

• true if the i flag is present.
• false otherwise.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples show how ignoreCase changes matching for real-world text.

const withIgnoreCase = /hello/i;
const withoutIgnoreCase = /hello/;

console.log(withIgnoreCase.ignoreCase);     // true
console.log(withoutIgnoreCase.ignoreCase);  // false

true
false

const sensitive = /javascript/;
const flexible = /javascript/i;

console.log(sensitive.test("JavaScript"));  // false
console.log(flexible.test("JavaScript"));   // true
console.log(flexible.test("JAVASCRIPT"));   // true

false
true
true

const text = "Error found: ERROR and error.";

console.log(text.match(/error/g));   // null (case-sensitive)
console.log(text.match(/error/gi));  // ["Error", "ERROR", "error"]

null
["Error", "ERROR", "error"]

const log = "WARNING: Disk full. Warning again.";

const cleaned = log.replace(/warning/gi, "Notice");
console.log(cleaned);
// "Notice: Disk full. Notice again."

Notice: Disk full. Notice again.

const regex = new RegExp("hello", "gi");

console.log(regex.ignoreCase);           // true
console.log(regex.global);               // true
console.log(regex.flags);                // "gi"
console.log(regex.flags.includes("i"));  // true

true
true
gi
true

🚀 Common Use Cases

• Search boxes — find keywords whether users type JavaScript or javascript.
• Form validation — accept .PNG, .png, and .Png file extensions.
• Log parsing — detect ERROR, Error, and error in server output.
• URL routing — match path segments without caring about case (when appropriate).
• Content filters — block banned words in any casing.
• Dynamic regex — pass "i" in the flags string from user settings.

Important Considerations

• Unicode edge cases — some locale-specific letters have special case-folding rules; test international text when it matters.
• Not for passwords — case-insensitive matching is wrong for secrets; keep passwords case-sensitive.
• Performance — ignoreCase adds a small cost; for simple ASCII checks it is usually negligible.
• Replacement casing — i finds any case but does not preserve original casing in replacements unless you use a function callback.
• Immutable flags — create a new RegExp to toggle case sensitivity; you cannot set regex.ignoreCase = true.

📝 Notes

• ignoreCase is read-only—flags are fixed at creation.
• The i flag applies to the entire pattern, not just one character.
• Combine with g for all matches: /word/gi.
• regex.flags lists all flags; regex.ignoreCase is the boolean for i alone.
• Review global for the g flag and (x|y) for alternation.
• Next up: \b word boundary metacharacter.

💡 Best Practices