PHP Regex Catastrophic Backtracking — Prevent 503 Errors

Every serious PHP application eventually needs to validate, search, or transform text in ways that simple string functions can't handle. Is this email address valid? Does this URL follow the right format? Pull every phone number out of a thousand-word document — can you do that with str_replace? Not a chance. Regular expressions (regex) are the tool PHP developers reach for when the text problem gets complex, and they show up in frameworks, CMS platforms, routing engines, and security filters every single day.

The problem regex solves isn't just 'find a word.' It's 'find any sequence of characters that follows a rule I can describe.' That distinction is everything. Without regex, validating a UK postcode means writing dozens of if-statements. With regex, it's one expressive pattern. The power comes from a small vocabulary of special characters that act like wildcards, counters, and anchors — and once you learn that vocabulary, you can read and write patterns for almost any text problem.

By the end of this article you'll be able to write patterns that validate email addresses and phone numbers, extract data from raw strings using capture groups, perform smart find-and-replace with preg_replace, and dodge the three most common mistakes that trip developers up in production. You'll also understand why PHP uses PCRE (Perl Compatible Regular Expressions) and what that means for you practically.

How PHP Regex Backtracking Can Crash Your Server

A regular expression in PHP is a pattern-matching engine that scans strings character by character, using backtracking to explore alternative paths when a match fails. The core mechanic: the engine tries a greedy quantifier like .* or .+, consumes as much as possible, then backtracks one character at a time to find a valid match. This is not O(n) — it's exponential O(2^n) in worst-case patterns, because each backtracking step can spawn further alternatives.

In practice, the PCRE library (used by preg_match, preg_replace) implements NFA backtracking. When you write a pattern like /(a|aa|aaa)+b/ against a long string of 'a's with no 'b' at the end, the engine tries every possible combination of groups before failing. For a 30-character string, that's over a billion paths. PHP's default backtrack limit (pcre.backtrack_limit) is 1,000,000 — once exceeded, preg_match returns false (not 0), and you get a silent failure or a 503 if the process times out.

Use regex backtracking-aware patterns when validating user input, parsing logs, or extracting data from large strings. The cost isn't CPU cycles — it's process death. A single malicious or accidental input can peg a PHP-FPM worker at 100% for seconds, exhausting the pool and returning 503 errors to all users. This is why every regex in production code must be audited for catastrophic backtracking before deployment.

How PHP's Regex Engine Works — PCRE and the Delimiter Rule

PHP uses the PCRE library — Perl Compatible Regular Expressions — which means patterns work the same way in PHP as they do in Perl, Python's re module, and JavaScript's regex engine. That compatibility is a big deal: patterns you find in documentation, Stack Overflow answers, or security libraries are almost always directly usable in PHP.

Every PHP regex pattern is a string wrapped in delimiters. The most common delimiter is the forward slash: /pattern/. The characters after the closing delimiter are flags (also called modifiers) that change how the engine behaves — for example, i makes the match case-insensitive and m makes ^ and $ match line boundaries instead of the whole string boundary.

You can use almost any non-alphanumeric character as a delimiter — #, ~, |, or @ are popular alternatives when your pattern itself contains forward slashes (like a URL), because it avoids having to escape every slash inside the pattern. This is purely a readability choice; the engine treats all of them the same way.

The three functions you'll use most are preg_match (does this string match?), preg_match_all (find every match), and preg_replace (find and replace using a pattern). Each one takes your delimited pattern string as its first argument.

<?php

// A simple pattern: does the string contain a sequence of digits?
// Delimiters are the two forward slashes. \d means 'any digit character'.
// The + means 'one or more of the preceding thing'
$pattern = '/\d+/';

$orderReference = 'Order #4821 has been dispatched.';
$productCode    = 'Widget-Blue-Large';

