JavaScript RegExp \r Metacharacter

What You’ll Learn

The \r metacharacter matches a carriage return (CR) control character. It is a building block of line endings—especially Windows \r\n (CRLF)—and appears when parsing logs, CSV exports, and cross-platform text files.

Introduction

Text files store invisible characters to mark where one line ends and the next begins. On Windows, that is usually \r\n (carriage return + line feed). On Linux and macOS today, it is typically \n alone.

When your JavaScript code reads files from different systems, regex patterns with \r help you detect, split, or clean up those line-ending differences.

Understanding the \r Metacharacter

\r matches exactly one carriage return character. It does not match a visible letter or digit—it matches a control code embedded in the string.

const cr = "line one\rline two";

/\r/.test(cr);           // true
/\r/.test("line one\n"); // false (LF only, no CR)

"win\r\n".match(/\r\n/g); // ["\r\n"]

In regex literals, write /\r/. In a string for new RegExp(), escape the backslash: new RegExp("\\r").

How to Use \r in JavaScript

Common tasks include detecting CR characters, splitting mixed line endings, and converting to a single format:

const raw = "a\r\nb\nc";

raw.includes("\r");                    // true
raw.split(/\r\n|\r|\n/);               // ["a", "b", "c"]
raw.replace(/\r\n|\r/g, "\n");         // "a\nb\nc" (Unix-style)

Use test() to check for CR presence, match() to find CRLF pairs, and replace() to normalize endings before processing.

📝 Syntax

/\r/              // single carriage return
/\r\n/            // Windows CRLF pair
/\r\n|\r|\n/      // any common line ending
/\r\n/g            // all CRLF pairs (global)

Common patterns

• /\r\n/g — find all Windows-style line breaks.
• /\r\n|\r/g — normalize CRLF and old Mac CR to LF.
• /\r\n|\r|\n/ — split on any line-ending style.
• /[^\r\n]+/g — match lines excluding break characters.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover detection, CRLF matching, normalization, line splitting, and cleanup.

const withCR = "hello\rworld";
const withLF = "hello\nworld";

console.log(/\r/.test(withCR));  // true
console.log(/\r/.test(withLF));  // false
console.log(/\n/.test(withLF));  // true

true
false
true

const windowsText = "row1\r\nrow2\r\nrow3";

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

["\r\n", "\r\n"]
2

const mixed = "line1\r\nline2\rline3\nline4";

const unix = mixed.replace(/\r\n|\r/g, "\n");
console.log(JSON.stringify(unix));
// "line1\nline2\nline3\nline4"

"line1\nline2\nline3\nline4"

const blob = "alpha\r\nbeta\rgamma\ndelta";

const lines = blob.split(/\r\n|\r|\n/);
console.log(lines); // ["alpha", "beta", "gamma", "delta"]

["alpha", "beta", "gamma", "delta"]

const csvRow = "name,age\r";
const cleaned = csvRow.replace(/\r/g, "");

console.log(cleaned);           // "name,age"
console.log(/\r/.test(cleaned)); // false

name,age
false

🚀 Common Use Cases

• File import — detect Windows CRLF in uploaded text files.
• Log parsing — split log lines that mix CR and LF from different sources.
• CSV cleanup — remove trailing carriage returns from cell values.
• Cross-platform apps — normalize line endings before diffing or hashing.
• HTTP headers — parse CRLF-delimited header blocks in raw messages.
• Legacy Mac text — handle old CR-only line endings with /\r/g.

Important Considerations

• Order in alternation — put \r\n before \r when normalizing, or CRLF becomes two replacements.
• Invisible characters — CR is not visible in most editors; use JSON.stringify or char codes to debug.
• Not the same as \n — patterns for one do not match the other.
• String vs regex escaping — "\\r" in strings vs /\r/ in literals require different backslash counts.
• Modern macOS — current Mac files use LF; CR-only is mostly legacy but still appears in old data.

📝 Notes

• \r is carriage return; \n is line feed; Windows uses both as \r\n.
• Normalize with .replace(/\r\n|\r/g, "\n") before comparing multiline strings.
• Review \b word boundary for token matching in line-based text.
• Next up: \d digit metacharacter.
• String.prototype.split("\n") alone misses CR-only or CRLF text—use a regex split for robustness.
• Char code check: str.charCodeAt(i) === 13 identifies CR without regex.

💡 Best Practices