A few days ago Fabien Potencier, lead developer of Symfony project, published a new component  of the Symfony Components project.

As you may not know yet, Symfony components is a “lego way” that Fabien and symfony team found to publish piece by piece the parts that will compose the next big version of symfony framework, the very waited symfony 2 version.

This last component is a templating framework, but what is that?

A Templating Framework and some history

A big part of php developers around the world use day-by-day a templating engine, like smarty and phptal.

A group of devs have asked in symfony mailing lists to use symfony together with one of those engines.

But bundle a template engine together with Symfony was never in mind of core team, for some(and good) reasons.

Some time ago, the Symfony components project was released and putting all parts together we can understand everything, the answer is a templating framework(not a template engine) , giving us a flexibe way to implement whatever “engine” we want in a standard way.

Wich template engine?

Well, to test Symfony templating framework we need to choice a engine to reproduce.
Wich one?
Smarty? No, thanks. Too flat to me.
PHPTal? Maybe
Haml? Hum, far away from html and php syntax. A good example to see if the framework  is good

Implementing Haml Templating Engine with Symfony templating framework

Since Haml isn’t exactly a tiny language, I’ll implement just a few features.

The goal is parse this example:

!!!
%html
  %head
    %title= $title
  %body
    #header
      %h1 Symfony templating Haml example
    #content
      %img {:src => 'http://haml-lang.com/images/haml.gif'}
      %h2 Haml
      %p Haml is a markup language that’s used to cleanly and simply describe the HTML of any web document without the use of inline code. Haml functions as a replacement for inline page templating systems such as PHP, ASP, and ERB, the templating language used in most Ruby on Rails applications. However, Haml avoids the need for explicitly coding HTML into the template, because it itself is a description of the HTML, with some code to generate dynamic content.
    #footer
      %span.author Lucas Stephanou

The simple Symfony Haml Template Engine

Since phphaml is very easy to use, our template renderer class will be simple.

<?php

/**
 * sfTemplateRendererHaml is a renderer for Haml templates.
 *
 * @package    symfony
 * @subpackage templating
 * @author     Lucas Stephanou <lucas@lucas-ts.com>
 * @version    SVN: $Id$
 */
class sfTemplateRendererHaml extends sfTemplateRenderer
{
  private $hamlParser;

  public function __construct(HamlParser $hamlParser)
  {
    $this->hamlParser = $hamlParser;
  }    

  /**
   * Evaluates a template.
   *
   * @param mixed $template   The template to render
   * @param array $parameters An array of parameters to pass to the template
   *
   * @return string|false The evaluated template, or false if the renderer is unable to render the template
   */
  public function evaluate(sfTemplateStorage $template, array $parameters = array())
  {  

    // even if $template is a string representation, hamlParser will take care of this
    $this->hamlParser->setFile($template);

    foreach($parameters as $key => $val)
    {
      $this->hamlParser->assign($key,$val);
    }   

    return $this->hamlParser->render();
  }
}

The

<?php
__construct(HamlParser $hamlParser)

method receive a HamlParser class as argument, this will allow us to implement all this with  DI in the next article.

<?php
evaluate($template, array $parameters = array())

this method  is all we need to do for  a renderer class, we receive a $template instance(object or a string) and $parameters.

Them the symfony templating framework will expect to receive a string(in case of success ) or a boolean false if something goes wrong.

Testing

To test if we do all right, just create a single file:

<?php

require_once '../../symfony_templating/lib/sfTemplateAutoloader.php';
sfTemplateAutoloader::register();

$loader = new sfTemplateLoaderFilesystem(dirname(__FILE__).'/%name%.haml');

require_once dirname(__FILE__).'/../lib/phphaml/haml/HamlParser.class.php';
$parser = new HamlParser();

require_once dirname(__FILE__).'/../lib/sfTemplateRendererHaml.php';
$engine = new sfTemplateEngine($loader,array(
 'haml' => new sfTemplateRendererHaml($parser),
));

echo $engine->render('haml:example', array('title' => 'Haml Lucas Test'));

Al l code is pretty obvious

1. register symfony templating autoload
2. instantiate a template loader (in this case a filesystem loader)
3. include the HamlParser and instantiate it
4. include our haml renderer class
5. create a template engine indicating that our class will render haml files
6. render  the template passing a single parameter(title)

In the next article we will integrate the symfony dependency injection lib and create a more flexible way to load templates

All code are here for download:

http://dl.getdropbox.com/u/1417411/sfSimpleHaml.tar.bz2

It’s a Screencast covering a Symfony Tutorial, the  Jobeet Day 1

I’m thinking in continue the series of jobeet if people like this one and so start  increasing quality(+audio,+tips) of nexts

About Screencast:
It’s take a fresh ubuntu  and starting install everything that we need to run php/symfony and all things related to Jobeet Day 1

For this screencast, I can’t record audio and edit the video, is purely what I got from screencast recorder, sorry for that.

you can see it larger direct in vimeo website:
http://www.vimeo.com/5518192

Symfony Screencast – Jobeet Day 1 from lucas stephanou on Vimeo.

Apesar de ter 3 anos, a instalação ainda funciona normalmente.

Mas irei atualiza-lo em breve refletindo alguns avançoes que tivemos.

De uma olhada: Symfony com lighttpd e php5 compilado

Meu primeiro artigo no blog, uma tradução do otimo post de Reinhold, depois desse espero ter sempre artigos e traduções de qualidade sobre PHP. ( fiz algumas alterações e coloquei links para alguns artigos relacionados)

