Please wait


Quantifiers in regular expressions are symbols that tell you how many times a certain pattern or character must appear. They are useful when you want to match repeated characters or patterns in a string.

Here's a simple breakdown:

  • *: Matches 0 or more occurrences of the preceding character or pattern.
  • +: Matches 1 or more occurrences.
  • ?: Matches 0 or 1 occurrence.
  • {n}: Matches exactly n occurrences.
  • {n,m}: Matches between n and m occurrences.

Basic example

If you want to find sequences of the same digit occurring exactly three times in a row, you could use the pattern /\d{5}/.

$string = "I'm 12345 years old";
preg_match("/\d{3}/", $string, $matches);

So, this pattern would match "12345" in the string "I'm 12345 years old".

Here's what each part means:

  • \d: Matches any digit.
  • {5}: Specifies that the preceding pattern (a digit in this case) must occur exactly 5 times.

Configuring the Limit

To find numbers from 3 to 5 digits, you can use the pattern \d{3,5}:

$string = "I'm not 12, but 1234 years old";
preg_match('/\d{3,5}/', $string, $matches);
print_r($matches[0]); // "1234"

If you omit the upper limit, the pattern \d{3,} looks for sequences of digits of length 3 or more:

$string = "I'm not 12, but 345678 years old";
preg_match('/\d{3,}/', $string, $matches);
print_r($matches[0]); // "345678"

To match a sequence of one or more digits in a row, like in the string "+7(903)-123-45-67", you can use the pattern \d{1,}:

$str = "+7(903)-123-45-67";
preg_match_all('/\d{1,}/', $str, $numbers);
print_r($numbers[0]); // Array: 7, 903, 123, 45, 67

These examples illustrate how you can use quantifiers with curly braces to specify exact, minimum, or ranged quantities of characters or patterns you want to match. It's a powerful way to write more flexible and precise patterns in regular expressions.

Shorthand Syntax

As mentioned earlier, we're not limited to setting quantifiers with {}. There are also shorthand characters to represent limits.

One or more

The + quantifier means "one or more," the same as {1,}.

For instance, \d+ looks for numbers:

$str = "+7(903)-123-45-67";
preg_match_all('/\d+/', $str, $matches);
print_r($matches[0]); // Array: 7, 903, 123, 45, 67

The pattern \d+ will match one or more consecutive digits in the given string, returning an array with all the matched sequences.

Zero or one

The ? quantifier means "zero or one," the same as {0,1}. In other words, it makes the symbol optional.

For instance, the pattern ou?r looks for 'o' followed by zero or one 'u', and then 'r'.

So, colou?r finds both "color" and "colour":

$str = "Should I write color or colour?";
preg_match_all('/colou?r/', $str, $matches);
print_r($matches[0]); // Array: color, colour

This pattern demonstrates how you can use the ? quantifier to match variations in spelling or optional parts of a pattern.

Zero or more

The * quantifier in regular expressions means "zero or more," the same as {0,}. Essentially, this means that the character may repeat any number of times or not be present at all.

Using * to look for a digit followed by any number of zeroes (may be many or none):

$string = "100 10 1";
preg_match_all('/\d0*/', $string, $matches);
print_r($matches[0]); // Array: 100, 10, 1

Comparing it with +, which requires one or more of the specified characters:

$string = "100 10 1";
preg_match_all('/\d0+/', $string, $matches);
print_r($matches[0]); // Array: 100, 10
// 1 is not matched, as 0+ requires at least one zero

The * quantifier provides flexibility in matching patterns where a specific character can be present in various quantities or not at all, whereas the + quantifier requires at least one occurrence of the specified character.


Exercise #1

Create a regular expression to find an ellipsis: 3 (or more) dots in a row.

Here's some starter code to help you out:

$regexp = "";
$test = "Hello!... How goes?.....";
preg_match_all($regexp, $test, $matches);
print_r( $matches );

Exercise #2

Create a regular expression to search for valid CSS colors in hexadecimal format. This regular expression only needs to work with 6 hexadecimal characters. For example, #FFFFFF would be a valid result. The expression should also capture the # character.

Here's some starter code:

$regexp = "";
$test = "color:#121212; background-color:#AA00ef bad-colors:f#fddee #fd2 #12345678";
preg_match_all($regexp, $test, $matches);
print_r( $matches );

Key Takeaways

  • Quantifiers define how many times a character, group, or character class must occur in a pattern.
  • {n} matches exactly n occurrences. {n,} matches n or more occurrences. {n,m} matches between n and m occurrences.
  • One or More (+): Matches one or more occurrences of the preceding element. Equivalent to {1,}.
  • Zero or More (*): Matches zero or more occurrences of the preceding element. Equivalent to {0,}.
  • Zero or One (?): Makes the preceding element optional, matching either zero or one occurrence. Equivalent to {0,1}.


Please read this before commenting