Regex Quantifiers in JavaScript

Welcome back to Regex Foundations: Matching Patterns! This is your second lesson, and you're making excellent progress in mastering regular expressions with JavaScript. In the previous lesson, we explored literals and special characters, learning how to match exact text and use metacharacters like the dot to match any single character. We also discovered how to escape special characters when we need them to match literally.

Today, we're expanding our pattern-matching toolkit significantly by introducing quantifiers. These powerful tools let us control how many times a pattern element should repeat. Instead of matching just one character or a fixed sequence, we'll learn to match variable-length patterns such as numbers of any length, optional characters, or sequences that repeat a specific number of times.

By the end of this lesson, you'll understand how to use five essential quantifiers: + for one or more repetitions, * for zero or more, ? for optional elements, {n} for exact counts, and {m,n} for flexible ranges. These quantifiers transform simple patterns into flexible matching tools that handle real-world text variations with ease.

In the previous lesson, we matched fixed-length patterns like c.t (exactly three characters). But real-world data rarely comes in fixed sizes. Consider extracting numbers from text: we might encounter single digits like 7, double digits like 42, or longer sequences like 12345. Writing a separate pattern for each possible length would be impractical.

This is where quantifiers become essential. They allow us to specify repetition directly in our patterns, telling the regex engine: "match this element one or more times," "match this element zero or more times," or even "match this element exactly five times." Quantifiers attach to the pattern element immediately before them, controlling how many times that element should repeat.

For instance, the pattern /\d+/ means "match one or more digits." The \d matches any single digit, while the + quantifier extends this to match sequences of any length. This single pattern can match 7, 42, 12345, or any other continuous sequence of digits. Let's explore each quantifier in detail.

The + quantifier is one of the most commonly used repetition operators. It matches one or more occurrences of the preceding element. When we write /\d+/, we're instructing the regex engine to find at least one digit and continue matching as many consecutive digits as possible.

function extractNumbers(text) {
  // Match one or more digits
  return text.match(/\d+/g) || [];
}

// Extract all numbers from mixed text
const sampleText = "Order #12345 costs $99 and weighs 2kg.";
console.log(extractNumbers(sampleText));

The pattern /\d+/g uses the \d character class (which matches any digit from 0 to 9) followed by +. The g flag makes the regex global, meaning it finds all matches in the string rather than stopping after the first one. The regex engine scans through our text, and whenever it encounters a digit, it starts matching. It continues matching consecutive digits until it hits a non-digit character. This process repeats throughout the entire string, finding all numeric sequences regardless of their length.

Note the || [] pattern in our function: JavaScript's .match() method returns null when no matches are found, so we use the logical OR operator to return an empty array instead. This makes our function more predictable and easier to work with.

[ '12345', '99', '2' ]

Notice how our function successfully extracted three distinct numbers: the five-digit order number 12345, the two-digit price 99, and the single-digit weight 2. Each number was captured as a separate match because they were separated by non-digit characters. The + quantifier's greedy nature ensures we capture the longest possible sequence of digits at each location.