[UPDATE]
Algumas correções de português, adicionados exemplos.
Obrigado Pablo.
[/UPDATE]

Ai esta: (Thank you Reinhold)

1. Se um método pode ser estatico, declare ele estatico. O fator de otimização é 4x+
2. echo é mais rapido que print. Veja
3. Prefira usar echo com multiplo parametros ao invés de concatenar string
   1. echo “parametro um”, $var , “outro parametro”
4. Set o valor maximo  do seus loops FOR antes e não no for
   #onde:

   1. for($i=0;$i<count($array);$i++)
   2. #use:
   3. $max_for = count($array);
   4. for($i=0;$i<$max_for;$i++)
5. Sempre de unset em variaveis que nao serão mais usadas, principalemente grandes arrays.
6. Tente não usar métodos magicos, como:  __get, __set, __autoload
7. require_once() tem custo elevado, prefira include[_once], como alertado pelo Pablo, o include_once é mais custoso que o include.
8. Use caminhos completos em includes e requires, o PHP gastara menos tempo resolvendo os caminhos.
9. Se você deseja descobrir quando o script começou a ser executado, $_SERVER[’REQUEST_TIME’]  é melhor que time()
10. Se você puder, use strncasecmp, strpbrk e stripos no lugar de funcões regex
11. str_replace é mais rápida que preg_replace, mas strtr é ainda 4x mais rapida que str_replace.
12. Se uma função, como troca de string , aceitar tanto arrays quanto caracteres unicos e a sua lista de argumentos não for muito longa, considere escrever algumas vezes o mesmo codigo passando um caracter por vez ao invés de uma linha passando arrays nos argumentos de pesquisa e troca.
13. É melhor usar switch/case do que multiplos if’s e else.
14. Usar supressão de erros com @ na frente da função é muito lento.
15. Ative o mod_deflate do apache( modulo de compressão de resposta).
16. Feche as conexões ao banco de dados quando você não for mais usa-lo.
17. $row[’id’] é 7x mais rapido que  $row[id]
18. Mensagens de erros tem custo elevado, desligue-as em produção.
19. Não use funcões dentro de loops, como:
    1. for ($x=0; $x < count($array); $x)

    A função count() é chamada em cada iteração.

20. Incrementando uma variavel local é mais rapido.
21. Incrementando uma variavel global é 2x mais lento que em uma variavel local.
22. Incrementando uma propriedade ( $this->prop++) é 3x mais lento que em uma variavel local.
23. Incrementando uma variavel local não definida é de 9x a 10x mais lento do que uma variavel local pré-inicializada.
24. Declarando uma variável global sem usá-lo em uma função também atrasa as coisas (com aproximadamente a mesma quantidade incrementando como uma variavel local).O PHP provavelmente faz um checagem para ver se existe a nível global
25. A invocação de métodos parece ser independente do número de métodos definidos em uma classe, em uma classe de teste onde se adicionou 10 metódos não teve mudança de performance.
26. Métodos em classes derivadas rodam mais rápido do que aqueles definidos na classe base.
27. Use ‘ ao invés de ” em strings quando não for preciso usar variaveis ou escapes, assim o PHP não necessita procurar e interpretar esses caracteres especiais.
28. Prefira usar HTML puro se for possivel, scripts PHP são servidos de 2x a 10x mais lentos que equivalentes.
29. Em cada requisição seus scripts PHP são recompilados, use uma solução de cache, isso pode te dar um ganho de 25 a 100% . Veja
30. Quando lidando com string e você precisar verificar se a string possui certo tamanho, você entendidamente desejara usar a função strlen().
    Essa função é bastante rapida, já que ela não faz nenhum calculo, apenas retorna o tamanho ja conhecido da string disponivel na estrutura zval(estrutura interna do C usada para guardar variaveis PHP). No entanto como strlen() é uma função ela ainda assim é lenta, porque o PHP precisa fazer varias operações  como lowercase e buscas na hashtable, e em seguida executar a dita função.
    Algumas vezes você podera aumentar a velocidade do seu código usando um truque com isset().
    Exemplo: Digamos que voce tem :
    if (strlen($foo) < 5) { echo “Foo is too short”; }

    1. # versus
    2. if (!isset($foo{5})) { echo “Foo is too short”; }

    Usando isset() sera mais rapido que strlen(), porque diferente de strlen(), isset() é um construtor de linguagem e não uma função, isso quer dizer que a sua execução não necessita busca na hashtable nem uso de lowercase. Virtualmente você não sobrecarga no código atual para determinar o tamanho da string.

31. Quando incrementando ou decrementando o valor de uma variavel, $i++ normalmente é mais lenta que  ++$i. Isso é especifico para PHP, ou seja, não se aplica a outras linguagens, não sai por ai modificando seu código java ou C. Isso se da porque $i++ usa 4 opcodes enquanto ++$i precisa de somente 3.
32. Nem tudo precisa ser OOP, gera muita sobrecarga, cada chamada de método e objeto consome um monte de memória.
33. Não implemente cada estrutura de dados como uma classe, arrays são utéis também.
34. Não divida muito os métodos, pense bem cada código que sera reusado.
35. Você sempre podera dividir o código no futuro, caso necessario.
36. Faça uso das incontaveis funções pré-definidas.
37. Se você tem muito tempo consumido por funções em seu código, considere escreva-las como extensões C.
38. Faça Profile do seu código. Um profiler mostra quanto tempo cada parte do seu código consome. A extensão  Xdebug ja contém um profiler.
39. Excelente artigo sobre otimização PHP de John Lim (inglês)