JS RegExp Quantifiers

Quantifiers control how many times the preceding part of a pattern must repeat to count as a match -- * for zero or more, + for one or more, ? for zero or one, and {n,m} for a specific range -- turning a single-character pattern into one that matches variable-length runs of that same thing.

In this page:

Zero or More: *
One or More: +
Zero or One: ?
Specific Ranges with {n,m}
Greedy vs Lazy Matching

Syntax

javascript

x*   // 0 or more
x+   // 1 or more
x?   // 0 or 1
x{n}   x{n,m}

Zero or More: *

* matches zero or more occurrences of the preceding element -- ab*c matches "ac" (zero b's), "abc" (one b), "abbbc" (many b's), and so on, since even zero repetitions still counts as a valid match.

Note: Remember that * allows for zero occurrences -- if at least one is actually required, use + instead.

Warning: A pattern relying on * where + was intended can match an unexpectedly short (or even empty) string, since zero repetitions still satisfies *.

उदाहरण: Zero or More: *

javascript

console.log(/ab*c/.test("ac"));    // true, zero b's
console.log(/ab*c/.test("abbbc")); // true, many b's

One or More: +

+ requires at least one occurrence of the preceding element -- \d+ matches "5", "42", or "123456", but fails to match anywhere at all in a string with no digits, unlike * which would still technically match zero characters.

Note: Use + instead of * whenever the preceding element genuinely must appear at least once for the match to be meaningful.

Warning: Confusing + and * is one of the most common regex mistakes -- always double-check whether "zero" is actually a valid count for what you are matching.

उदाहरण: One or More: +

javascript

console.log(/\d+/.test("42"));  // true
console.log(/\d+/.test("abc")); // false, no digits at all

Zero or One: ?

? makes the preceding element optional -- present zero or one time, never more -- colou?r matches both "color" (without the u) and "colour" (with it), handling both American and British spellings with a single pattern.

Note: Use ? to handle a genuinely optional single character or short sequence, like an optional letter or an optional trailing character.

Warning: ? only allows zero OR one occurrence -- it does not mean "optional and repeatable"; for that, combine it with a group and a different quantifier.

उदाहरण: Zero or One: ?

javascript

console.log(/colou?r/.test("color"));   // true
console.log(/colou?r/.test("colour"));  // true

Specific Ranges with {n,m}

{n} matches exactly n occurrences, {n,} matches at least n, and {n,m} matches between n and m occurrences (inclusive) -- giving precise control over repetition count beyond the broader */+/? shorthand, useful for things like validating a fixed-length code.

Note: Use {n,m} whenever a repetition count has specific, known bounds, like a 5-digit zip code or a password requiring 8 to 20 characters.

Warning: Writing {n} when {n,} or {n,m} was intended (or vice versa) is an easy typo that silently changes the matching rules -- always double-check which bound(s) you actually want.

उदाहरण: Specific Ranges with {n,m}

javascript

console.log(/^\d{3}$/.test("123"));   // true, exactly 3
console.log(/^\d{2,4}$/.test("12345")); // false, too many

Greedy vs Lazy Matching

By default, quantifiers are greedy -- they match as much text as possible while still allowing the overall pattern to succeed.

Adding a ? right after a quantifier (like *? or +?) makes it lazy instead, matching as little text as possible, which matters when a pattern could otherwise "overshoot" across more text than intended.

Note: Use a lazy quantifier when matching content between two delimiters (like quotes or HTML tags) that might appear multiple times in the same string, to avoid matching from the first delimiter all the way to the last one.

Warning: A greedy quantifier used to match "between two quotes" in a string containing multiple quoted sections will match from the very first quote to the very last one, not the nearest matching pair.

उदाहरण: Greedy vs Lazy Matching

javascript

console.log("<a><b>".match(/<.*>/)[0]);  // greedy: "<a><b>"
console.log("<a><b>".match(/<.*?>/)[0]); // lazy: "<a>"

Live Example

Chapter Quiz — Complete all 26 topics to unlock

0/26 topics done

Complete these topics first:

← Previous Lesson JS RegExp Groups Next Lesson → JS Fetch API

JS RegExp Quantifiers

Zero or More: *

One or More: +

Zero or One: ?

Specific Ranges with {n,m}

Greedy vs Lazy Matching

Chapter Quiz — Complete all 26 topics to unlock

Login to run this code