// preg_match returns 1 if the pattern is found, 0 if not, false on error
$orderHasNumber   = preg_match($pattern, $orderReference); // 1
$productHasNumber = preg_match($pattern, $productCode);   // 0

echo "Order reference contains digits: " . ($orderHasNumber ? 'YES' : 'NO') . PHP_EOL;
echo "Product code contains digits: "   . ($productHasNumber ? 'YES' : 'NO') . PHP_EOL;

// Using an alternative delimiter — useful when the pattern contains slashes
// This pattern matches a simple URL path segment like /products/42
$urlPattern = '#^/products/(\d+)$#';
$urlPath    = '/products/42';

// The third argument (passed by reference) captures what was matched
if (preg_match($urlPattern, $urlPath, $matches)) {
    // $matches[0] is the full match, $matches[1] is the first capture group
    echo "Product ID from URL: " . $matches[1] . PHP_EOL;
}

// The 'i' flag — case-insensitive matching
$greetingPattern = '/hello/i';
$userInput       = 'HELLO there!';

if (preg_match($greetingPattern, $userInput)) {
    echo "Found a greeting (case-insensitive match)" . PHP_EOL;
}

Capture Groups and Named Captures — Extracting Structured Data

Finding whether a pattern exists is only half the job. Most real-world tasks need you to extract specific pieces of the matched text — the domain part of an email, the year from a date string, the area code from a phone number. That's what capture groups are for.

A capture group is any part of your pattern wrapped in parentheses. When the pattern matches, PHP stores what each group matched in the $matches array: index 0 is always the full match, index 1 is the first group, index 2 is the second, and so on. This numeric indexing works, but it's fragile — if you add a group at the start of the pattern, every index shifts.

Named capture groups solve this. The syntax is (?P<name>pattern) — and instead of $matches[1] you write $matches['name']. Your code becomes self-documenting and refactor-safe. This is the approach used in Laravel's routing engine and most modern PHP frameworks, so it's worth making a habit of it.

For extracting multiple matches from a long string — say, pulling every date from a document — you use preg_match_all instead of preg_match. It finds every non-overlapping occurrence and populates a two-dimensional $matches array.

<?php

// --- Example 1: Numeric capture groups ---
// Pattern breaks an ISO date (2024-03-15) into year, month, day
$isoDatePattern = '/(\d{4})-(\d{2})-(\d{2})/';
$publishedDate  = 'Article published on 2024-03-15.';

if (preg_match($isoDatePattern, $publishedDate, $dateParts)) {
    // Index 0: full match '2024-03-15'
    // Index 1: year, Index 2: month, Index 3: day
    echo "Year: {$dateParts[1]}, Month: {$dateParts[2]}, Day: {$dateParts[3]}" . PHP_EOL;
}

// --- Example 2: Named capture groups (the better approach) ---
// (?P<year>\d{4}) gives the group the name 'year'
// Now the code reads like plain English
$namedDatePattern = '/(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})/';

if (preg_match($namedDatePattern, $publishedDate, $namedParts)) {
    echo "Year: {$namedParts['year']}, Month: {$namedParts['month']}, Day: {$namedParts['day']}" . PHP_EOL;
}

// --- Example 3: preg_match_all — extract every date from a longer document ---
$reportText = 'Invoice raised 2024-01-10. Payment received 2024-02-28. Closed 2024-03-15.';

// PREG_SET_ORDER makes each element of $allMatches a complete match set
$matchCount = preg_match_all($namedDatePattern, $reportText, $allMatches, PREG_SET_ORDER);

echo "Found {$matchCount} dates in the report:" . PHP_EOL;

foreach ($allMatches as $index => $match) {
    // Each $match has the same named keys as a single preg_match call
    echo "  Date " . ($index + 1) . ": {$match['year']}/{$match['month']}/{$match['day']}" . PHP_EOL;
}

