Comparação entre strings com aspas e apóstrofos no PHP

1st-case.php

<?php
$a = 'Neto';

echo $a;

2nd-case.php

<?php
$a = "Neto";

echo $a;

3rd-case.php

<?php
$name = 'Neto';
$string = "Sou o $name";

4th-case.php

<?php
$name = 'Neto';
$string = "Sou o $name e gosto de PHP";

5th-case.php

<?php
$name = 'Neto';
$string = 'Sou o ' . $name . ' e gosto de PHP';

6th-case.php

<?php
$name = "Neto";
$string = "Sou o " . $name . " e gosto de PHP";

String.md

Strings delimitadas por aspas ou apóstrofos não tem nenhuma diferença, em nenhum aspecto, quando são strings simples. Por exemplo:

$a = 'Neto';
$b = "Neto";

Vejam que $a usa apóstrofo e $b usa aspas. Internamente, quando isso for interpretado, não haverá nenhuma, absolutamente nenhuma diferença. O resultado será igual, o tempo de execução será igual. Tudo será igual.

Para demonstrar, comparei o opcode gerado a partir do 1st-case.php e o 2nd-case.php. O opcode é exatamente o mesmo:

1st-case.php

Finding entry points
Branch analysis from position: 0
Return found
filename:       /src/string/1st-case.php
function name:  (null)
number of ops:  5
compiled vars:  !0 = $a
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
	 1      ASSIGN                                                   !0, 'Neto'
   4     2      EXT_STMT                                                 
	 3      ECHO                                                     !0
   5     4    > RETURN                                                   1

branch: #  0; line:     2-    5; sop:     0; eop:     4
path #1: 0, 

2nd-case.php

Finding entry points
Branch analysis from position: 0
Return found
filename:       /src/string/2nd-case.php
function name:  (null)
number of ops:  5
compiled vars:  !0 = $a
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
	 1      ASSIGN                                                   !0, 'Neto'
   4     2      EXT_STMT                                                 
	 3      ECHO                                                     !0
   5     4    > RETURN                                                   1

branch: #  0; line:     2-    5; sop:     0; eop:     4
path #1: 0, 

A diferença ocorre apenas quando temos variáveis dentro da string. Nesses casos, vai haver concatenações até se obter o resultado final. Por exemplo:

$name = 'Neto';
$string = "Sou o $name";

Como a variável está no final da string, teremos apenas 1 concatenação. Já quando temos a variável no meio, vai haver duas concatenações.

$name = 'Neto';
$string = "Sou o $name e gosto de PHP";

Para demonstrar, comparei o opcode gerado a partir do 3rd-case.php e o 4th-case.php.

3rd-case.php

Finding entry points
Branch analysis from position: 0
Return found
filename:       /src/string/3rd-case.php
function name:  (null)
number of ops:  7
compiled vars:  !0 = $name, !1 = $string
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
	 1      ASSIGN                                                   !0, 'Neto'
   3     2      EXT_STMT                                                 
	 3      ADD_STRING                                       ~1      'Sou+o+'
	 4      ADD_VAR                                          ~1      ~1, !0
	 5      ASSIGN                                                   !1, ~1
   4     6    > RETURN                                                   1

branch: #  0; line:     2-    4; sop:     0; eop:     6
path #1: 0, 

4th-case.php

Finding entry points
Branch analysis from position: 0
Return found
filename:       /src/string/4th-case.php
function name:  (null)
number of ops:  8
compiled vars:  !0 = $name, !1 = $string
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
	 1      ASSIGN                                                   !0, 'Neto'
   3     2      EXT_STMT                                                 
	 3      ADD_STRING                                       ~1      'Sou+o+'
	 4      ADD_VAR                                          ~1      ~1, !0
	 5      ADD_STRING                                       ~1      ~1, '+e+gosto+de+PHP'
	 6      ASSIGN                                                   !1, ~1
   4     7    > RETURN                                                   1

branch: #  0; line:     2-    4; sop:     0; eop:     7
path #1: 0, 

Quando temos variáveis dentro da string, o PHP fará adições e atribuições (ADD_STRING e ADD_VAR) para se chegar no resultado esperado, o que é mais lento que fazer a concatenação direta. O 5th-case.php e 6th-case.php demonstram a concatenação diretamente no código PHP, utilizando aspas e apóstrofos. Vejam que o resultado é o mesmo e, em ambos os casos, é melhor que o 4th-case.php.

5th-case.php

Finding entry points
Branch analysis from position: 0
Return found
filename:       /src/string/5th-case.php
function name:  (null)
number of ops:  7
compiled vars:  !0 = $name, !1 = $string
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
	 1      ASSIGN                                                   !0, 'Neto'
   3     2      EXT_STMT                                                 
	 3      CONCAT                                           ~1      'Sou+o+', !0
	 4      CONCAT                                           ~2      ~1, '+e+gosto+de+PHP'
	 5      ASSIGN                                                   !1, ~2
   4     6    > RETURN                                                   1

branch: #  0; line:     2-    4; sop:     0; eop:     6
path #1: 0, 

6th-case.php

Finding entry points
Branch analysis from position: 0
Return found
filename:       /src/string/6th-case.php
function name:  (null)
number of ops:  7
compiled vars:  !0 = $name, !1 = $string
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
	 1      ASSIGN                                                   !0, 'Neto'
   3     2      EXT_STMT                                                 
	 3      CONCAT                                           ~1      'Sou+o+', !0
	 4      CONCAT                                           ~2      ~1, '+e+gosto+de+PHP'
	 5      ASSIGN                                                   !1, ~2
   4     6    > RETURN                                                   1

branch: #  0; line:     2-    4; sop:     0; eop:     6
path #1: 0,

Então, quando se trata de strings simples, tanto faz utilizar aspas ou apóstrofos. O resultado é o mesmo. O problema, que pode prejudicar o desempenho, é a utilização de variáveis dentro da string. Além disso, e agora meu ponto de vista pessoal, ter variáveis dentro da string também prejudica a legibilidade e manutenção do código.

Neto, o que acha de fazer um teste de perfomance/desempenho com sprintf ? Já que você citou :

"ter variáveis dentro da string também prejudica a legibilidade e manutenção do código."

Então, poderíamos ter :

<?php
$name = 'Neto';
$string = sprintf("Sou o %s e gosto de PHP" , $name);

O que você acha ?