¿Diferencia de velocidad al usar cadenas en línea versus concatenación en php5?

Question

(supongamos php5) considere

<?php

    $foo = 'some words';

    //case 1
    print "these are $foo";

    //case 2
    print "these are {$foo}";

    //case 3
    print 'these are ' . $foo;
?>

¿Hay mucha diferencia entre 1 y 2?

Si no, ¿qué pasa entre 1/2 y 3?

Answer 1

Bueno, como ocurre con todas las preguntas sobre "¿Qué podría ser más rápido en la vida real?", no hay nada mejor que una prueba de la vida real.

function timeFunc($function, $runs)
{
  $times = array();

  for ($i = 0; $i < $runs; $i++)
  {
    $time = microtime();
    call_user_func($function);
    $times[$i] = microtime() - $time;
  }

  return array_sum($times) / $runs;
}

function Method1()
{ 
  $foo = 'some words';
  for ($i = 0; $i < 10000; $i++)
    $t = "these are $foo";
}

function Method2()
{
  $foo = 'some words';
  for ($i = 0; $i < 10000; $i++)
    $t = "these are {$foo}";
}

function Method3()
 {
  $foo = 'some words';
  for ($i = 0; $i < 10000; $i++)
    $t = "these are " . $foo;
}

print timeFunc('Method1', 10) . "\n";
print timeFunc('Method2', 10) . "\n";
print timeFunc('Method3', 10) . "\n";

Dale unas cuantas ejecuciones para paginar todo, luego...

0.0035568

0.0035388

0.0025394

Entonces, como era de esperar, la interpolación es prácticamente idéntica (diferencias en el nivel de ruido, probablemente debido a los caracteres adicionales que el motor de interpolación necesita manejar).La concatenación directa es aproximadamente el 66% de la velocidad, lo que no es una gran sorpresa.El analizador de interpolación buscará, no encontrará nada que hacer y luego terminará con una simple cadena interna concat.Incluso si el concat fuera caro, el interpolador todavía tendrá que hacerlo, después todo el trabajo para analizar la variable y recortar/copiar la cadena original.

Actualizaciones de Somnath:

Agregué Method4() a la lógica en tiempo real anterior.

function Method4()
 {
  $foo = 'some words';
  for ($i = 0; $i < 10000; $i++)
    $t = 'these are ' . $foo;
}

print timeFunc('Method4', 10) . "\n";

Results were:

0.0014739
0.0015574
0.0011955
0.001169

Cuando solo estás declarando una cadena y no necesitas analizar esa cadena también, entonces ¿por qué confundir el depurador de PHP con el análisis?Espero que hayas entendido mi punto.

Answer 2

La diferencia de rendimiento ha sido irrelevante desde al menos enero de 2012, y probablemente antes:

Single quotes: 0.061846971511841 seconds
Double quotes: 0.061599016189575 seconds

Es posible que las versiones anteriores de PHP hayan tenido una diferencia: personalmente prefiero las comillas simples a las comillas dobles, por lo que fue una diferencia conveniente.La conclusión del artículo hace un comentario excelente:

Nunca confíes en una estadística que no hayas falsificado tú mismo.

(Aunque el artículo cita la frase, la broma original probablemente fue falsa. atribuido a Winston Churchill, inventado por el ministerio de propaganda de Joseph Goebbels para presentar a Churchill como un mentiroso:

Ich traue keiner Statistik, die ich nicht selbst gefälscht habe.

Esto se traduce aproximadamente como "No confío en una estadística que no haya falsificado".)

Answer 3

Puntos de referencia en vivo:

http://phpbench.com/

En realidad, existe una diferencia sutil al concatenar variables con comillas simples o dobles.

Answer 4

Se utilizó la prueba de @Adam

"these are " . $foo

tenga en cuenta que lo siguiente es aún más rápido:

'these are ' . $foo;

esto se debe al hecho de que se evalúa una "cadena" entre comillas dobles, mientras que una "cadena" entre comillas simples se toma tal cual...

Answer 5

No se deje atrapar demasiado por intentar optimizar las operaciones de cadenas en PHP.Concatenación vs.la interpolación no tiene sentido (en el rendimiento del mundo real) si las consultas de su base de datos están mal escritas o no está utilizando ningún tipo de esquema de almacenamiento en caché.Escriba sus operaciones de cadena de tal manera que depurar su código más adelante sea fácil, las diferencias de rendimiento son insignificantes.

@uberfuzzy Suponiendo que esto es solo una pregunta sobre minucias del lenguaje, supongo que está bien.Solo estoy tratando de agregar a la conversación que comparar el rendimiento entre comillas simples, comillas dobles y heredoc en aplicaciones del mundo real no tiene sentido en comparación con los sumideros de rendimiento reales, como consultas deficientes a bases de datos.

