* The input string. *

* If matches is provided, then it is filled with * the results of search. $matches[0] will contain the * text that matched the full pattern, $matches[1] * will have the text that matched the first captured parenthesized * subpattern, and so on. *

* flags can be the following flag: * PREG_OFFSET_CAPTURE *

* If this flag is passed, for every occurring match the appendant string * offset will also be returned. Note that this changes the value of * matches into an array where every element is an * array consisting of the matched string at offset 0 * and its string offset into subject at offset 1. *

 * 
 * 

* The above example will output: *

 * Array
 * (
 *     [0] => Array
 *         (
 *             [0] => foobarbaz
 *             [1] => 0
 *         )
 *
 *     [1] => Array
 *         (
 *             [0] => foo
 *             [1] => 0
 *         )
 *
 *     [2] => Array
 *         (
 *             [0] => bar
 *             [1] => 3
 *         )
 *
 *     [3] => Array
 *         (
 *             [0] => baz
 *             [1] => 6
 *         )
 *
 * )
 * 

*

* If this flag is passed, unmatched subpatterns are reported as NULL; * otherwise they are reported as an empty string. *

 * 
 * 

* The above example will output: *

 * array(4) {
 *   [0]=>
 *   string(2) "ac"
 *   [1]=>
 *   string(1) "a"
 *   [2]=>
 *   string(0) ""
 *   [3]=>
 *   string(1) "c"
 * }
 * array(4) {
 *   [0]=>
 *   string(2) "ac"
 *   [1]=>
 *   string(1) "a"
 *   [2]=>
 *   NULL
 *   [3]=>
 *   string(1) "c"
 * }
 * 

*

* Normally, the search starts from the beginning of the subject string. * The optional parameter offset can be used to * specify the alternate place from which to start the search (in bytes). *

* Using offset is not equivalent to passing * substr($subject, $offset) to * preg_match in place of the subject string, * because pattern can contain assertions such as * ^, $ or * (?<=x). Compare: *

 * $subject = "abcdef";
 * $pattern = '/^def/';
 * preg_match($pattern, $subject, $matches, PREG_OFFSET_CAPTURE, 3);
 * print_r($matches);
 * 

 * Array
 * (
 * )
 * 

* while this example *

* will produce *

 * Array
 * (
 *     [0] => Array
 *         (
 *             [0] => def
 *             [1] => 0
 *         )
 * )
 * 

* The pattern to search for, as a string. *

* The input string. *

* Array of all matches in multi-dimensional array ordered according to flags. *

