Simplify callback logic using named grouping

In PHP, preg_replace_callback_array is a very powerful function that can process multiple regular expressions and execute specified callback functions when matched. Typically, it requires us to specify a callback function for each regular expression, but as the logic complexity increases, this approach may result in callback functions being verbose and not easy to maintain. To simplify this process, we can use named Capture Groups to simplify the callback logic of preg_replace_callback_array , making the code clearer and easier to maintain.

What is named grouping?

In regular expressions, named grouping is a named identifier for the matching result, which allows you to access the matching content by name, not just by numeric indexing. The syntax for naming a group is as follows:

 (?<name>pattern)

where name is the name you give for that grouping, and pattern is the actual regular expression pattern.

Use named grouping to simplify preg_replace_callback_array

In preg_replace_callback_array , we usually pass an array containing multiple patterns and corresponding callback functions. When multiple regular expressions need to be processed, it is often necessary to write a callback function for each expression, which can make the code verbose. By using named grouping, we can get matching results more intuitively, thereby reducing dependence on callback logic.

Here is a specific example:

Example: Processing parameters in URLs

Suppose we have a set of URLs that need to replace some of the query parameters through preg_replace_callback_array . We can simplify the logic of callback functions by using named grouping.

 <?php
// Define an array containing regular expressions and callback functions
$patterns = [
    '/(?<scheme>https?):\/\/(?<host>[a-zA-Z0-9.-]+)\/(?<path>[^?]+)\?(?<query>.*)/' => function ($matches) {
        // Access matching results by named grouping
        $scheme = $matches['scheme'];
        $host = $matches['host'];
        $path = $matches['path'];
        $query = $matches['query'];

        // Here you can process query parameters
        $query = str_replace('example.com', 'm66.net', $query);

        // Returns the replaced string
        return $scheme . '://' . $host . '/' . $path . '?' . $query;
    }
];

// What to deal with URL List
$urls = [
    'https://example.com/path/to/resource?param1=value1&param2=value2',
    'http://example.com/another/path?param1=value1',
];

// use preg_replace_callback_array Make a replacement
$updatedUrls = preg_replace_callback_array($patterns, $urls);

// Output the result after replacement
foreach ($updatedUrls as $url) {
    echo $url . PHP_EOL;
}
?>

Code parsing:

1. Regular expression part:

   • (?<scheme>https?) : Match http or https and name it scheme .

   • (?<host>[a-zA-Z0-9.-]+) : Match the domain name and name it host .

   • (?<path>[^?]+) : Match the path part and name it path .

   • (?<query>.*) : Match the query parameter part and name it query .

2. Callback function part: In the callback function, we obtain the parts of the regular expression match by naming grouping of matches (such as $matches['scheme'] ), which simplifies the access process. We also processed the query string part and replaced the domain name example.com with m66.net .

3. preg_replace_callback_array : This function accepts an array of regular expressions and callback functions, matches the URL one by one and executes the corresponding callback functions.

Results output: