JavaScript RegExp * Quantifier

What Is the * Quantifier?

Place * after a token to match it zero or more times. It is the most permissive repetition operator: the token may appear many times, once, or not at all. Shorthand for {0,}.

token*     → zero or more of token
ab*c       → ac, abc, abbbc  (not abxc)
a*         → "", "a", "aaa" all match
a+         → needs at least one a

* is greedy   → match as many as possible
*? is lazy    → match as few as possible

How to Use *

Attach * to the token that may repeat any number of times, including never.

1. Write the token you want to repeat (character, class, group, or metachar).
2. Add * right after it — e.g. b*, \s*, (ha)*.
3. Complete the rest of the pattern so the engine knows when to stop.
4. If empty must fail, switch to +. For a shorter match, use *?.

Pseudocode

pattern = <token>* <rest>

// greedy *:
count = as many token matches as possible
while rest fails and count > 0:
    count = count - 1          // backtrack
if rest succeeds (even with count = 0):
    match
else:
    fail

// lazy *? starts at count = 0 and grows only if needed

Cheat Sheet

Keep these facts handy while writing zero-or-more patterns.

Live Preview

Pick a pattern and a sample string to see whether * matches (and what match() returns).

pattern = /ab*c/
text    = "ac"
test()  → true
match() → ["ac"]

/* b* matched zero times */

JavaScript Examples

Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.

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

tokens.forEach((t) => {
  console.log(t, /ab*c/.test(t));
});

ac true
abc true
abbbc true
abxc false

const empty = "";

console.log(/a*/.test(empty));                      // true
console.log(/a+/.test(empty));                      // false
console.log(JSON.stringify(empty.match(/\d*/)[0])); // ""
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."]

Performance Notes

Simple * patterns are fast. Trouble starts with nested or overlapping quantifiers that force heavy backtracking. Prefer specific classes (\s*, \d*) over open-ended .* when you can.

Key Takeaways