The key to PHP regular expression performance optimization is to reduce the number of backtracking and matches; 1. Avoid greedy matching and backtracking, use non-greedy patterns, avoid nested quantifiers, and reduce the use of capture groups; 2. Compile regular expressions in advance, and use static variables or class constant storage to reduce duplicate parsing overhead; 3. Prioritize string functions to replace simple matching tasks, such as strpos, substr, etc. to improve efficiency; 4. Reasonably use anchor points and boundary control characters such as ^, $, and \b to limit the matching range, and speed up the engine judgment speed.

Performance optimization of PHP regular expressions is actually a common problem, especially in scenarios where large amounts of text or frequent calls are handled. If the regular writes are not good, the interface response will be slowed down, and the service will be stuck directly. Therefore, it is worth taking a little time to understand how to write efficient PHP rules.

1. Try to avoid greedy matching and backtracking

PHP's PCRE engine is greedy to match by default, which means it matches as much content as possible. But this "greed" behavior often leads to a lot of backtracking , especially in long strings.

For example:

 preg_match('/.*abc/', $str);

If $str is long and no abc appears, the engine will try various possible combinations from scratch until confirmation is really not found, which can be very time-consuming.

suggestion:

• Use non-greedy mode (add ? ), such as /.*?abc/
• Avoid nested quantifiers (such as (a ) ), such structures are most likely to cause catastrophic backtracking
• If you can use the capture group, don't use it, or use a non-capture group instead (?:...)

2. Compile regular expressions in advance

If you use the same regular expression multiple times in a loop, PHP re-parses and compiles it each time. Although this process is fast, performance losses will also accumulate in high-frequency calls.

Suggestion: Write regulars into static variables or class constants and compile them only once.

For example:

 function matchEmail($email) {
    static $pattern = '/^[a-z0-9._% -] @[a-z0-9.-] \.[az]{2,}$/i';
    return preg_match($pattern, $email);
}

This reduces the overhead of duplicate compilation.

3. Alternatives prioritize string functions

Sometimes you just want to determine whether a substring exists or extract content in a fixed format. At this time, using strpos , substr or explode is faster than regular.

For example, if you want to determine whether a URL contains parameters like ?id=123 :

 if (strpos($url, '?id=') !== false) { ... }

This is much faster than writing a regular match, and the logic is clearer.

When is the right time to use regularity?

• Multiple variants need uniform matching (such as verification of mailboxes, URLs)
• A situation where the structure is complex and cannot be solved with simple string operations
• When you need to extract data in groups

4. Rational use of anchor points and boundary control

If you know that the matching position should be at the beginning, end or word boundary, adding anchor points such as ^ , $ , \b can significantly improve efficiency.

For example, the following two regularities are the difference:

 // Without anchor points, it will traverse the entire string to find matching preg_match('/error/', $log_line);

// With anchor points, tell the engine to only look for preg_match('/^error/', $log_line);

The second method allows the engine to quickly decide whether to continue matching, saving time.

In general, the performance optimization of PHP regularity mainly relies on two points: one is to avoid unnecessary backtracking, and the other is to minimize the matching range and number of times. When writing, think about whether there are more efficient ways. Sometimes, seemingly simple changes have a great impact on performance.

Basically that's it.

The above is the detailed content of php regex performance. For more information, please follow other related articles on the PHP Chinese website!