Please wait

Understanding Modifiers and Flags

PHP offers a variety of built-in string functions that allow you to manipulate and analyze text data. These functions can perform tasks like converting a string to uppercase, trimming whitespace, replacing certain words, and so on.

While these string functions are powerful, there are scenarios where they may not be enough. This is especially true when you need to perform more complex pattern-based searches, replacements, or validations.

This is where regular expressions come into play. Regular expressions, often referred to as regex, are a way to describe complex patterns within strings.

Why use Regular Expressions?

Imagine you're trying to find a needle in a haystack, but the needle can be in many shapes or sizes. Regular expressions are like a magical tool that can find that needle, no matter its form, as long as it follows a certain pattern.

The main advantages of regular expressions are:

  • Pattern Matching: You can search for a specific pattern in a string. For example, finding all email addresses in a text.
  • Validation: You can check if a string follows a specific format, like verifying if a user's input is a valid phone number.
  • Replacement: You can find and replace a complex pattern within a string, such as formatting dates.
  • Flexibility: They allow you to define very specific or very general patterns, making them incredibly versatile.

Regular expressions are like a Swiss Army knife for working with text. While PHP's string functions can handle many text-related tasks, regular expressions give developers the ability to perform intricate manipulations and checks that go beyond what standard string functions can achieve.

For an absolute beginner, think of regular expressions as a special code that describes a pattern you want to find (or avoid) in a text. It's like having a superpower for handling text, allowing you to do things that would otherwise be incredibly complex or downright impossible.

Understanding PCRE

PHP has a set of functions for performing regular expressions, which can be found here:

They're referred to as PCRE Functions. PCRE, or Perl Compatible Regular Expressions, in PHP, is a way to search for specific patterns in text. It's called "Perl Compatible" because it uses the same rules and symbols as the Perl programming language. This allows PHP to have powerful tools for working with text, inspired by Perl's well-known abilities in this area. In simple terms, if you want to find, match, or replace certain words or patterns in a text, PCRE in PHP is a set of tools designed to help you do that, using rules similar to Perl's.


A regular expression is written as a pattern enclosed between delimiters, usually forward slashes (/). Inside this pattern, various characters and symbols are used to describe what you want to match.

Here's a basic breakdown of what a regular expression might look like:

  • Delimiters: These are symbols that define the start and end of the pattern. Commonly, the forward slash (/) is used.
  • Pattern: This is the sequence of characters inside the delimiters that define what you want to match.
  • Modifiers: These are optional characters that can follow the closing delimiter to change the behavior of the pattern, such as making it case-insensitive.

Here's an example:

  • The / characters are the delimiters.
  • pattern is the specific sequence you want to match.
  • i is a modifier that makes the match case insensitive.

Constructing a regular expression requires understanding these symbols and their meanings and combining them to create a pattern that matches what you're looking for. It's a bit like constructing a puzzle where each piece has a specific role in defining what the final picture looks like.

Regular expressions can range from simple patterns, like /dog/ to match the word "dog", to highly complex ones that can validate an email address or find specific types of information in large texts.


Delimiters are characters that are used to mark the beginning and end of a pattern. They help the parser recognize where the pattern starts and stops, separating it from other parts of the expression, such as modifiers. You can think of them as opening or closing quotes for strings. An opening quote tells PHP where a string begins, and another quote tells PHP where it ends.

In PHP, you can use several characters as delimiters for regular expressions. The most common one is the forward slash (/), but other characters can be used as well. Here's a list of some supported delimiters:

  • Forward Slash: /
  • Hash: #
  • Tilde: ~
  • Exclamation Mark: !
  • Percent Sign: %
  • At Sign: @

Here are examples of using different delimiters in PHP for the same pattern:

  • Using forward slash: /pattern/
  • Using hash: #pattern#
  • Using tilde: ~pattern~

Escaping Delimiters

In PHP, and programming in general, "escaping" a character means to treat it as a literal character rather than as a special or reserved character that could be interpreted in a different way by the language or context.

Certain characters have special meanings in specific contexts. For example, in a regular expression, the dot (.) is a special character that matches any character except a new line. If you want to use the dot to match itself literally, you have to "escape" it.

To escape a character, you usually prefix it with a backslash (\). Here's how you might escape a dot in a regular expression:

  • Special meaning: . (matches any character)
  • Escaped for literal meaning: \. (matches a literal dot)

If the delimiter character appears inside the pattern itself, it must be escaped with a backslash. For example, if you want to match a URL that contains slashes, you might choose to use a different delimiter or escape the slashes:

  • Escaping slashes: /http:\/\/example\.com/
  • Using a different delimiter: #

Escaping is a way to tell PHP (or any programming language) "Don't treat this character in its special way; treat it just as itself." It's a fundamental concept that helps in forming correct syntax, preserving the intended meaning of a sequence of characters, and maintaining security.

