PHP中单引号和双引号,到底谁快,其实可以一样快

    从接触PHP以来就一直有单引号比双引号的快的思想,今天看了一篇文章,也是关于单引号和双引号的测试,但是我认为那片文章没有测完整,所以自己重测了一遍,发现了一个比较有意思的问题:单引号与双引号快不快可能看写法,写法不同,产生的opcode也是不一样的,自然速度也不一样了。

    测试环境:

    CPU : AMD Athlon(tm) II Dual-Core M300 × 2
    OS  : ubuntu 12.04 32bit
    PHP : PHP Version 5.3.10-1ubuntu3.10
    tool: vld

    代码1:

<?php
$single_str = 'Hello quotes';
$double_str = "Hello quotes";
echo $single_str;
echo $double_str;

$tail = 'quotes';
$single_str_tail = 'Hello '.$tail;
$double_str_tail = "Hello ".$tail;
echo $single_str_tail;
echo $double_str_tail;

$head = 'Hello';
$single_str_head = $head.' quotes';
$double_str_head = $head." quotes";
echo $single_str_head;
echo $double_str_head;
?>

    通过vld产生的结果如下:

line     # *  op              fetch   ext  return  operands
-------------------------------------------------------------
   2     0  >   EXT_STMT                             
         1      ASSIGN                               !0, 'Hello+quotes'
   3     2      EXT_STMT                             
         3      ASSIGN                               !1, 'Hello+quotes'
   4     4      EXT_STMT                             
         5      ECHO                                 !0
   5     6      EXT_STMT                             
         7      ECHO                                 !1
   7     8      EXT_STMT                             
         9      ASSIGN                               !2, 'quotes'
   8    10      EXT_STMT                             
        11      CONCAT                       ~3      'Hello+', !2
        12      ASSIGN                               !3, ~3
   9    13      EXT_STMT                             
        14      CONCAT                       ~5      'Hello+', !2
        15      ASSIGN                               !4, ~5
  10    16      EXT_STMT                             
        17      ECHO                                 !3
  11    18      EXT_STMT                             
        19      ECHO                                 !4
  13    20      EXT_STMT                             
        21      ASSIGN                               !5, 'Hello'
  14    22      EXT_STMT                             
        23      CONCAT                       ~8      !5, '+quotes'
        24      ASSIGN                               !6, ~8
  15    25      EXT_STMT                             
        26      CONCAT                       ~10     !5, '+quotes'
        27      ASSIGN                               !7, ~10
  16    28      EXT_STMT                             
        29      ECHO                                 !6
  17    30      EXT_STMT                             
        31      ECHO                                 !7
  20    32      EXT_STMT                             
        33    > RETURN                               1

    

    可以发现产生的opcode都是一样的,也就是单引号和双引号是一样的,但是我们改一下代码,把双引号的部分换一种写法,也就是把变量放在双引号里面,代码2:

<?php
$single_str = 'Hello quotes';
$double_str = "Hello quotes";
echo $single_str;
echo $double_str;

$tail = 'quotes';
$single_str_tail = 'Hello '.$tail;
$double_str_tail = "Hello $tail";
echo $single_str_tail;
echo $double_str_tail;

$head = 'Hello';
$single_str_head = $head.' quotes';
$double_str_head = "$head quotes";
echo $single_str_head;
echo $double_str_head;
?>


    产生的opcode如下:

line     # *  op              fetch   ext  return  operands
-------------------------------------------------------------
   2     0  >   EXT_STMT                             
         1      ASSIGN                               !0, 'Hello+quotes'
   3     2      EXT_STMT                             
         3      ASSIGN                               !1, 'Hello+quotes'
   4     4      EXT_STMT                             
         5      ECHO                                 !0
   5     6      EXT_STMT                             
         7      ECHO                                 !1
   7     8      EXT_STMT                             
         9      ASSIGN                               !2, 'quotes'
   8    10      EXT_STMT                             
        11      CONCAT                       ~3      'Hello+', !2
        12      ASSIGN                               !3, ~3
   9    13      EXT_STMT                             
        14      ADD_STRING                   ~5      'Hello+'
        15      ADD_VAR                      ~5      ~5, !2
        16      ASSIGN                               !4, ~5
  10    17      EXT_STMT                             
        18      ECHO                                 !3
  11    19      EXT_STMT                             
        20      ECHO                                 !4
  13    21      EXT_STMT                             
        22      ASSIGN                               !5, 'Hello'
  14    23      EXT_STMT                             
        24      CONCAT                       ~8      !5, '+quotes'
        25      ASSIGN                               !6, ~8
  15    26      EXT_STMT                             
        27      ADD_VAR                      ~10     !5
        28      ADD_STRING                   ~10     ~10, '+quotes'
        29      ASSIGN                               !7, ~10
  16    30      EXT_STMT                             
        31      ECHO                                 !6
  17    32      EXT_STMT                             
        33      ECHO                                 !7
  20    34      EXT_STMT                             
        35    > RETURN                               1

    

    现在就能看出区别了,对比11,12以及14,15,16,或者24,25以及27,28,29,就可以发现使用单引号产生了CONCAT和ASSIGN两个动作,使用双引号产生了ADD_STRING,ADD_VAR,ASSIGN三个动作,貌似是单引号要快,因为少一个动作,但是我们还没测CONCAT 是否真的比ADD_STRING,ADD_VAR快,这个可以采用基准测试,或者直接查看对应的C函数代码比较得知。


    总结: 采用代码1中的写法,单引号和双引号的作用是一样的,速度自然也是一样的,采用代码2中的写法,单引号和双引号产生的opcode不一样,虽然多双引号的opcode多一个动作,但是单从opcode还是无法判断单引号要比双引号要快,如果是这样的话后面还是需要其他的测试。

    还有一种造成速度差异的是在分析语法和解释阶段,我看过的那片文章提到了这样一句话:"至于编译阶段,双引号和单引号的区别也是很大的, 我就举个数字来说明: 在scanning阶段, 对于双引号的词法规则有14条,而对于单引号,仅仅只有6条。"

    如果是这样的话,说明双引号在解释编译阶段要慢,那是不是可以通过opcode缓存来消除差异?

你可能感兴趣的:(双引号,vld,PHP单引号,opcode)