// --- Example 4: Named groups for email parsing ---
$emailPattern = '/(?P<localPart>[a-zA-Z0-9._%+\-]+)@(?P<domain>[a-zA-Z0-9.\-]+\.(?P<tld>[a-zA-Z]{2,}))/';
$contactEmail = 'support@thecodeforge.io';

if (preg_match($emailPattern, $contactEmail, $emailParts)) {
    echo "Local part: {$emailParts['localPart']}" . PHP_EOL;
    echo "Domain: {$emailParts['domain']}" . PHP_EOL;
    echo "TLD: {$emailParts['tld']}" . PHP_EOL;
}

preg_replace and preg_replace_callback — Transforming Text Intelligently

Finding text is useful. Replacing it intelligently is where regex earns its salary. preg_replace lets you find a pattern and swap it for a replacement string. Inside the replacement string, $1 or ${1} refers back to the first capture group, $2 to the second, and so on — you can rearrange matched pieces, not just delete them.

But sometimes the replacement isn't a static string — it's the result of a calculation or a database lookup. That's where preg_replace_callback comes in. Instead of a replacement string, you pass a callable. For every match, PHP calls your function with the $matches array and uses whatever you return as the replacement. This turns regex from a text tool into a text processing pipeline.

A real use case: you receive user-generated content and want to auto-link any URL-shaped text. preg_replace_callback finds each URL-shaped string and your callback wraps it in an anchor tag. Another common use: a legacy system stores dates as MM/DD/YYYY and your database expects YYYY-MM-DD — one preg_replace_callback call migrates an entire file.

Keep callbacks focused on one transformation. If your callback is doing three different things, split it into three separate calls — it's far easier to debug.

<?php

// --- Example 1: Reformat a date string using backreferences ---
// Input: MM/DD/YYYY  →  Output: YYYY-MM-DD
// The replacement uses $3, $1, $2 to reorder the captured groups
$usDatePattern     = '/(\d{2})\/(\d{2})\/(\d{4})/';
$legacyDateString  = 'Created 03/15/2024, expires 12/31/2024';

$reformattedDates = preg_replace($usDatePattern, '$3-$1-$2', $legacyDateString);
echo $reformattedDates . PHP_EOL;

// --- Example 2: Mask sensitive data (credit card numbers) ---
// Keep only the last 4 digits, replace everything else with *
// \d{4} matches exactly 4 digits. The whole pattern matches 16-digit card numbers.
$cardPattern     = '/(\d{4})(\d{4})(\d{4})(\d{4})/';
$paymentLog      = 'Charged card 4111111111111234 amount $99.99';

// Replacement keeps only group 4 (last 4 digits)
$maskedLog = preg_replace($cardPattern, '****-****-****-$4', $paymentLog);
echo $maskedLog . PHP_EOL;

// --- Example 3: preg_replace_callback — auto-link URLs in user content ---
$urlPattern  = '#(https?://[^\s<>"]+[^\s<>".,;:!?\)])#i';
$userComment = 'Check out https://thecodeforge.io and https://php.net for more info.';

$linkedComment = preg_replace_callback(
    $urlPattern,
    function (array $match): string {
        // $match[0] is the full matched URL
        // We sanitise the URL before embedding it in HTML
        $safeUrl = htmlspecialchars($match[0], ENT_QUOTES, 'UTF-8');
        return "<a href=\"{$safeUrl}\" rel=\"noopener\">{$safeUrl}</a>";
    },
    $userComment
);

echo $linkedComment . PHP_EOL;

// --- Example 4: preg_replace_callback — dynamic price formatting ---
// Multiply every price in a string by 1.2 (add 20% tax)
$pricePattern = '/\$(\d+\.\d{2})/';
$productList  = 'Widget $9.99, Gadget $24.99, Thingamajig $4.50';

$pricesWithTax = preg_replace_callback(
    $pricePattern,
    function (array $match): string {
        $priceWithTax = round((float)$match[1] * 1.20, 2);
        // number_format ensures we always get 2 decimal places
        return '$' . number_format($priceWithTax, 2);
    },
    $productList
);

echo $pricesWithTax . PHP_EOL;

Real-World Validation Patterns — Email, Phone, Passwords and Postcodes

Validation is where most developers first meet regex, and it's also where most developers write patterns they'll regret. The golden rule: your regex doesn't have to be perfect — it has to be good enough to catch obvious errors while staying readable and maintainable.

Email addresses are the classic example. The technically correct RFC 5322 pattern is hundreds of characters long and nearly impossible to maintain. In practice, a pattern that validates the general shape — local part, @ symbol, domain with at least one dot — catches 99.9% of typos without being a maintenance nightmare.

For passwords, regex is excellent at enforcing structure rules: minimum length, must contain uppercase, must contain a digit. The trick is using lookaheads — patterns that assert something must exist ahead in the string without consuming characters.

A positive lookahead looks like (?=...). You can chain multiple lookaheads at the start of a pattern, each one asserting a different rule. This is far cleaner than writing multiple separate preg_match calls.

Always wrap validation in a dedicated function with a clear name. That function becomes your single source of truth — change the pattern once, and every call site benefits.

<?php

/**
 * Validates an email address using a practical (not RFC-perfect) pattern.
 * Good enough for form validation; catches obvious typos and format errors.
 */
function isValidEmail(string $email): bool {
    // [a-zA-Z0-9._%+\-]+ matches the local part (before the @)
    // [a-zA-Z0-9.\-]+ matches the domain name
    // [a-zA-Z]{2,} matches the TLD — at least 2 letters
    $emailPattern = '/^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$/';
    return (bool) preg_match($emailPattern, $email);
}

/**
 * Validates a UK mobile number.
 * Accepts formats: 07911 123456, +447911123456, 07911123456
 */
function isValidUKMobile(string $phoneNumber): bool {
    // Strip all spaces first so the pattern doesn't need to account for them
    $normalised    = preg_replace('/\s+/', '', $phoneNumber);
    // Matches 07xxxxxxxxx or +447xxxxxxxxx (11 or 13 digits)
    $mobilePattern = '/^(\+44|0)7\d{9}$/';
    return (bool) preg_match($mobilePattern, $normalised);
}

/**
 * Validates password strength using lookaheads.
 * Rules: min 8 chars, at least 1 uppercase, 1 lowercase, 1 digit, 1 special char.
 */
function isStrongPassword(string $password): bool {
    // Each (?=...) is a lookahead — it checks ahead without moving the cursor
    // (?=.*[A-Z])    — must contain at least one uppercase letter somewhere
    // (?=.*[a-z])    — must contain at least one lowercase letter somewhere
    // (?=.*\d)       — must contain at least one digit somewhere
    // (?=.*[^a-zA-Z\d]) — must contain at least one non-alphanumeric char
    // .{8,}          — the actual string must be at least 8 characters long
    $passwordPattern = '/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[^a-zA-Z\d]).{8,}$/';
    return (bool) preg_match($passwordPattern, $password);
}

/**
 * Validates a UK postcode (e.g. SW1A 1AA, EC1A 1BB, W1A 0AX)
 */
function isValidUKPostcode(string $postcode): bool {
    $normalised      = strtoupper(trim($postcode));
    $postcodePattern = '/^[A-Z]{1,2}[0-9][0-9A-Z]?\s?[0-9][ABD-HJLNP-UW-Z]{2}$/';
    return (bool) preg_match($postcodePattern, $normalised);
}

// --- Test all validators ---
$testEmails = ['user@example.com', 'bad@', 'also.bad', 'good+tag@domain.co.uk'];
echo "=== Email Validation ===".PHP_EOL;
foreach ($testEmails as $email) {
    echo "  {$email}: " . (isValidEmail($email) ? 'VALID' : 'INVALID') . PHP_EOL;
}

$testPhones = ['07911 123456', '+447911123456', '0207 123 4567', '07911123456'];
echo PHP_EOL."=== UK Mobile Validation ===".PHP_EOL;
foreach ($testPhones as $phone) {
    echo "  {$phone}: " . (isValidUKMobile($phone) ? 'VALID' : 'INVALID') . PHP_EOL;
}

$testPasswords = ['weak', 'AllLetters1', 'N0Special!', 'Str0ng@Pass!'];
echo PHP_EOL."=== Password Strength Validation ===".PHP_EOL;
foreach ($testPasswords as $password) {
    echo "  {$password}: " . (isStrongPassword($password) ? 'STRONG' : 'WEAK') . PHP_EOL;
}

$testPostcodes = ['SW1A 1AA', 'ec1a1bb', 'W1A 0AX', 'INVALID', 'BS1 4DJ'];
echo PHP_EOL."=== UK Postcode Validation ===".PHP_EOL;
foreach ($testPostcodes as $postcode) {
    echo "  {$postcode}: " . (isValidUKPostcode($postcode) ? 'VALID' : 'INVALID') . PHP_EOL;
}

Debugging Regex Performance and Catastrophic Backtracking

You tested your regex with a 20-character string. It worked instantly. Then in production, a user submits a 10KB log file and your server goes down. That's catastrophic backtracking — the regex engine takes exponential time trying every possible combination of quantifiers before failing.

The root cause is nested or overlapping greedy quantifiers: .., (.+)+, or .foo.bar.* without anchors. The engine tries all ways to split the string. With 1000 characters, that's more combinations than atoms in the universe.

PHP provides two safety nets: pcre.backtrack_limit (default 1,000,000) and pcre.recursion_limit (default 100,000). When exceeded, preg_match returns false and preg_last_error() returns PCRE_BACKTRACK_LIMIT_ERROR (2) or PCRE_RECURSION_LIMIT_ERROR (3). You should always check for these in production.

The fix is to rewrite patterns using possessive quantifiers (++), atomic groups (?>...), or more specific character classes [^ ] instead of .. Anchoring the pattern with ^ and $ also limits backtracking.

<?php

// --- The problematic pattern: nested greedy quantifiers ---
$badPattern = '/(.*)+(.)+(.*)+/';
$shortString = 'short';
$longString  = str_repeat('a', 10000);

// This will trigger backtrack limit on long input
$result = preg_match($badPattern, $longString);
if ($result === false) {
    $error = preg_last_error();
    echo "Backtrack error code: $error" . PHP_EOL;
    // $error == 2 means PCRE_BACKTRACK_LIMIT_ERROR
}

// --- The fix: possessive quantifiers and atomic groups ---
// Possessive quantifier ++ gives up backtracking as soon as it matches
$goodPattern = '/[^\n]*+foo[^\n]*+/';
$text = 'first line foo something' . "\n" . 'second line bar';

if (preg_match($goodPattern, $text, $match)) {
    echo "Match with possessive: " . $match[0] . PHP_EOL;
}

// --- Atomic groups: (?>...) prevents backtracking inside ---
$atomicPattern = '/(?>".*?")[^\\"]*/';
$jsonSample    = '"key" : "value"';

if (preg_match($atomicPattern, $jsonSample)) {
    echo "Atomic group matched" . PHP_EOL;
}

// --- Best practice: set limits in code for critical paths ---
$oldLimit = ini_get('pcre.backtrack_limit');
ini_set('pcre.backtrack_limit', 500000);

$pattern = '/^[a-zA-Z]+$/';  // simple pattern, safe
if (preg_match($pattern, 'HelloWorld') === 1) {
    echo "Pattern works with custom limit" . PHP_EOL;
}

ini_set('pcre.backtrack_limit', $oldLimit);

Modifiers That Change Everything — and Break Everything

Modifiers aren't decorations. They rewrite the engine's behavior. The i modifier makes patterns case-insensitive. m turns ^ and $ into line-boundary anchors instead of string-boundary anchors. s makes the dot match newlines. x lets you add whitespace and comments inside your pattern — invaluable for complex regexes. But here's the trap: u enables UTF-8 mode. Without it, PCRE treats strings as raw bytes. If your subject contains multibyte characters and you omit u, the pattern silently matches garbage. Worse: S (study) caches the compiled pattern for repeated matches, but J (JIT) does it at runtime. Both improve speed but increase memory. Never use e (PREGR) — it was removed in PHP 7.0 because it executed arbitrary code. The real danger is R (recursive matching) or X (extra features). If you stack modifiers without understanding each one, you're debugging crashes at 3 AM. Test modifiers one at a time.

// io.thecodeforge
$email = "User@Example.COM\n";
// Without 'i', this fails
$pattern = '/^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/i';
if (preg_match($pattern, trim($email))) {
    echo "Valid email with case-insensitive match.\n";
}

// With 'm', ^ and $ match per line
$multiline = "Line1\nLine2\nLine3";
echo preg_match('/^Line2$/m', $multiline) ? "Found Line2\n" : "Missed\n";

Atomic Groups and Possessive Quantifiers — Stop Backtracking Before It Stops You

Catastrophic backtracking kills servers. Atomic groups and possessive quantifiers are your artillery. An atomic group (?>pattern) tells the engine: once you match this, never backtrack into it. Possessive quantifiers ++, *+, ?+ work the same way — they grab everything and refuse to give it back. Use them when you know a subpattern can't match later alternatives. Example: parsing HTML tags. A naive pattern /<[^>]+>/ backtracks on every failure. Write it as /<[^>]++>/ — possessive ++ prevents backtracking into the bracket content. This drops worst-case complexity from O(2^n) to O(n). In a web app processing user input at scale, that's the difference between a 200ms response and a white screen of death. Test with regex101.com's debugger. Watch the backtracking steps drop to zero when you switch to atomic or possessive. Your ops team will thank you.

// io.thecodeforge
$subject = "<div class='main'>Content</div>string";

// Catastrophic backtracking risk
$bad = '/<div[^>]*>.*<\/div>/';
$time_start = microtime(true);
preg_match($bad, $subject);
echo "Bad pattern: " . (microtime(true) - $time_start) . "s\n";

// Atomic group prevents backtracking
$good = '/<div[^>]*>(?>.*?)<\/div>/';
$time_start = microtime(true);
preg_match($good, $subject);
echo "Good pattern: " . (microtime(true) - $time_start) . "s\n";

PHP 8.4 New Regex Features

PHP 8.4 introduces several enhancements to PCRE2 that improve regex capabilities and performance. Key additions include support for Unicode 15.1 properties, which allow matching based on new character classifications like emoji sequences and script extensions. The \p{Emoji} property now correctly matches full emoji sequences, not just base characters. Additionally, PHP 8.4 adds the (NO_JIT) verb to disable JIT compilation for specific patterns, useful when JIT causes stack limit errors. The PREG_UNMATCHED_AS_NULL flag is now the default behavior, returning null for unmatched groups instead of empty strings, simplifying null checks. Example: /\p{Emoji_Presentation}/u matches emoji like 😀. The (NO_JIT) verb can be placed at the start of a pattern: /(*NO_JIT)\d+/. These features help write more precise and efficient regex patterns.

<?php
// Unicode 15.1 emoji matching
$pattern = '/\p{Emoji_Presentation}/u';
preg_match($pattern, '😀', $matches);
var_dump($matches); // ['😀']

// Using (*NO_JIT) to disable JIT for a pattern
$pattern = '/(*NO_JIT)\d{10}/';
$result = preg_match($pattern, '1234567890');
var_dump($result); // 1

