← Back to JavaScript Course | Chapter 9: Async & Web APIs | Lesson 19 of 26

JS RegExp Flags

A regular expression's flags -- single letters placed after the closing slash, like /pattern/gi -- modify how the pattern matches: case-insensitively, globally across every match instead of just the first, or across multiple lines. Understanding each flag is essential for getting the matching behavior you actually intend.

In this page:

  1. The Global Flag (g)
  2. The Case-Insensitive Flag (i)
  3. The Multiline Flag (m)
  4. The Unicode Flag (u)
  5. Combining Multiple Flags
Syntax
javascript 
/pattern/g   // global
/pattern/i   // case-insensitive
/pattern/m   // multiline
/pattern/gi  // combined

The Global Flag (g)

Without g, a regex only finds the first match in a string and stops -- with g, methods like .match() and .replace() find and act on every match throughout the entire string, not just the first occurrence.

Note: Always include g with .replace() when you intend to replace every occurrence, not just the first one found.
Warning: A regex with the g flag becomes stateful when reused with .test() or .exec() -- it remembers its position between calls via lastIndex, which can produce surprising alternating results.

उदाहरण: The Global Flag (g)

javascript 
console.log("cat cat cat".match(/cat/));   // only the first match
console.log("cat cat cat".match(/cat/g));  // every match

The Case-Insensitive Flag (i)

The i flag makes a pattern match regardless of upper or lower case -- /cat/i matches "cat", "CAT", "Cat", and any other capitalization -- useful whenever the exact case of the input cannot be relied upon, like validating a user-entered word.

Note: Use i specifically when case genuinely should not matter for the match, rather than adding it as a reflexive default to every pattern.
Warning: Adding i to a pattern that specifically needs to distinguish case (like matching a case-sensitive code or identifier) will incorrectly widen the match to unintended cases.

उदाहरण: The Case-Insensitive Flag (i)

javascript 
console.log(/cat/i.test("CAT")); // true, case-insensitive

The Multiline Flag (m)

By default, ^ matches only the very start of the entire string and $ only the very end, even in a multi-line string -- the m flag changes this so ^ and $ instead match the start and end of each individual line within the string.

Note: Use m specifically when working with a multi-line string where you need to match patterns at the start or end of each line, not just the whole string.
Warning: Forgetting the m flag when working with multi-line text is a common reason ^ or $ anchors appear to "not work" as expected on anything but the very first or last line.

उदाहरण: The Multiline Flag (m)

javascript 
const text = "line one\nline two";
console.log(text.match(/^line/gm)); // matches start of each line

The Unicode Flag (u)

The u flag enables full Unicode-aware pattern matching, correctly handling characters outside the Basic Multilingual Plane (like many emoji), which without this flag can be misinterpreted as two separate characters instead of one.

Note: Include u when a pattern needs to correctly match emoji or other characters represented by surrogate pairs in UTF-16.
Warning: Without u, a pattern like /./ can match only half of an emoji character, since JavaScript strings internally use UTF-16 and some characters span two code units.

उदाहरण: The Unicode Flag (u)

javascript 
console.log(/\u{1F600}/u.test("\u{1F600}")); // correctly handles characters outside the basic plane

Combining Multiple Flags

Flags can be combined in any order after the closing slash -- /pattern/gi applies both global and case-insensitive matching at once, /pattern/gm combines global and multiline, and so on, letting you mix exactly the behaviors a given task needs.

Note: Combine only the flags a specific pattern actually needs -- adding unnecessary flags does not usually break anything, but can make the intended matching behavior less clear to a reader.
Warning: The order flags are written in does not matter (gi and ig behave identically), but each flag can only appear once -- repeating a flag causes a syntax error.

उदाहरण: Combining Multiple Flags

javascript 
console.log("Cat cat CAT".match(/cat/gi)); // combines global + case-insensitive
Live Example
Related Topics

JS RegExp Classes · JS RegExp Metachars · JS RegExp Assertions · JS RegExp Groups

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
🔒

Chapter Quiz — Complete all 26 topics to unlock

0/26 topics done

Complete these topics first:

← Previous Lesson JS Regular Expressions Next Lesson → JS RegExp Classes

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.