JavaScript RegExp \d Metacharacter

What You’ll Learn

The \d metacharacter matches any single digit from 0 through 9. It is shorthand for [0-9] and appears in nearly every pattern that validates numbers, extracts digits, or parses formatted text like phone numbers and dates.

Introduction

Many real-world strings mix letters and numbers: order IDs, ages, prices, and verification codes. The \d metacharacter gives you a compact way to target digits without listing every numeral.

One \d matches exactly one digit. To match a full number, combine \d with quantifiers like + (one or more) or {n} (exactly n digits).

Understanding the \d Metacharacter

\d is a predefined character class escape. In JavaScript it matches ASCII digits 0 through 9 only.

/\d/.test("abc");     // false (no digits)
/\d/.test("room 5");  // true  ("5" matches)

"price: $19".match(/\d+/);  // ["19"]
/\d{3}/.test("pin 482");    // true  (482 is three digits)

The uppercase form \D matches any character that is not a digit—equivalent to [^0-9].

How to Use \d in JavaScript

Use \d in detection, extraction, validation, and replacement workflows:

/\d/.test("Order #42");              // true
"abc123def456".match(/\d+/g);        // ["123", "456"]
/^\d{4}$/.test("2026");              // true (four-digit year)
"Card 4111".replace(/\d/g, "*");     // "Card ****"

Pair \d with anchors (^, $), quantifiers (+, {n}), and grouping for structured formats like dates and phone numbers.

📝 Syntax

\d              // one digit 0–9
\d+             // one or more digits
\d{4}           // exactly four digits
\d*             // zero or more digits
\D              // one non-digit character

Common patterns

• /\d+/ — match a run of digits (a number token).
• /^\d{4}$/ — validate a four-digit code.
• /\d{2}-\d{2}-\d{4}/ — match DD-MM-YYYY style dates.
• /\D+/ — match non-digit sequences (words, symbols).

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover detection, extraction, validation, masking, and non-digit matching.

console.log(/\d/.test("hello"));       // false
console.log(/\d/.test("room 5"));      // true
console.log(/\d/.test("Order #42"));   // true

false
true
true

const text = "Order 42 costs $19.99 today";

const numbers = text.match(/\d+/g);
console.log(numbers); // ["42", "19", "99"]

const first = text.match(/\d+/);
console.log(first[0]); // "42"

["42", "19", "99"]
42

const pinPattern = /^\d{4}$/;

console.log(pinPattern.test("4829"));   // true
console.log(pinPattern.test("482"));    // false (too short)
console.log(pinPattern.test("48291"));  // false (too long)
console.log(pinPattern.test("48a9"));   // false (letter)

true
false
false
false

const card = "Card ending 4111";

const masked = card.replace(/\d/g, "*");
console.log(masked); // "Card ending ****"

Card ending ****

const mixed = "abc123def456";

const letters = mixed.match(/\D+/g);
console.log(letters); // ["abc", "def"]

console.log(/\D/.test("123"));  // false (all digits)
console.log(/\D/.test("a1"));   // true  ("a" is non-digit)

["abc", "def"]
false
true

🚀 Common Use Cases

• PIN and OTP validation — enforce fixed-length numeric codes with \d{n}.
• Price parsing — extract digit runs from currency strings.
• Form input rules — require at least one digit in passwords or usernames.
• Data masking — hide digits in logs and UI displays.
• Date fragments — match DD, MM, or YYYY segments in formatted dates.
• Filtering — remove digits with replace(/\d/g, "") to keep letters only.

Important Considerations

• One vs many — lone \d matches one digit; use + or {n} for sequences.
• ASCII only — default \d does not match Unicode numerals like ① without the u flag and \p{Nd}.
• Decimals — \d+ stops at the decimal point; use \d+\.\d+ for simple floats.
• Leading zeros — \d+ preserves leading zeros in the matched string (e.g. "007").
• Same as [0-9] — pick one style and stay consistent within a codebase.

📝 Notes

• \d equals [0-9] in standard JavaScript regex.
• \D equals [^0-9] (any non-digit).
• Review [0-9] character class and [^0-9] negated form.
• Next up: . (dot) metacharacter for any character.
• For integers only, anchor with ^\d+$; for decimals add \. between digit groups.
• Combine with \b for whole-number tokens: \b\d+\b.

💡 Best Practices