Answer 6

Cualquier diferencia en el tiempo de ejecución es completamente insignificante.

Por favor mira

• Blog de NikiC:Refutando el mito del rendimiento de las comillas simples para obtener una explicación técnica de cómo funcionan la interpolación y la concatenación en PHP y por qué es absolutamente inútil preocuparse por su velocidad.

No pierda el tiempo en microoptimizaciones como esta.Utilice un generador de perfiles para medir el rendimiento de su aplicación en un escenario del mundo real y luego optimícelo donde realmente sea necesario.Es probable que optimizar una única consulta de base de datos descuidada genere una mejora de rendimiento mayor que aplicar microoptimizaciones en todo el código.

Answer 7

Creo recordar que el desarrollador del software del foro, Vanilla, reemplazó todas las comillas dobles en su código con comillas simples y notó un aumento razonable en el rendimiento.

Sin embargo, parece que no puedo encontrar un enlace a la discusión en este momento.

Answer 8

hay una diferencia al concatenar variables...y que estas haciendo con el resultado...y si lo que está haciendo es volcarlo a la salida, el almacenamiento en búfer de salida está activado o no.

Además, ¿cuál es la situación de la memoria del servidor?normalmente la gestión de la memoria en una plataforma de nivel superior es peor que en plataformas inferiores...

$a = 'parse' . $this; 

está gestionando la memoria a nivel de plataforma de código de usuario...

$a = "parse $this";

está administrando la memoria a nivel de plataforma de código del sistema php...

por lo que estos puntos de referencia relacionados con la CPU no cuentan la historia completa.

ejecutar el punto de referencia 1000 veces versus ejecutar el punto de referencia 1000 veces en un servidor que intenta ejecutar la misma simulación 1000 veces simultáneamente...es posible que obtenga resultados drásticamente diferentes según el alcance de la aplicación.

Answer 9

Las comillas dobles pueden ser mucho más lentas.Leí en varios lugares que es mejor hacer esto.

'parse me '.$i.' times'

que

"parse me $i times"

Aunque diría que el segundo te dio un código más legible.

Answer 10

Sólo para agregar algo más a la mezcla, si está utilizando una variable dentro de una sintaxis de cadena entre comillas dobles:

$foo = "hello {$bar}";

es más rápido que

$foo = "hello $bar";

y ambos son más rápidos que

$foo = 'hello' . $bar; 

Answer 11

¡Prácticamente no hay ninguna diferencia!Ver los horarios: http://micro-optimization.com/single-vs-double-quotes

Answer 12

Cabe señalar que, cuando se utiliza una versión modificada del ejemplo de Adam Wright con 3 variables, los resultados se invierten y las dos primeras funciones son en realidad más rápidas y consistentes.Esto es con PHP 7.1 en CLI:

function timeFunc($function, $runs)
{
    $times = array();

    for ($i = 0; $i < $runs; $i++)
    {
        $time = microtime();
        call_user_func($function);
        @$times[$i] = microtime() - $time;
    }

    return array_sum($times) / $runs;
}

function Method1()
{ 
    $foo = 'some words';
    $bar = 'other words';
    $bas = 3;
    for ($i = 0; $i < 10000; $i++)
         $t = "these are $foo, $bar and $bas";
}

function Method2()
{
    $foo = 'some words';
    $bar = 'other words';
    $bas = 3;
    for ($i = 0; $i < 10000; $i++)
         $t = "these are {$foo}, {$bar} and {$bas}";
}

function Method3()
{
    $foo = 'some words';
    $bar = 'other words';
    $bas = 3;
    for ($i = 0; $i < 10000; $i++)
         $t = "these are " . $foo . ", " . $bar . " and " .$bas;
}

print timeFunc('Method1', 10) . "\n";
print timeFunc('Method2', 10) . "\n";
print timeFunc('Method3', 10) . "\n";

También probé con '3' en lugar de solo el número entero 3, pero obtengo el mismo tipo de resultados.

Con $bas = 3:

0.0016254
0.0015719
0.0019806

Con $bas = '3':

0.0016495
0.0015608
0.0022755

Cabe señalar que estos resultados varían mucho (obtengo variaciones de alrededor del 300%), pero los promedios parecen relativamente estables y casi (9 de cada 10 casos) siempre muestran una ejecución más rápida para los 2 primeros métodos, siendo siempre el Método 2 ligeramente más rápido que el método 1.

En conclusión:Lo que es cierto para una sola operación (ya sea interpolación o concatenación) no siempre es cierto para operaciones combinadas.