JavaScript RegExp * Quantifier

What You’ll Learn

The * quantifier repeats the previous token zero or more times. It is the most permissive repetition operator: the token may appear many times, once, or not at all. Master * for flexible patterns like ab*c, whitespace trimming with \s*, and greedy wildcards.

Introduction

Some parts of text repeat an unknown number of times: multiple spaces, repeated letters, or optional middle sections. The * quantifier says “match this token as many times as you want—including zero times.” That last part distinguishes * from +, which requires at least one occurrence.

Patterns like ab*c match ac (no b at all), abc, and abbbc. Because zero repetitions are allowed, * can also produce surprising empty matches when combined with the global flag—a common beginner pitfall covered later in this tutorial.

Understanding the * Quantifier

Place * immediately after a character, metacharacter, class, or group. The engine greedily consumes as many repetitions as possible while still allowing the rest of the pattern to succeed.

const words = ["ac", "abc", "abbbc", "abxc"];

words.forEach((w) => {
  console.log(w, /ab*c/.test(w));
});
// ac    true  (zero b)
// abc   true
// abbbc true
// abxc  false

Shorthand: * equals {0,}. On an empty string, /a*/ still succeeds because matching zero a characters is valid.

How to Use the * Quantifier

Attach * to tokens that may repeat any number of times, including never:

/ab*c/;                    // a, zero+ b, c
/^\s*/;                    // leading whitespace (incl. none)
/(ha)*/g;                  // zero or more "ha" groups
/.* /;                     // greedy to last space
/.*?\./;                   // lazy to first dot

"   hi".replace(/^\s*/, ""); // "hi"

Use test() for presence checks, match() to extract runs, and replace() with anchored \s* to trim edges.

📝 Syntax

token*           // zero or more of token
ab*c             // flexible middle section
\s*              // zero or more whitespace
(group)*         // repeat entire group (or skip)
token{0,}        // equivalent to *
token*?          // lazy — as few as possible

Common patterns

• /ab*c/ — a and c with any number of b between.
• /^\s*/ — strip leading whitespace (including none).
• /\s*$/ — strip trailing whitespace.
• /go*/ — g followed by zero or more o.
• //g — lazy match for HTML comments.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover flexible middle sections, whitespace trimming, zero vs one-or-more, greedy vs lazy wildcards, and repeated groups.

const tokens = ["ac", "abc", "abbbc", "abxc"];

tokens.forEach((t) => {
  console.log(t, /ab*c/.test(t));
});
// ac    true
// abc   true
// abbbc true
// abxc  false

ac true
abc true
abbbc true
abxc false

const inputs = ["hello", "   hello", "\t\thello"];

inputs.forEach((s) => {
  console.log(JSON.stringify(s), "→", JSON.stringify(s.replace(/^\s*/, "")));
});
// "hello"     → "hello"
// "   hello"  → "hello"
// "\t\thello" → "hello"

"hello" → "hello"
"   hello" → "hello"
"		hello" → "hello"

const empty = "";

console.log(/a*/.test(empty));  // true  — zero a's OK
console.log(/a+/.test(empty));  // false — needs at least one
console.log(empty.match(/\d*/)[0]); // "" — zero digits
console.log(empty.match(/\d+/));    // null

true
false
""
null

const text = "say hello. then bye.";

console.log(text.match(/.*\./));   // greedy — to last dot
console.log(text.match(/.*?\./));  // lazy — to first dot

["say hello. then bye."]
["say hello."]

const laughs = ["", "ha", "haha", "hahaha", "ho"];

laughs.forEach((s) => {
  console.log(JSON.stringify(s), /^(ha)*$/.test(s));
});
// ""      true
// "ha"    true
// "haha"  true
// "hahaha" true
// "ho"    false

"" true
"ha" true
"haha" true
"hahaha" true
"ho" false

🚀 Common Use Cases

• Flexible separators — ab*c style patterns with variable middle text.
• Whitespace trimming — ^\s* and \s*$ for edges.
• Wildcards — .* for “anything” between anchors (use carefully).
• Optional repeated sections — (prefix)* for zero or more blocks.
• Comment parsing — lazy .*? between delimiters.
• Loose token matching — when absence of a token is as valid as many copies.

Important Considerations

• Empty matches — /\d*/g on "a1b" returns empty strings between characters; prefer \d+ when you need digits.
• Greedy default — .* may span too far; use *? for minimal matching.
• Precedence — ab*c repeats only b; use (ab)*c to repeat ab.
• Performance — nested * quantifiers on hostile input can cause catastrophic backtracking.
• Not a substitute for + — when at least one char is required, * is too permissive.
• Anchors help — combine ^ and $ to avoid accidental partial matches.

📝 Notes

• * is shorthand for {0,}—zero to unlimited repetitions.
• Previous topic: ? zero-or-one quantifier.
• Next topic: ^ start anchor.
• See + when at least one repetition is required.
• See \s for whitespace with * trimming patterns.
• Lazy forms: +?, ??, and *? prefer shorter matches.

💡 Best Practices