JavaScript RegExp {X,} Quantifier

What You’ll Learn

The {X,} quantifier matches the previous token at least X times with no upper limit. Use \d{3,} for three-or-more digits, {8,} for minimum password length, and remember that + is shorthand for {1,}.

Introduction

Exact counts like {4} are perfect when length is fixed. But many rules only set a minimum: passwords must be at least eight characters, numbers need three or more digits, and repeated spaces should collapse to one. The {X,} quantifier handles that—at least X repetitions, as many as needed.

You already know + (one or more) and * (zero or more). Brace notation makes the minimum explicit: {1,} equals +, and {0,} equals *. Writing {3,} is clearer than guessing what “three or more” means in a complex pattern.

Understanding the {X,} At-Least Quantifier

Place {n,} after a token, where n is a non-negative integer. The engine matches that token at least n times in a row, then continues greedily if more matches are available.

/\d{3,}/.test("12");     // false — fewer than 3 digits

/\d{3,}/.test("123");    // true

/\d{3,}/.test("12345");  // true — more than 3 is allowed



"a{2,}".replace(/a{2,}/, "X");  // "X" from "aaa"

Unlike {n}, which stops at exactly n, {n,} has no maximum. The match grows until the token no longer applies or the rest of the pattern requires stopping (with backtracking if needed).

How to Use the {X,} Quantifier

Attach {n,} after a character class, metacharacter, dot, or grouped expression:

/\d{3,}/;              // three or more digits

/^.{8,}$/;             // at least 8 characters (whole field)

/\s{2,}/g;             // two or more whitespace chars

/(ha){2,}/;            // ha repeated at least twice

/\w{1,}/g;             // same idea as \w+

Use test() for yes/no checks, match() with g to find all qualifying runs, and ^…$ when the entire input must meet a minimum length.

📝 Syntax

token{n,}          // at least n repetitions, no max

{1,}               // one or more (same as +)

{0,}               // zero or more (same as *)

\d{3,}             // 3+ digits

.{8,}              // 8+ any chars

\s{2,}             // 2+ whitespace chars

Common patterns

• /\d{3,}/ — find digit runs of three or more characters.
• /^.{8,}$/ — password or field with minimum eight characters.
• /\s{2,}/g — detect double (or more) spaces for cleanup.
• /[A-Z]{2,}/ — two or more consecutive uppercase letters.
• /(ab){2,}/ — at least two full ab group repetitions.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover minimum digit runs, exact vs at-least comparison, password length rules, whitespace cleanup, and grouped repetition.

const samples = ["12", "123", "12345", "ab12"];



samples.forEach((s) => {

  console.log(s, s.match(/\d{3,}/));

});

// 12     null

// 123    ["123"]

// 12345  ["12345"]

// ab12   null

12 null

123 ["123"]

12345 ["12345"]

ab12 null

["a", "aa", "aaa"].forEach((s) => {

  console.log(s, /a{2}/.test(s), /a{2,}/.test(s));

});

// a   false false

// aa  true  true

// aaa true  true

a false false

aa true true

aaa true true

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



console.log(rule.test("short"));      // false

console.log(rule.test("longenough")); // true

console.log(rule.test("verylongpass")); // true

false

true

true

const messy = "Hello   world\t\ttest";



const cleaned = messy.replace(/\s{2,}/g, " ");

console.log(cleaned);  // "Hello world test"



console.log(messy.match(/\s{2,}/g));

// ["   ", "\t\t"]

Hello world test

["   ", "\t\t"]

const words = ["ha", "haha", "hahaha", "hahahaha"];



words.forEach((w) => {

  console.log(w, /(ha){2,}/.test(w));

});

// ha        false — only one ha unit

// haha      true

// hahaha    true

// hahahaha  true

ha false

haha true

hahaha true

hahahaha true

🚀 Common Use Cases

• Minimum length validation — passwords, usernames, and comments with {n,} and anchors.
• Number extraction — pull digit runs of at least a certain size from logs or CSV data.
• Whitespace normalization — collapse double spaces, tabs, or mixed whitespace.
• Repeated markers — detect two or more dashes, dots, or separator characters.
• Explicit minimums — document intent when + is too vague (e.g. {3,} vs + after a group).
• Text quality checks — flag words with [A-Z]{2,} (shouting) or long consonant runs.

Important Considerations

• Trailing comma matters — {3} is exact; {3,} is at least three. Do not omit the comma.
• No upper bound — {n,} allows unlimited length; use {n,m} when you need a maximum too.
• Greedy default — {n,} matches as many characters as possible; add ? for lazy matching.
• Group precedence — ab{2,} repeats only b; use (ab){2,} for the whole pair.
• Substring matching — without anchors, {n,} finds qualifying runs anywhere in the string.
• Not semantic validation — minimum length regex does not check password strength by itself.

📝 Notes

• + is shorthand for {1,}; * for {0,}.
• Previous topic: {X} exact-count quantifier.
• Next topic: {X,Y} bounded range quantifier.
• See + for the one-or-more shorthand in depth.
• Lazy form: {n,}? matches as few repetitions as possible.
• Pair with ^ and $ for whole-field minimum length.

💡 Best Practices