JavaScript RegExp \n Metacharacter

What You’ll Learn

The \n metacharacter matches a line feed (LF)—the newline character that separates lines in Unix-style text. It is essential for splitting paragraphs, counting lines, parsing logs, and working with multiline patterns.

Introduction

When you press Enter in a text area, JavaScript usually inserts a line feed character. That invisible code is what \n matches in a regular expression.

Newlines appear everywhere: multiline user input, server logs, CSV exports, and template strings. Regex with \n helps you split, count, validate, and transform line-based data.

Understanding the \n Metacharacter

\n matches exactly one line feed character. It is not the two-character sequence backslash-n in the source text—it is the single control code at that position in the string.

const text = "line one\nline two";

/\n/.test(text);         // true
/\n/.test("single");     // false

text.split("\n");        // ["line one", "line two"]

Line feed is part of the \s whitespace class. On Windows, a visible line break is often stored as \r\n, but many web APIs and modern files use \n alone.

How to Use \n in JavaScript

Common workflows include splitting, counting, replacing, and line-aware matching with the multiline flag:

const poem = "roses\nviolets\nsugar";

poem.split(/\n/);                    // 3 lines
(poem.match(/\n/g) || []).length;    // 2 newlines

"hello\nworld".replace(/\n/g, " ");  // "hello world"

/^done$/m.test("start\ndone\nnext"); // true (m flag)

Use split(/\n/) for line arrays, match(/\n/g) to count breaks, and the m flag when ^ and $ should apply per line.

📝 Syntax

/\n/              // single line feed
/\n+/             // one or more newlines
/\r\n|\n/         // Windows or Unix line break
/^line$/m         // whole line match (multiline)
/\s/              // whitespace (includes \n)

Common patterns

• /\n/g — find every newline in text.
• str.split(/\n/) — break into an array of lines.
• /\r\n|\r|\n/g — split on any line-ending style.
• /^# .+/gm — match comment lines in multiline text.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover detection, splitting, counting, multiline anchors, and cross-platform line endings.

console.log(/\n/.test("one line"));       // false
console.log(/\n/.test("two\nlines"));    // true
console.log(/\n/.test("a\r\nb"));        // true (contains \n in CRLF)

false
true
true

const log = "INFO boot\nWARN slow\nERROR fail";

const lines = log.split(/\n/);
console.log(lines);
// ["INFO boot", "WARN slow", "ERROR fail"]

console.log(lines[1]); // "WARN slow"

["INFO boot", "WARN slow", "ERROR fail"]
WARN slow

const essay = "Intro\nBody\nConclusion";

const breaks = essay.match(/\n/g);
console.log(breaks);              // ["\n", "\n"]
console.log(breaks.length);       // 2

console.log(essay.split(/\n/).length); // 3 lines

["\n", "\n"]
2
3

const block = "todo: buy milk\ndone: walk dog\n todo: sleep";

console.log(/^done:/m.test(block));    // true
console.log(/^done:/.test(block));     // false (no ^ at string start)

console.log(/^todo:/gm.test(block));    // true (two todo lines)

true
false
true

const mixed = "a\r\nb\nc\rd";

const lines = mixed.split(/\r\n|\r|\n/);
console.log(lines); // ["a", "b", "c", "d"]

const normalized = mixed.replace(/\r\n|\r/g, "\n");
console.log(JSON.stringify(normalized)); // "a\nb\nc\nd"

["a", "b", "c", "d"]
"a\nb\nc\nd"

🚀 Common Use Cases

• Log parsing — split server output into one object per line.
• Form validation — reject input that contains embedded newlines when single-line is required.
• CSV / config files — process line-oriented records with regex per row.
• Textarea processing — count lines in user-submitted essays or code.
• Markdown / comments — match lines starting with # using the m flag.
• Normalization — convert mixed line endings to consistent \n.

Important Considerations

• Platform endings — Windows files may use \r\n; do not assume \n alone for all uploads.
• Dot metacharacter — by default . does not match \n; use the s (dotAll) flag to include newlines.
• Visible vs invisible — newlines are control chars; use JSON.stringify to inspect them in DevTools.
• Trim empty lines — split(/\n/) may leave trailing empty strings if text ends with a newline.
• String vs regex — split("\n") and split(/\n/) behave the same for simple LF splits.

📝 Notes

• \n is line feed; Windows often uses \r\n together.
• Review \r carriage return for CR and CRLF details.
• Next up: \D non-digit metacharacter.
• String.prototype.split("\n") is fine when you know endings are LF-only.
• Template literals use real newlines: `line1\nline2` contains \n characters.
• Char code check: str.charCodeAt(i) === 10 identifies LF without regex.

💡 Best Practices