Selecting an appropriate delimiter can make the pattern more readable, especially when the pattern includes characters that could be confused with the delimiter itself.


Modifiers in regular expressions are characters that follow the pattern and change how the pattern is applied. They're like settings or switches that you can turn on to change how the pattern works.

Here are some of the common modifiers supported in PHP:

i (Case-Insensitive):

  • Without the i: A and a are different.
  • With the i: A and a are the same.
  • Example: /apple/i will match "apple", "Apple", "aPple", etc.

m (Multiline Mode):

  • Without the m: The pattern only looks at the beginning and end of the whole text.
  • With the m: The pattern looks at the beginning and end of each line in the text.
  • Example: /^apple/m will match "apple" at the beginning of any line, not just the beginning of the whole text.

s (Dotall Mode):

  • Without the s: The dot (.) matches any character except a newline.
  • With the s: The dot (.) matches any character, including newlines.
  • Example: /apple.sauce/s will match "apple\nsauce" where "\n" is a newline character.

u (UTF-8 Mode):

  • Without the u: The pattern treats text as plain bytes.
  • With the u: The pattern treats text as UTF-8 encoded, understanding multibyte characters.
  • Example: /apple/u will correctly handle characters from various languages encoded in UTF-8.

x (Extended Mode):

Allows you to add whitespace and comments within the pattern for better readability.

U (Ungreedy Mode):

By default, certain parts of a pattern match as much as possible. The U modifier makes them match as little as possible.


Performing a regular expression match in PHP is commonly done using the preg_match() function. This function searches a string for a pattern, returning true if the pattern exists and false otherwise.

Using the preg_match() function

You'll use the preg_match() function, giving it the regular expression and the string you want to search. Here's what it might look like in code:

This code looks for the word "apple" in the text "I have an apple." Since "apple" does appear in the text, the code will print "Match found!".

$pattern = '/apple/'; // The pattern to search for
$text = 'I have an apple.'; // The text to search in
if (preg_match($pattern, $text)) {
  echo 'Match found!';
} else {
  echo 'No match found.';

Storing the Match

You can store the matches found by the preg_match() function in a variable by providing an additional argument to the function. This argument will be an array that gets filled with the matches that were found.

In this code, $matches is an empty array when you call preg_match(), but after the function is called, it's filled with the parts of $text that match the pattern.

Keep in mind preg_match() only returns the first match found.

$pattern = '/apple/';
$text = 'I have an apple and another apple.';
$matches = []; // An empty array that will be filled with the matches
if (preg_match($pattern, $text, $matches)) {
  print_r($matches); // Print all the matches
} else {
  echo 'No match found.';

Multiple Matches

If you want to find multiple matches of a pattern within a string in PHP, you can use the preg_match_all() function. This function works similarly to preg_match(), but instead of stopping after finding the first match, it continues to search the entire string and collects all matches.

In this example, we're using the same pattern we had in the first example. Since there are three instances of the word "apple" in the string, the result of $matches will be all three instances.

preg_match_all() is the go-to function in PHP for finding all occurrences of a pattern within a string. It's like a super-powered "Find All" command for text!

$pattern = '/apple/';
$text = 'I have an apple, you have an apple, we all have apples!';
$matches = []; // An empty array to store the matches
if (preg_match_all($pattern, $text, $matches)) {
  print_r($matches[0]); // Print all the matches
} else {
  echo 'No matches found.';


You're not limited to searching for values but replacing them as well. You can replace a value using a regular expression with the preg_replace() function. This function takes a pattern to search for, a replacement value, and the subject string where the replacement should happen. It returns a new string with the pattern replaced by the replacement value.

Suppose you want to replace the word "apple" with "orange" in a given text. Here's how you can do it:

$pattern = '/apple/';
$replacement = 'orange';
$text = 'I like apples.';
$newText = preg_replace($pattern, $replacement, $text);
echo $newText; // Output: 'I like oranges.'

In this code, $pattern is the text you want to find ("apple"), $replacement is what you want to replace it with ("orange"), and $text is the original text. The preg_replace() function does the replacement, and the result is stored in $newText.

Key Takeaways

  • Regular expressions are patterns used for matching character combinations in strings.
  • PHP uses the PCRE (Perl Compatible Regular Expressions) library, allowing the same syntax and semantics as Perl.
  • preg_match(): Finds the first match of a pattern.
  • preg_match_all(): Finds all matches of a pattern.
  • preg_replace(): Replaces occurrences of a pattern with a specified text.
  • preg_split(): Splits a string by a regular expression pattern.
  • Regular expressions must be enclosed in delimiters, such as forward slashes (/pattern/).
  • Modifiers like i (case-insensitive), m (multiline), s (dot matches all), and u (UTF-8) affect how matching is performed.
  • Special characters must be escaped with a backslash (\) if they are to be treated as literals.
  • Regular expressions are essential for validating input, searching within strings, replacing text, and splitting strings based on patterns.


Please read this before commenting