为什么整数上的 in_array 严格模式比非严格模式慢？

Question

我一直认为in_array严格模式会更快或者至少和非严格模式一样的速度。但是经过一些基准测试后，我注意到在搜索整数时它们之间的执行时间存在巨大差异。字符串和数组测试表明严格模式更快。为什么？

测试代码 - (PHP 7.2.1)：

<?php

$array = array_fill(0, 10000, 12345);

for ($i=0; $i<100000; $i++) {
    in_array($i, $array, true);
}

时间 php test.php

php -c test.php 12.98s user 0.04s system 98% cpu 13.234 total

---

<?php

$array = array_fill(0, 10000, 12345);

for ($i=0; $i<100000; $i++) {
    in_array($i, $array, false);
}

时间 php test.php

php -c test.php 6.44s user 0.04s system 99% cpu 6.522 total

Answer 1

这似乎与针和/或干草堆中的元素类型有关，请注意：

来自http://sandbox.onlinephpfunctions.com/的PHP 7.3.5

$iterations = 10000000;
$needle = false;
$haystack = [ true ];

$start = microtime( true );
for( $i = 0; $i < $iterations; ++$i )
{
    in_array( $needle, $haystack, true );
}
echo ( microtime( true ) - $start ).' strict'.PHP_EOL;

$start = microtime( true );
for( $i = 0; $i < $iterations; ++$i )
{
    in_array( $needle, $haystack, false );
}
echo ( microtime( true ) - $start ).' not strict';

产生：

0.29996585845947 strict
0.40397191047668 not strict

但如果我们使用：

$needle = 1;
$haystack = [ 2 ];

然后我们得到：

0.34480714797974 strict
0.28275084495544 not strict

---

但是，PHP 5.6.29 产生的差异可以忽略不计，并且多次运行相同的测试可以将严格优先于非严格，反之亦然。

Answer 2

我可以通过跟踪 in_array 的 C 源代码提供一些小见解。

事实证明，在比较整数时，到达非严格模式的实际相等性检查的路径比严格模式涉及的操作更少。

严格模式

在in_array 的strict 标志为真的情况下，会发生以下情况：

1. We call fast_is_identical_function for each element in the array

2. fast_is_identical_function 第一 测试每个操作数的类型是否不同（Z_TYPE_P(op1) != Z_TYPE_P(op2)），希望能够尽早返回false；这是比较#1。

3. 如果类型相同（在您的测试用例中它们是相同的），我们然后测试(Z_TYPE_P(op1) <= IS_TRUE；我不知道这是做什么的，但它是比较#2。

4. 在两个比较都评估为false、we jump into zend_is_identical 之后，我们的第一个函数调用。

5. zend_is_identical 以 再次 测试 Z_TYPE_P(op1) != Z_TYPE_P(op2) 开始，这是另一次提前失败的尝试。这是比较#3。

6. 如果类型相同，我们可以通过switch (Z_TYPE_P(op1))语句下降，比较#4

7. 最后我们得到了比较Z_LVAL_P(op1) == Z_LVAL_P(op2)，它实际上测试了两个值的相等性，comparison #5。

总的来说，为了测试数组的每个元素是否等于我们正在搜索的值，有 5 次比较和 1 次函数调用。

非严格模式

相比之下，专门针对整数的非严格流程（真的是LONGs）要简单得多，如下：

1. 数组中的每个元素都不是fast_is_identical_function，而是we instead use fast_equal_check_function。

2. fast_equal_check_function 方法启动了一个更复杂的过程，将两个值与各种类型转换逻辑进行比较。但是，它所做的 first 测试恰好针对整数进行了优化，如下所示：

   if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
       if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
           return Z_LVAL_P(op1) == Z_LVAL_P(op2);
   

   我们可以看到它...

   1. 立即测试op1的类型是否为LONG，是的，然后
   2. 立即测试op2的类型是否为LONG，是的，然后
   3. 立即返回Z_LVAL_P(op1) == Z_LVAL_P(op2)的结果

非严格情况下总共进行了 3 次简单相等比较和 0 次函数调用，而严格情况下至少进行了 5 次比较和 1 次跳转。

这似乎是这样一种情况，即尝试进行早期优化会使严格检查变慢（通过反复测试操作数的类型，希望我们能更快地找到不等式）而不是特定的非严格情况比较两个整数。