JavaScript RegExp ^ Quantifier

What You’ll Learn

The ^ quantifier is a start anchor. It matches a position at the beginning of the input—not a character—so you can require prefixes, validate whole strings with ^…$, and parse line-by-line text when combined with the m flag.

Introduction

Many tasks care about where matching begins. Does a URL start with https? Does a config line begin with #? Must a username start with a letter? The ^ anchor answers those questions by pinning the match to the start of the string or line.

Without ^, the pattern /world/ matches "hello world" anywhere the letters appear. Adding ^ gives /^world/, which matches only when world is at the very beginning—a much stricter and often more useful rule.

Understanding the ^ Start Anchor

Place ^ at the start of a pattern (or after an opening parenthesis in some constructs). It asserts that the current match position is at the beginning of the input. With the m multiline flag, it also matches immediately after each newline.

const phrases = ["world peace", "hello world", "world"];

/^world/.test("world peace");  // true
/^world/.test("hello world");  // false
/^world/.test("world");        // true

^ is zero-width: it checks a boundary without consuming characters. The matched substring is still the literal text that follows—such as "world" in "world peace".

How to Use the ^ Anchor

Put ^ before the text or groups you want to require at the start, or pair it with $ for full-string validation:

/^hello/;                          // starts with hello
/^https?/;                         // URL prefix
/^#.+$/m;                          // comment lines
/^[A-Z]/;                          // starts with capital
/^[-+]?\d+$/;                      // signed integer

"  hello".match(/^\s*hello/);      // trim-aware start

Use test() for yes/no checks, match() with gm to collect line-start matches, and ^…$ for strict whole-value validation.

📝 Syntax

^pattern            // must start with pattern
^https?://           // URL at string start
^#                   // line starts with #
^.+$                 // non-empty whole string
^[A-Za-z]            // first char is a letter
^text                // with m: each line start

Common patterns

• /^https?:\/\// — string begins with a web URL scheme.
• /^#.+$/gm — every comment line in config text.
• /^\d+$/ — entire value is digits only.
• /^[a-z]/i — starts with a letter (any case).
• /^ERROR/m — line begins with ERROR in logs.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover basic prefix matching, multiline line starts, URL prefixes, comment lines, and full-string validation with ^ and $.

const phrases = ["world peace", "hello world", "world"];

phrases.forEach((s) => {
  console.log(s, /^world/.test(s));
});
// world peace true
// hello world false
// world       true

world peace true
hello world false
world true

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

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

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

true
true
["start", "start"]

const links = [
  "https://example.com",
  "http://example.com",
  "ftp://example.com",
  "visit https://example.com"
];

links.forEach((url) => {
  console.log(url, /^https?:\/\//.test(url));
});
// https://example.com        true
// http://example.com         true
// ftp://example.com          false
// visit https://example.com  false

https://example.com true
http://example.com true
ftp://example.com false
visit https://example.com false

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

const rule = /^\d+$/;

console.log(rule.test("42"));       // true
console.log(rule.test("42abc"));    // false — extra text
console.log(rule.test("abc42"));    // false — not at start

true
false
false

🚀 Common Use Cases

• Prefix checks — URLs, protocol schemes, or required leading text.
• Input validation — whole-field rules with ^…$.
• Log parsing — lines starting with ERROR, WARN, or timestamps.
• Config files — comment lines, section headers, or key prefixes.
• Markdown/headings — lines starting with # for titles.
• Capitalization rules — names or sentences that must start with a letter.

Important Considerations

• Multiline text — add m when ^ should apply per line, not only at string start.
• Not negation — [^abc] inside a class is negation, not a start anchor.
• Leading whitespace — spaces before text prevent ^ from matching where you expect; trim or use ^\s* if needed.
• Not a character — ^ is an assertion; it does not match the first letter itself.
• Partial vs full match — without $, /^pattern/ still allows extra text at the end.
• Windows line endings — \r\n may affect line-start matching; normalize when parsing cross-platform files.

📝 Notes

• ^ pairs naturally with $ for whole-string or whole-line validation.
• See the m modifier for per-line ^ behavior.
• Previous topic: * zero-or-more quantifier.
• End anchor counterpart: $ end quantifier.
• \b word boundaries differ from ^; see \b.
• Next topic: {X} exact-count quantifier.

💡 Best Practices