JavaScript RegExp m Modifier

What You’ll Learn

The m modifier (multiline flag) changes how ^ and $ anchors work. Instead of matching only the start and end of the entire string, they match the start and end of each line—making it easy to parse config files, logs, and multi-line user input line by line.

Introduction

Real-world text often spans multiple lines: CSV rows, `.env` files, stack traces, and user comments in textareas. By default, ^ matches only the very beginning of the string and $ only the very end—so a pattern like /^#/ finds comment lines only if the string starts with #.

Add the m modifier and those anchors apply at each line boundary. Now /^#/ matches any line that begins with #, which is the behavior most developers expect when working with multi-line text.

Understanding the m Modifier

Append m to enable multiline mode. The RegExp sets multiline: true, and ^ matches after a newline (or at string start), while $ matches before a newline (or at string end).

const text = "start here\nnot start\nstart again";

/^start/.test(text);   // true  (first line only)
/^start/m.test(text);  // true  (lines 1 and 3)

text.match(/^start/gm); // ["start", "start"]

The m flag does not change how . behaves—the dot still does not match newline characters unless you also use the s (dotAll) flag.

How to Use the m Modifier

Enable multiline mode on literals, constructors, and combined flags:

/^line/m;                          // multiline literal
new RegExp("^line", "m");          // constructor
/^.+$/gm;                          // every full line

re.multiline;                      // true when m is set
config.match(/^#.*$/gm);           // all comment lines

Pair m with g when you need to match anchors on every line, not just the first occurrence.

📝 Syntax

/pattern/m           // multiline anchors
/pattern/gm          // global + multiline
/pattern/gim         // global + ignoreCase + multiline
new RegExp("p", "m") // constructor
regex.multiline       // true | false

Common patterns

• /^#.+$/gm — match every comment line.
• /^\s*$/gm — find blank lines.
• /^ERROR/m — detect lines starting with ERROR.
• /^.+$/gm — split string into logical lines via match.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover ^ line start, $ line end, full-line extraction, multiline property, and comment-line detection.

const text = "start here\nnot start\nstart again";

console.log(/^start/.test(text));    // true (first line)
console.log(/^start/m.test(text));   // true (lines 1 & 3)

console.log(text.match(/^start/gm)); // ["start", "start"]

true
true
["start", "start"]

const text = "line one end\nline two end\nno match";

console.log(/end$/.test(text));    // false (string ends with "match")
console.log(/end$/m.test(text));  // true

console.log(text.match(/end$/gm).length); // 2

false
true
2

const text = "apple\nbanana\ncherry";

const lines = text.match(/^.+$/gm);
console.log(lines);        // ["apple", "banana", "cherry"]
console.log(lines.length); // 3

["apple", "banana", "cherry"]
3

const withM = /^line/m;
const withoutM = /^line/;

console.log(withM.multiline);     // true
console.log(withoutM.multiline);  // false
console.log(withM.flags);         // "m"

true
false
m

const config = "host=localhost\n# comment\nport=3000\n# another";

const comments = config.match(/^#.+$/gm);
console.log(comments);        // ["# comment", "# another"]
console.log(comments.length); // 2

["# comment", "# another"]
2

🚀 Common Use Cases

• Config files — parse .env, INI, or hosts files line by line.
• Log analysis — match lines starting with ERROR or WARN.
• Input validation — ensure each line in a textarea meets a rule.
• Comment stripping — find or remove # or // comment lines.
• Blank line detection — locate empty lines with /^\s*$/gm.
• Markdown/CSV prep — extract or transform individual lines before further parsing.

Important Considerations

• Not dotAll — m does not make . match newlines; use the s flag for that.
• Combine with g — use gm when you need every line match, not just the first.
• Line endings — Windows \r\n may leave \r at line ends; consider normalizing first.
• Single-line strings — m has no effect if the string contains no newlines.
• Flags are fixed — you cannot add m after creating the RegExp; build a new one.

📝 Notes

• m affects ^ and $ only—not \b word boundaries.
• See \n for the newline character matched at line breaks.
• Previous modifier: i ignoreCase flag.
• Next topic: $ end-of-input quantifier.
• For string-wide anchors without line mode, omit m.
• Flag order is free: gm equals mg.

💡 Best Practices