Preg_replace的效率

Question

执行摘要：

preg_replace()运行速度比字符串比较快。 为什么？ 正则表达式不应该慢一些吗？

---

在有关检测给定输入中不允许的子字符串数组中的任何一个的最新问题中 ，我建议将preg_replace()调用的结果与原始输入进行比较，因为preg_replace()可以将模式数组作为输入。 因此， if其他解决方案需要一个（或多个）循环，则我的方法可能是单个方法。

我对辩论的答案不感兴趣，因为它确实比循环可读性/可维护性差。 我的答案仍然是-1，为了易于阅读/易于维护，我会接受它，但是我的方法指出的最大错误是效率低下。 那使我感到好奇，并导致我进行了一些测试。 我的结果令我有些惊讶：在所有其他因素保持相等的情况下， preg_replace()比任何其他方法都快 。

您能解释为什么会这样吗？

这些测试的代码以及结果如下：

$input = "In a recent question about detecting any of an array of disallowed substrings within a given input, I suggested comparing the result of a `preg_replace()` call to the original input, since `preg_replace()` can take an array of patterns as input. Thus my method for this could be a single `if` whereas the other solutions required one (or many) loops. I'm not interested in debating my answer, because really it is less readable/maintainable than the loops. However, the biggest fault pointed out with my method was a lack of efficiency. That got me curious, and led me to do some testing. My results were a bit surprising to me: with all other factors held equal, `preg_replace()` was **faster** than any of the other methods. Can you explain why this was the case?";
$input2 = "Short sentence - no matches";
$input3 = "Word";
$input4 = "Short sentence - matches loop";

$start1 = microtime(true);
$rejectedStrs = array("loop", "efficiency", "explain");
$p_matches = 0;
for ($i = 0; $i < 10000; $i++) {
    if (str_check($rejectedStrs, $input)) $p_matches++;
    if (str_check($rejectedStrs, $input2)) $p_matches++;
    if (str_check($rejectedStrs, $input3)) $p_matches++;
    if (str_check($rejectedStrs, $input4)) $p_matches++;
}

$start2 = microtime(true);
$rejectedStrs = array("loop", "efficiency", "explain");
$l_matches = 0;
for ($i = 0; $i < 10000; $i++) {
    if (loop_check($rejectedStrs, $input)) $l_matches++;
    if (loop_check($rejectedStrs, $input2)) $l_matches++;
    if (loop_check($rejectedStrs, $input3)) $l_matches++;
    if (loop_check($rejectedStrs, $input4)) $l_matches++;
}

$start3 = microtime(true);
$rejectedStrs = array("/loop/", "/efficiency/", "/explain/");
$s_matches = 0;
for ($i = 0; $i < 10000; $i++) {
    if (preg_check($rejectedStrs, $input)) $s_matches++;
    if (preg_check($rejectedStrs, $input2)) $s_matches++;
    if (preg_check($rejectedStrs, $input3)) $s_matches++;
    if (preg_check($rejectedStrs, $input4)) $s_matches++;
}

$end = microtime(true);
echo $p_matches." ".$l_matches." ".$s_matches."\n";
echo "str_match: ".$start1." ".$start2."= ".($start2-$start1)."\nloop_match: ".$start2." ".$start3."=".($start3-$start2)."\npreg_match: ".$start3." ".$end."=".($end-$start3);

function preg_check($rejectedStrs, $input) {
    if($input == preg_replace($rejectedStrs, "", $input)) 
        return true;
    return false;
}

function loop_check($badwords, $string) {

    foreach (str_word_count($string, 1) as $word) {
        foreach ($badwords as $bw) {
            if (stripos($word, $bw) === 0) {
                return false;
            }
        }
    }
    return true;
}

function str_check($badwords, $str) {
    foreach ($badwords as $word) {
        if (stripos(" $str ", " $word ") !== false) {
            return false;
        }
    }
    return true;
}

结果

20000 20000 20000

str_match：1282270516.6934 1282270518.5881 = 1.894730091095

loop_match：1282270518.5881 1282270523.0943 = 4.5061857700348

preg_match：1282270523.0943 1282270523.6191 = 0.52475500106812

Answer 1

您能解释为什么会这样吗？

简单。 preg_match在C中实现。其他解决方案在PHP中实现。 现在，这并不意味着正则表达式将永远比同等的PHP更快，但是在大多数情况下，它可能会更快。

最近，我遇到了类似的情况，我有一个函数（一个CamelCase转换器）被调用了数十万次，并且占用了大量的CPU（我分析过）。 我尝试了所有我梦dream以求的PHP重新实现。 preg_replace总是更快。 最后，我按原样保留了该函数，并对其进行了记忆，从而完成了窍门。

在许多情况下，执行的PHP语句越少越好。 如果您可以用一个单独的调用替换替换循环，该调用是在C语言下实现的，那么这可能是您最好的选择。

实际上，它比循环更不易读/难以维护

我不同意。 一线即刻变得简单。 虽然我可能会更喜欢

function preg_check($rejectedStrs, $input) {
    return preg_match($rejectedStrs, "", $input);
}

Answer 2

我们首先来看一下preg_check和loop_check 。 他们两个都必须遍历整个字符串，并且必须检查每个遍历中的每个单词。 因此，它们的行为至少应为O(n*m) ，其中n是字符串的长度， m是不良单词的数量。 您可以通过增加n和m值并绘制3D图来运行算法来进行测试（但是，可能必须也可以不使用n和m很高的值来运行该算法以查看此行为）。

在这里loop_check效率更高 （渐近）。 原因是字符串中的单词数与它们的长度不成比例-我似乎还记得它通常遵循对数函数。 它可能使用哈希表来存储通过这种方式找到的单词，这是在平均恒定时间内完成的（如果我们忽略了可能不得不不时地重建哈希表以容纳更多元素的情况）。

因此loop_check将具有类似于n + m * log(n)的渐近行为，它比n*m 。

现在，这是指算法的渐近行为，即，当m和n很大时（可能需要非常非常大）。 对于m和n较小的值，常数起很大的作用。 特别是，PHP操作码和PHP函数调用的执行比用C实现的同一任务（仅一个函数调用）的开销更大。 这并不能使regex算法更快，而只是对于较小的m和n值可以使其更快。