* Can be a combination of the following flags (note that it doesn't make * sense to use PREG_PATTERN_ORDER together with * PREG_SET_ORDER): * PREG_PATTERN_ORDER *
* Orders results so that $matches[0] is an array of full * pattern matches, $matches[1] is an array of strings matched by * the first parenthesized subpattern, and so on. *

* Normally, the search starts from the beginning of the subject string. * The optional parameter offset can be used to * specify the alternate place from which to start the search (in bytes). *

* Using offset is not equivalent to passing * substr($subject, $offset) to * preg_match_all in place of the subject string, * because pattern can contain assertions such as * ^, $ or * (?<=x). See preg_match * for examples. *

* * preg_match_all("|]+>(.*)]+>|U", * "example: this is a test", * $out, PREG_PATTERN_ORDER); * echo $out[0][0] . ", " . $out[0][1] . "\n"; * echo $out[1][0] . ", " . $out[1][1] . "\n"; * * The above example will output:

 * example: , this is a test
 * example: , this is a test
 * 

* So, $out[0] contains array of strings that matched full pattern, * and $out[1] contains array of strings enclosed by tags. *

* The pattern to search for. It can be either a string or an array with * strings. *

* Several PCRE modifiers * are also available, including the deprecated 'e' * (PREG_REPLACE_EVAL), which is specific to this function. *

* The string or an array with strings to replace. If this parameter is a * string and the pattern parameter is an array, * all patterns will be replaced by that string. If both * pattern and replacement * parameters are arrays, each pattern will be * replaced by the replacement counterpart. If * there are fewer elements in the replacement * array than in the pattern array, any extra * patterns will be replaced by an empty string. *

* replacement may contain references of the form * \\n or (since PHP 4.0.4) * $n, with the latter form * being the preferred one. Every such reference will be replaced by the text * captured by the n'th parenthesized pattern. * n can be from 0 to 99, and * \\0 or $0 refers to the text matched * by the whole pattern. Opening parentheses are counted from left to right * (starting from 1) to obtain the number of the capturing subpattern. * To use backslash in replacement, it must be doubled * ("\\\\" PHP string). *

* When working with a replacement pattern where a backreference is * immediately followed by another number (i.e.: placing a literal number * immediately after a matched pattern), you cannot use the familiar * \\1 notation for your backreference. * \\11, for example, would confuse * preg_replace since it does not know whether you * want the \\1 backreference followed by a literal * 1, or the \\11 backreference * followed by nothing. In this case the solution is to use * \${1}1. This creates an isolated * $1 backreference, leaving the 1 * as a literal. *

* When using the deprecated e modifier, this function escapes * some characters (namely ', ", * \ and NULL) in the strings that replace the * backreferences. This is done to ensure that no syntax errors arise * from backreference usage with either single or double quotes (e.g. * 'strlen(\'$1\')+strlen("$2")'). Make sure you are * aware of PHP's string * syntax to know exactly how the interpreted string will look. *

* The string or an array with strings to search and replace. *

* If subject is an array, then the search and * replace is performed on every entry of subject, * and the return value is an array as well. *

* The maximum possible replacements for each pattern in each * subject string. Defaults to * -1 (no limit). *

* If specified, this variable will be filled with the number of * replacements done. *

* If matches are found, the new subject will * be returned, otherwise subject will be * returned unchanged or NULL if an error occurred. */ function preg_replace(array|string $pattern, array|string $replacement, array|string $subject, int $limit = -1, &$count): array|string|null {} /** * Perform a regular expression search and replace using a callback * @link https://php.net/manual/en/function.preg-replace-callback.php * @param string|string[] $pattern

* The pattern to search for. It can be either a string or an array with * strings. *

* A callback that will be called and passed an array of matched elements * in the subject string. The callback should * return the replacement string. This is the callback signature: *

* stringhandler * arraymatches *

* You'll often need the callback function * for a preg_replace_callback in just one place. * In this case you can use an * anonymous function to * declare the callback within the call to * preg_replace_callback. By doing it this way * you have all information for the call in one place and do not * clutter the function namespace with a callback function's name * not used anywhere else. *

* preg_replace_callback and * anonymous function * * /* a unix-style command line filter to convert uppercase * * letters at the beginning of paragraphs to lowercase * / * $fp = fopen("php://stdin", "r") or die("can't read stdin"); * while (!feof($fp)) { * $line = fgets($fp); * $line = preg_replace_callback( * '|

\s*\w|', * function ($matches) { * return strtolower($matches[0]); * }, * $line * ); * echo $line; * } * fclose($fp); * *

* The string or an array with strings to search and replace. *

* The maximum possible replacements for each pattern in each * subject string. Defaults to * -1 (no limit). *

* If specified, this variable will be filled with the number of * replacements done. *

* If matches are found, the new subject will be returned, otherwise * subject will be returned unchanged. */ function preg_replace_callback( array|string $pattern, callable $callback, array|string $subject, int $limit = -1, &$count, #[PhpStormStubsElementAvailable(from: '7.4')] int $flags = 0 ): array|string|null {} /** * Perform a regular expression search and replace using callbacks * @link https://php.net/manual/en/function.preg-replace-callback-array.php * @param callable[] $pattern An associative array mapping patterns (keys) to callbacks (values) * @param string|string[] $subject * @param int $limit [optional] * @param int &$count [optional] * @param int $flags [optional] * @return string|string[]|null

preg_replace_callback_array() returns an array if the subject parameter is an array, or a string otherwise. On errors the return value is NULL

If matches are found, the new subject will be returned, otherwise subject will be returned unchanged.

* If no matches are found or an error occurred, an empty array * is returned when subject is an array * or NULL otherwise. */ function preg_filter(array|string $pattern, array|string $replacement, array|string $subject, int $limit = -1, &$count): array|string|null {} /** * Split string by a regular expression * @link https://php.net/manual/en/function.preg-split.php * @param string $pattern

* The pattern to search for, as a string. *

* The input string. *

* If specified, then only substrings up to limit * are returned with the rest of the string being placed in the last * substring. A limit of -1, 0 or NULL means "no limit" * and, as is standard across PHP, you can use NULL to skip to the * flags parameter. *

* flags can be any combination of the following * flags (combined with the | bitwise operator): * PREG_SPLIT_NO_EMPTY * If this flag is set, only non-empty pieces will be returned by * preg_split. *

* The input string. *

* If the optional delimiter is specified, it * will also be escaped. This is useful for escaping the delimiter * that is required by the PCRE functions. The / is the most commonly * used delimiter. *

* The pattern to search for, as a string. *

* The input array. *

* If set to PREG_GREP_INVERT, this function returns * the elements of the input array that do not match * the given pattern. *