JavaScript RegExp {n,m} Range Quantifier

What Is the {n,m} Quantifier?

Place {n,m} after a token to match it between n and m times inclusive. You get both a floor and a ceiling — unlike {n,}, which has no maximum.

token{n,m}   → between n and m of token (inclusive)
\d{2,4}      → "12" ✓ · "1234" ✓ · "1" ✗ · "12345" (finds "1234")
^.{8,64}$    → whole string length 8–64

{2} exact  ·  {2,} two or more  ·  {2,4} two to four
{0,1} = ?  ·  {n,n} = {n}

How to Use {n,m}

Attach {n,m} when both a minimum and a maximum count matter.

1. Choose the token — e.g. \d, ., (ha), or a character class.
2. Add {n,m} with inclusive bounds — e.g. \d{2,4}, .{8,64}.
3. Expect greedy behavior: the engine prefers the longest run that still fits in the range.
4. Use ^ and $ when validating a whole field’s length.

Pseudocode

pattern = <token>{n,m}

// greedy: try up to m, then backtrack toward n if needed
count = 0
while count < m and next input matches <token>:
    count = count + 1

if count < n:
    fail
else:
    // success — count is between n and m
    continue with rest of pattern

Cheat Sheet

Keep these facts handy while writing bounded range patterns.

Live Preview

Pick a range pattern and a sample string to see test() / match() results.

pattern = /^\d{2,4}$/
text    = "12"
test()  → true
match() → ["12"]

/* whole string is 2–4 digits */

JavaScript Examples

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

const rule = /^\d{2,4}$/;

["12", "123", "1234", "12345", "1"].forEach((s) => {
  console.log(s, rule.test(s));
});

12 true
123 true
1234 true
12345 false
1 false

console.log("12345".match(/\d{2,4}/));  // ["1234"]
console.log("99".match(/\d{2,4}/));      // ["99"]
console.log("1".match(/\d{2,4}/));       // null

console.log("aaaa".match(/a{1,3}/g));    // ["aaa", "a"]

["1234"]
["99"]
null
["aaa", "a"]

const rule = /^.{8,64}$/;

console.log(rule.test("short"));        // false — too short
console.log(rule.test("longenough"));   // true
console.log(rule.test("a".repeat(64))); // true — at max
console.log(rule.test("a".repeat(65))); // false — over max

false
true
true
false

Performance Notes

Bounded ranges are often safer than open-ended {n,} because the engine stops at m. Keep m realistic for your data, and prefer digit or word classes over bare . when you can.

Key Takeaways