// PREG_UNMATCHED_AS_NULL default in PHP 8.4
$pattern = '/(a)?(b)/';
preg_match($pattern, 'b', $matches);
var_dump($matches[1]); // null (instead of empty string)
?>

Regex Performance with PREG_JIT_STACKLIMIT_ERROR Handling

Catastrophic backtracking often manifests as PREG_JIT_STACKLIMIT_ERROR (error code 6) when PCRE2's JIT compiler runs out of stack space. This error occurs with deeply nested patterns or excessive backtracking, causing preg_match to return false and generating a warning. To handle this gracefully, check preg_last_error() after regex operations. For example:

``php if (preg_last_error() === PREG_JIT_STACKLIMIT_ERROR) { // Fallback: disable JIT for this pattern $pattern = '/(*NO_JIT)' . $pattern . '/'; preg_match($pattern, $subject, $matches); } ``

Alternatively, increase the JIT stack size via pcre.jit_stack_size in php.ini (default 64K). For high-traffic applications, monitor error logs for PREG_JIT_STACKLIMIT_ERROR and adjust patterns to reduce backtracking. Using atomic groups (?>...) or possessive quantifiers ++ can prevent stack overflow. Example: /\d++/ instead of /\d+/. Always validate regex results with preg_last_error() to ensure reliability.

<?php
$pattern = '/(a+)+b/';
$subject = str_repeat('a', 100);
$result = preg_match($pattern, $subject);

if ($result === false) {
    $error = preg_last_error();
    if ($error === PREG_JIT_STACKLIMIT_ERROR) {
        echo "JIT stack limit reached. Retrying with (*NO_JIT)\n";
        $pattern = '/(*NO_JIT)(a+)+b/';
        $result = preg_match($pattern, $subject);
        if ($result === false) {
            echo "Still failing: " . preg_last_error_msg();
        }
    } else {
        echo "Other error: " . preg_last_error_msg();
    }
}

// Using possessive quantifier to avoid backtracking
$safe_pattern = '/(a++)+b/';
$result = preg_match($safe_pattern, $subject);
var_dump($result); // 0 (no match, but no error)
?>

Named Capturing Groups for Readable Patterns

Named capturing groups improve regex readability and maintainability by assigning names to groups instead of numeric indices. In PHP, use (?P<name>...) or (?<name>...) syntax. Named groups can be accessed via $matches['name'] in preg_match and referenced in replacement strings with \k<name> or ${name}. For example, extracting email parts:

$pattern = '/(?P<local>[^@]+)@(?P<domain>[^@]+)/';
preg_match($pattern, 'user@example.com', $matches);
echo $matches['local']; // user
echo $matches['domain']; // example.com

In preg_replace, use ${name} for backreferences: preg_replace('/(?P<year>\d{4})-(?P<month>\d{2})/', '${month}/${year}', '2024-01'). Named groups also work with preg_match_all and preg_replace_callback. They make patterns self-documenting and reduce errors when reordering groups. Best practice: always use named groups for patterns with multiple captures, especially in production code.

<?php
// Extract URL components using named groups
$pattern = '/^(?P<scheme>https?):\/\/(?P<host>[^\/]+)(?P<path>\/.*)?$/';
$url = 'https://example.com/path?query=1';
preg_match($pattern, $url, $matches);
echo "Scheme: " . $matches['scheme'] . "\n";
echo "Host: " . $matches['host'] . "\n";
echo "Path: " . ($matches['path'] ?? '/') . "\n";

// Using named groups in preg_replace
$date = '2024-01-15';
$pattern = '/(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})/';
$replacement = '${day}/${month}/${year}';
echo preg_replace($pattern, $replacement, $date); // 15/01/2024

// Named groups in preg_replace_callback
$pattern = '/(?P<word>\w+)/';
$result = preg_replace_callback($pattern, function($m) {
    return strtoupper($m['word']);
}, 'hello world');
echo $result; // HELLO WORLD
?>