为什么嵌套的 if 语句比使用 && 运算符更快？

Question

其实我很好奇，为什么当我将多个条件合并成一个 if-statement 比多个分开的 if-statement 慢？换句话说，为什么使用 && 很慢？

考虑一下：

$a = 1;
$b = 2;
$c = 3;
$d = 4;
$e = 5;

所以这个的执行时间：0.32209205627441

if ( $a == 1 && $b == 2 && $c == 3 && $d == 4 && $e == 5 ) {}

还有这个：0.25026607513428

if ( $a == 1 ){
    if ( $b == 2 ) {
        if ( $c == 3 ) {
            if ( $d == 4 ) {
                if ( $e == 5 ) {}
            }
        }
    }
}

Online Benchmark

Answer 1

一个明显的区别是长链表达式在每次比较后执行额外的转换为布尔值（因为 && 运算符要求这样做）：

  11    11    >   IS_EQUAL                                         ~16     !0, 1
        12      > JMPZ_EX                                          ~16     ~16, ->15
        13    >   IS_EQUAL                                         ~17     !1, 2
        14        BOOL                                             ~16     ~17
        15    > > JMPZ_EX                                          ~16     ~16, ->18
        16    >   IS_EQUAL                                         ~18     !2, 3
        17        BOOL                                             ~16     ~18
        18    > > JMPZ_EX                                          ~16     ~16, ->21
        19    >   IS_EQUAL                                         ~19     !3, 4
        20        BOOL                                             ~16     ~19
        21    > > JMPZ_EX                                          ~16     ~16, ->24
        22    >   IS_EQUAL                                         ~20     !4, 5
        23        BOOL                                             ~16     ~20
        24    > > JMPZ                                                     ~16, ->25

对

  17    42    >   IS_EQUAL                                         ~30     !0, 1
        43      > JMPZ                                                     ~30, ->52
  18    44    >   IS_EQUAL                                         ~31     !1, 2
        45      > JMPZ                                                     ~31, ->52
  19    46    >   IS_EQUAL                                         ~32     !2, 3
        47      > JMPZ                                                     ~32, ->52
  20    48    >   IS_EQUAL                                         ~33     !3, 4
        49      > JMPZ                                                     ~33, ->52
  21    50    >   IS_EQUAL                                         ~34     !4, 5
        51      > JMPZ                                                     ~34, ->52

除此之外，两种实现的评估看起来非常相似。