¿Apertura / cierre de tags y rendimiento?

Esta puede ser una pregunta tonta, pero como alguien relativamente nuevo en PHP, me pregunto si hay problemas relacionados con el rendimiento para abrir y cerrar con frecuencia las tags PHP en código de plantilla HTML, y si es así, ¿cuáles podrían ser las mejores prácticas en términos de trabajar con tags PHP?

Mi pregunta no es sobre la importancia / corrección de las tags de cierre, ni sobre qué tipo de código es más legible que otro, sino más bien sobre cómo se analiza / ejecuta el documento y qué impacto puede tener en el rendimiento.

Para ilustrar, considere los siguientes dos extremos:

Mezcla de tags PHP y HTML:

<?php echo ' '.$variable1.' '.$variable2.' '.$variable3.' '.$variable4.' '.$variable5.' ' ?> // PHP tag opened once 

Separación de tags PHP y HTML:

        // PHP tag opened five times 

Estaría interesado en escuchar algunos puntos de vista sobre esto, incluso si es solo para escuchar que no hace ninguna diferencia.

Gracias.

Solutions Collecting From Web of "¿Apertura / cierre de tags y rendimiento?"

3 reglas simples para que puedas hacerlo bien:

  • Ningún problema de syntax puede afectar el rendimiento. La manipulación de datos sí.
  • Habla de rendimiento solo respaldado con resultados de creación de perfiles .
  • La optimización temprana es la raíz de todo mal

Los problemas de rendimiento son bastante difíciles de entender. Se aconseja a los novatos que no lo tengan en cuenta. Porque siempre están impresionados con cosas insignificantes y no pueden ver cosas realmente importantes. Solo por falta de experiencia.

Lo mismo para tu pregunta. Imagina que alguna vez conseguirás algo de diferencia. Incluso uno grande, por ejemplo, un método es 2 veces más rápido. Oh mi, 2 veces! Lo elijo y optimicé bien mi aplicación, ahora funcionará un 50% más rápido.

Mal . No el 50% Nunca notarías ni siquiera medirías este aumento de velocidad. Porque optimizó una parte que toma solo el 0,0001% del tiempo de ejecución del script completo.

En cuanto a las grandes tablas HTML, el navegador tarda mucho tiempo en procesarla. Mucho más de lo que tomaste para generar.

La creación de perfiles es una palabra clave en el mundo del rendimiento. Uno puede criticar cualquier pregunta relacionada con el rendimiento sin dudas si no hay una palabra “perfil” en ella. Al mismo tiempo, perfilar no es una ciencia de cohetes. Solo estoy midiendo el tiempo de ejecución de diferentes partes de tu script. Se puede hacer con algún generador de perfiles, como xdebug, o incluso manualmente, usando microtime(1) . Y solo después de detectar la parte más lenta, puede comenzar con las pruebas.

Aprenda a crear un perfil antes de hacer preguntas sobre el rendimiento. Y aprenda a no hacer preguntas de rendimiento si no hay razones reales para ello.

La optimización prematura es la raíz de todo mal : D.Knuth .

He vuelto a hacer las pruebas con 50,000 filas y agregué el método de multi eco en 1 etiqueta también

 for ($j=0;$j<30;$j++) { foreach ($results as $key=>$val){ ?>  < ?php echo $results[$key][0]?> < ?php echo $results[$key][1]?> < ?php echo $results[$key][2]?> < ?php echo $results[$key][3]?> < ?php echo $results[$key][4]?> < ?php echo $results[$key][5]?> < ?php echo $results[$key][6]?> < ?php echo $results[$key][7]?> < ?php echo $results[$key][8]?> < ?php echo $results[$key][9]?> < ?php echo $results[$key][10]?> < ?php echo $results[$key][11]?> < ?php echo $results[$key][12]?> < ?php echo $results[$key][13]?> < ?php echo $results[$key][14]?>  < ?php } } 

duration1: 31.15542483 Segundos

 for ($k=0;$k<30;$k++) { foreach ($results as $key1=>$val1){ echo ' '.$results[$key1][0].' '.$results[$key1][1].' '.$results[$key1][2].' '.$results[$key1][3].' '.$results[$key1][4].' '.$results[$key1][5].' '.$results[$key1][6].' '.$results[$key1][7].' '.$results[$key1][8].' '.$results[$key1][9].' '.$results[$key1][10].' '.$results[$key1][11].' '.$results[$key1][12].' '.$results[$key1][13].' '.$results[$key1][14].' '; } } 

duration2: 30.23169804 Segundos

 for ($l=0;$l<30;$l++) { foreach ($results as $key2=>$val2){ echo''; echo''.$results[$key2][0].''; echo''.$results[$key2][1].''; echo''.$results[$key2][2].''; echo''.$results[$key2][3].''; echo''.$results[$key2][4].''; echo''.$results[$key2][5].''; echo''.$results[$key2][6].''; echo''.$results[$key2][7].''; echo''.$results[$key2][8].''; echo''.$results[$key2][9].''; echo''.$results[$key2][10].''; echo''.$results[$key2][11].''; echo''.$results[$key2][12].''; echo''.$results[$key2][13].''; echo''.$results[$key2][14].''; echo''; } } 

duration3: 27.54640007 Segundos

No hay mucha diferencia entre los 2 métodos originales, pero parece que es bastante más rápido con menos concatenación @poke

Como dudo que necesite tantos datos en 1 bash, creo que seguiré usando muchas tags, la sangría del código se ve más ordenada y el diseño 'ver fuente' más preciso

Puede ignorar fácilmente la diferencia de rendimiento entre esos dos. Con los recursos informáticos modernos de hoy en día, la diferencia realmente no importa. Este tipo de material de impresión a pantalla realmente no debe preocuparse. Hay muchas otras cosas que deberías considerar antes. Aparte de eso, siempre hay un debate entre el mejor rendimiento y la mantenibilidad de su código. No siempre se puede tratar de lograr el mejor rendimiento. En su lugar, siempre debe considerar las preocupaciones sobre el rendimiento junto con la cantidad de tiempo que necesita invertir para mejorarlas.

El código que es fácil de traducir a pseudocódigo es mejor. Esto se evidencia en los ejemplos anteriores. ¿Qué lleva más tiempo decirlo?

 "Start php, do this 30 times:, then stop php. Print this. Start php, print this, stop php. Print this. Start php, print this, stop php.Print this. Start php, print this, stop php. Print this. Start php, print this, stop php.Print this. Start php, print this, stop php. Print this. Start php, print this, stop php.Print this. Start php, print this, stop php..." "Start php, do this 30 times: print this, then add this to that, then add this to that, then add this to that, then add this to that, then add this to that, then add this to that..." "Start php, do this 30 times: print this, print this, print this, print this, print this, print this, print this..." 

Personalmente, haría:

 "Start php, define this, do this 30 times: add this to that. Print." 

Una explicación técnica sobre cómo funciona el intérprete y por qué una forma es más rápida que otra es irrelevante para un novato. Lo mejor es conocer las reglas generales:

  1. Más simple es mejor.
  2. Si no cabe en una sola página, entonces está haciendo demasiado (descomponerlo).
  3. Si no puede escribir a mano el pseudocódigo en una tarjeta de índice, es demasiado complejo.

Use más tags si el resultado general es más simple. Período.

El verdadero problema con esto es el uso de la memoria. La concatenación de cadenas y el eco masivo pueden boost el uso de memoria de manera exponencial.

Si envía spam a la etiqueta php, su código no podrá leerse.

La mejor solución es usar un motor de plantillas y evitar mezclar código y presentación por completo.