Abrindo / fechando tags e desempenho?

Esta pode ser uma pergunta boba, mas como alguém relativamente novo em PHP, estou me perguntando se há algum problema relacionado ao desempenho para abrir e fechar tags PHP com frequência no código de modelo HTML e, em caso afirmativo, quais podem ser as melhores práticas em termos de trabalhar com tags PHP?

Minha pergunta não é sobre a importância / exatidão das tags de fechamento ou sobre qual tipo de código é mais legível do que outro, mas sim sobre como o documento é analisado / executado e que impacto isso pode ter no desempenho.

Para ilustrar, considere os dois extremos a seguir:

Combinação de tags PHP e HTML:

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

Separando tags PHP e HTML:

<tr>
   <td><?php echo $variable1 ?></td>
   <td><?php echo $variable2 ?></td>
   <td><?php echo $variable3 ?></td>
   <td><?php echo $variable4 ?></td>
   <td><?php echo $variable5 ?></td>
</tr>
// PHP tag opened five times

Teria interesse em ouvir algumas opiniões sobre isso, mesmo que seja apenas para saber que não faz diferença.

Obrigado.

3 regras simples para você acertar:

• Nenhum problema de sintaxe pode afetar o desempenho. A manipulação de dados sim.
• Fale de desempenho apenas com resultados de perfis .
• Otimização prematura é a raiz de todo o mal

Os problemas de desempenho são muito difíceis de entender. É aconselhável que os novatos não o levem em consideração. Porque eles sempre se impressionam com coisas insignificantes e não conseguem ver coisas realmente importantes. Só por falta de experiência.

O mesmo vale para sua pergunta. Imagine que você vai conseguir alguma diferença. Mesmo grande, digamos, um método é 2 vezes mais rápido. Nossa, 2 vezes! Eu escolhi e otimizei bem meu aplicativo, ele rodará 50% mais rápido agora!

Errado . Não 50%. Você nunca notaria ou mesmo mediria esse aumento de velocidade. Porque você otimizou uma parte que ocupa apenas 0,0001% de todo o tempo de execução do script.

Quanto às grandes tabelas HTML, leva muito tempo para o navegador renderizá-las. Muito mais do que você demorou para gerar.

Profiling é uma palavra-chave no mundo da performance. Qualquer questão relacionada ao desempenho pode ser descartada sem dúvidas se não houver nenhuma palavra "perfil" nela. Ao mesmo tempo, criar perfis não é uma ciência espacial. Estou apenas medindo o tempo de execução de diferentes partes do seu script. Pode ser feito com algum profiler, como xdebug, ou mesmo manualmente, usando microtime(1). E só depois de detectar a parte mais lenta, você pode começar com os testes.

Aprenda a traçar o perfil antes de fazer perguntas sobre desempenho. E aprenda a não fazer perguntas sobre desempenho se não houver motivos reais para isso.

A otimização prematura é a raiz de todos os males - D.Knuth .

Refiz os testes com 50.000 linhas e adicionei o método multi eco em 1 tag também

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

duração1: 31,15542483 segundos

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

duração2: 30,23169804 segundos

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

duração3: 27,54640007 segundos

Não há muita diferença entre os 2 métodos originais, mas parece que é um pouco mais rápido com menos concatenação @poke

Como duvido que precise de tantos dados de uma só vez, acho que continuarei a usar muitas tags, a indentação do código parece mais organizada e o layout de 'fonte de visualização' mais preciso

Você pode ignorar facilmente a diferença de desempenho entre os dois. Com os recursos de computação modernos de hoje, a diferença realmente não importa. Não devemos nos preocupar com esse tipo de impressão na tela. Existem várias outras coisas que você deve considerar antes. Além disso, sempre há um debate entre o melhor desempenho e a capacidade de manutenção do seu código. Nem sempre você pode tentar obter o melhor desempenho. Em vez disso, você deve sempre considerar as questões de desempenho junto com a quantidade de tempo que você precisa gastar para melhorá-las.

O código que é fácil de traduzir em pseudocódigo é melhor. Isso é evidenciado pelos exemplos acima. O que demora mais para dizer?

"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..."

Pessoalmente, eu faria:

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

Uma explicação técnica sobre como o intérprete funciona e por que uma maneira é mais rápida do que outra é irrelevante para um novato. É melhor apenas conhecer as regras básicas:

1. Mais simples é melhor.
2. Se não couber em uma única página, é porque está fazendo muito (divida-o).
3. Se você não puder escrever o pseudocódigo em um cartão de índice, ele é muito complexo.

Use mais tags se o resultado geral for mais simples. Período.

O verdadeiro problema com isso é o uso de memória. A concatenação de strings e o eco em massa podem aumentar o uso de memória exponencialmente.

Se você enviar spam para a tag php, seu código se tornará ilegível.

A melhor solução é usar um mecanismo de modelo e evitar misturar código e apresentação.