JavaScript RegExp {X} Quantifier

What You’ll Learn

The {X} quantifier matches the previous token exactly X times. Replace X with a number: \d{4} means four digits, (ab){2} means abab. Use it when length matters—ZIP codes, years, PINs, and structured IDs.

Introduction

Sometimes “one or more” is too loose. A US ZIP code has five digits. A year has four. A verification code might require exactly six characters. The {X} quantifier gives you that precision: it repeats the preceding token a fixed number of times—no more, no fewer.

Writing \d{4} is clearer than \d\d\d\d, especially for longer counts like \d{16} for card numbers. Combined with anchors (^ and $), {n} becomes a powerful validation tool for form fields and structured data.

Understanding the {X} Exact-Count Quantifier

Place {n} immediately after the token you want to repeat, where n is a non-negative integer. The engine requires exactly n consecutive matches of that token.

/\d{3}/.test("123");    // true  — exactly 3 digits found

/\d{3}/.test("12");      // false — only 2 digits

/\d{3}/.test("1234");    // true  — "123" is a valid 3-digit run



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

Without anchors, {n} finds a substring of the right length anywhere in the input. For whole-field validation, wrap the pattern with ^ and $ so the entire value must match.

How to Use the {X} Quantifier

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

/\d{4}/;              // four digits (year, PIN block)

/\w{6}/;              // six word characters

/(ha){3}/;            // hahaha

/^\d{5}$/;            // entire value is 5 digits

/\d{4}-\d{2}-\d{2}/;  // ISO-style date segments



"abc123def".match(/\d{3}/);  // ["123"]

Use test() for yes/no checks, match() to extract the exact-length substring, and ^…$ when the full input must conform to a fixed length.

📝 Syntax

token{n}           // exactly n repetitions of token

\d{4}              // four digits

\w{8}              // eight word chars

(ab){2}            // ab repeated twice

a{3}               // same as aaa

{0}                // zero times (rare; see ? and *)

Common patterns

• /\d{4}/ — four-digit year or block in a longer string.
• /^\d{5}$/ — US ZIP code (five digits only).
• /\d{4}-\d{2}-\d{2}/ — date with fixed-width segments.
• /(..){3}/ — three pairs of any two characters.
• /^[A-Z]{2}\d{6}$/ — two letters followed by six digits.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover exact digit runs, grouped repetition, date segments, fixed-length validation, and extracting equal-width tokens with g.

const samples = ["12", "123", "1234", "abc123def"];



samples.forEach((s) => {

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

});

// 12          null

// 123         ["123"]

// 1234        ["123"]

// abc123def   ["123"]

12 null

123 ["123"]

1234 ["123"]

abc123def ["123"]

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



words.forEach((w) => {

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

});

// hahaha    true

// haha      false — only two ha units

// hahahaha  true  — contains hahaha

hahaha true

haha false

hahahaha true

const dates = ["2024-07-17", "24-7-17", "2024/07/17"];



dates.forEach((d) => {

  console.log(d, /\d{4}-\d{2}-\d{2}/.test(d));

});

// 2024-07-17  true

// 24-7-17     false — segments wrong width

// 2024/07/17  false — slashes, not hyphens

2024-07-17 true

24-7-17 false

2024/07/17 false

const rule = /^\d{5}$/;



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

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

console.log(rule.test("902101"));  // false — too long

console.log(rule.test("9021a"));   // false — letter breaks digits

true

false

false

false

const text = "The quick brown fox";



console.log(text.match(/\w{4}/g));

// ["quic", "brow"]



console.log("hello world".match(/\w{4}/g));

// ["hell", "worl"]

["quic", "brow"]

["hell", "worl"]

🚀 Common Use Cases

• Fixed-length codes — PINs, OTPs, and verification tokens with exact character counts.
• Postal and ID formats — ZIP codes, product SKUs, and license segments with known widths.
• Date and time parts — four-digit years and two-digit months or days in structured strings.
• Hex and binary runs — [0-9a-f]{6} for color codes or fixed-width hashes.
• Padding patterns — detect exactly N repeated separator characters.
• Protocol fields — fixed-width headers in logs or network packet formats.

Important Considerations

• Substring vs whole field — {n} alone matches inside longer text; add ^…$ for full-value validation.
• Group precedence — ab{2} repeats only b twice (abb); use (ab){2} for abab.
• Not range syntax yet — {n} is exact count; {n,m} and {n,} are separate topics.
• Zero count — {0} matches zero times (like optional); prefer ? for readability when zero or one is intended.
• Large n values — {100} is valid but can be harder to read; consider whether a simpler pattern exists.
• Validation limits — shape matching with {n} does not guarantee semantic correctness (e.g. month 99 still matches \d{2}).

📝 Notes

• {1} matches once—usually redundant unless grouping for clarity.
• + is shorthand for {1,}; * for {0,}; ? for {0,1}.
• Previous topic: ^ start anchor.
• Next topic: {X,} at-least-n quantifier.
• See \d for digit matching with exact counts.
• Pair with $ and ^ for strict field validation.

💡 Best Practices