¿Diferencia de velocidad en el uso de cadenas en línea frente a la concatenación en php5?

(asumir php5) considerar

 

¿Hay mucha diferencia entre 1 y 2?

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

Bueno, como con todas las preguntas “¿Qué podría ser más rápido en la vida real?”, No se puede superar 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 vueltas para buscar todo, entonces ...

0.0035568

0.0035388

0.0025394

Entonces, como era de esperar, la interpolación es prácticamente idéntica (diferencias de 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 un gran shock. El analizador de interpolación se verá, no encontrará nada que hacer, luego terminará con un string de cadena interna simple. Incluso si el concat fuera caro, el interpolador todavía tendrá que hacerlo, después de todo el trabajo para analizar la variable y recortar / copiar la cadena original.

Actualizaciones por Somnath:

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

 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 acaba de declarar solo una cadena y no es necesario analizar también esa cadena, ¿por qué confundir el depurador de PHP para analizar? Espero que entiendas mi punto.

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 

Las versiones anteriores de PHP pueden haber tenido una diferencia: personalmente prefiero las comillas simples a las comillas dobles, por lo que era una diferencia conveniente. La conclusión del artículo es un excelente punto:

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

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

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

Esto se traduce vagamente a “No confío en una estadística de que no me fingí”).

Puntos de referencia en vivo:

http://phpbench.com/

En realidad, hay una diferencia sutil cuando se concatenan variables con comillas simples versus dobles.

@ Prueba de Adam utilizada

 "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” con comillas dobles, donde una sola cadena citada se toma como está …

No se deje demasiado atrapado tratando de optimizar las operaciones de cadena en PHP. La concatenación frente a la interpolación no tiene sentido (en el rendimiento del mundo real) si las consultas de la base de datos están mal escritas o si no está utilizando ningún tipo de esquema de almacenamiento en caché. Escriba sus operaciones de cadena de tal manera que la depuración de su código más tarde será fácil, las diferencias de rendimiento son insignificantes.

@uberfuzzy Suponiendo que esto sea solo una pregunta sobre la minucia del lenguaje, supongo que está bien. Solo estoy tratando de agregar a la conversación que comparar el rendimiento entre aplicaciones de comillas simples, comillas dobles y heredoc en el mundo real es insignificante cuando se compara con los receptores de rendimiento real, como las consultas de bases de datos deficientes.

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

Por favor mira

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

No pierdas tiempo en micro-optimizaciones como esta. Utilice un generador de perfiles para medir el rendimiento de su aplicación en un escenario del mundo real y luego optimice donde realmente se necesita. Es probable que la optimización de una sola consulta DB descuidada mejore mucho más el rendimiento que la aplicación de micro-optimizaciones en todo su código.

Me parece recordar que el desarrollador del software del foro, Vanilla reemplazó todas las comillas dobles en su código con comillas simples y notó una cantidad razonable de aumento en el rendimiento.

Parece que no puedo rastrear un enlace a la discusión en este momento.

hay una diferencia cuando se concatenan variables … y lo que se está haciendo con el resultado … y si lo que se está haciendo es arrojarlo a la salida, se está almacenando o no el búfer de salida.

también, ¿cuál es la situación de memoria del servidor? por lo general, la gestión de la memoria en una plataforma de nivel superior es peor que en las plataformas inferiores …

 $a = 'parse' . $this; 

es administrar la memoria en el nivel de plataforma de código de usuario …

 $a = "parse $this"; 

es la gestión de la memoria en el nivel de la plataforma de código del sistema php …

entonces estos puntos de referencia relacionados con la CPU no cuentan la historia completa.

ejecutar el punto de referencia 1000 veces vs ejecutar el punto de referencia 1000 veces en un servidor que está intentando ejecutar esa misma simulación 1000 veces al mismo tiempo … es posible que obtenga resultados drásticamente diferentes según el scope de la aplicación.

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.

¡Prácticamente no hay diferencia en absoluto! Vea los tiempos: http://micro-optimization.com/single-vs-double-quotes

Solo para agregar algo más a la mezcla, si está usando una variable dentro de una syntax 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; 

Cabe señalar que, al utilizar una versión modificada del ejemplo de Adam Wright con 3 variables, los resultados se invierten y las dos primeras funciones son realmente 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 he intentado con '3' en lugar de solo con el 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 aproximadamente 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 el Método 2 siempre ligeramente más rápido que el método 1.

En conclusión: lo que es cierto para 1 sola operación (ya sea de interpolación o concatenación) no siempre es cierto para las operaciones combinadas.