JavaScript RegExp i Modifier

What You’ll Learn

The i modifier (ignoreCase flag) makes letter matching case-insensitive. With /hello/i, the pattern matches hello, Hello, and HELLO—ideal for user input, search boxes, and validation where letter case should not matter.

Introduction

By default, regular expressions distinguish uppercase from lowercase. The letter A in a pattern matches only capital A, not a. The i modifier removes that restriction for letters throughout the pattern.

Case-insensitive matching is one of the most common regex needs in web apps—search fields, filtering lists, validating emails or keywords where users may type any combination of upper and lower case letters.

Understanding the i Modifier

Append i to a regex literal or pass "i" in constructor flags. The RegExp instance sets ignoreCase: true, and the engine folds letter case during matching.

/hello/i.test("Hello World"); // true
/hello/i.test("HELLO");        // true
/hello/.test("Hello World");   // false

/cat/i.test("CAT");            // true

Digits, whitespace, and punctuation are unaffected. Only letters (and Unicode letter-like characters) participate in case folding.

How to Use the i Modifier

Enable case-insensitive matching on literals, constructors, and combined flags:

/hello/i;                          // case-insensitive literal
new RegExp("hello", "i");          // constructor
/error/gi;                         // global + ignoreCase

re.ignoreCase;                     // true when i is set
text.replace(/yes/gi, "ok");       // replace all case variants

Pair i with g when you need every case-insensitive match in a string, not just the first one.

📝 Syntax

/pattern/i           // ignoreCase
/pattern/gi          // global + ignoreCase
/pattern/ig          // same (order free)
new RegExp("p", "i") // constructor
regex.ignoreCase      // true | false

Common patterns

• /word/i — match word in any letter case.
• /error/gi — find every error/ERROR/Error in text.
• /^[a-z]+$/i — letters only, any case (still matches A–Z via i).
• re.ignoreCase — check whether the flag is active.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover test(), ignoreCase, gi combo, replace, and comparison with character classes.

console.log(/hello/i.test("Hello World")); // true
console.log(/hello/i.test("HELLO"));        // true
console.log(/hello/.test("Hello World"));   // false

true
true
false

const withI = /cat/i;
const withoutI = /cat/;

console.log(withI.ignoreCase);     // true
console.log(withoutI.ignoreCase);  // false
console.log(withI.flags);          // "i"

true
false
i

const text = "Error: file not found. ERROR logged.";

console.log(text.match(/error/gi));
// ["Error", "ERROR"]

console.log(text.match(/error/gi).length); // 2

["Error", "ERROR"]
2

const text = "Yes YES yes";

console.log(text.replace(/yes/gi, "ok"));
// "ok ok ok"

ok ok ok

const text = "JavaScript rocks";

console.log(/javascript/i.test(text));     // true
console.log(/[Jj]ava[Ss]cript/.test(text)); // true
console.log(/javascript/.test(text));      // false

true
true
false

🚀 Common Use Cases

• Search boxes — find items whether users type upper or lower case.
• Validation — accept YES, yes, or Yes as equivalent answers.
• Log filtering — match ERROR, error, or Error in log lines.
• URL/path checks — treat /API and /api the same when appropriate.
• Keyword detection — flag prohibited words regardless of capitalization.
• Replace normalization — swap all case variants in one pass with /gi.

Important Considerations

• Letters only — i does not make 5 match S or symbols match differently.
• Unicode nuance — some locale-specific case pairs (e.g. Turkish I/i) may behave unexpectedly; test international input.
• When case matters — passwords and base64 tokens usually must stay case-sensitive; omit i.
• Flags are fixed — you cannot toggle i after creating the RegExp; build a new one.
• Combine with g — use gi when you need all case-insensitive matches, not just the first.

📝 Notes

• i is the ignoreCase flag (also called case-insensitive).
• Flag order is free: /pat/gi equals /pat/ig.
• Previous modifier: g global flag.
• Next modifier: m multiline flag.
• See also: ignoreCase property.
• For case-sensitive matching, omit i or use explicit character classes.

💡 Best Practices