Template engines are really famous in the PHP World nowadays. As of today, I always disliked template engines written in PHP and I always advocated to use pure PHP templates to generate views.

Some of you still probably follow the same opinion. In fact PHP sucks as a template engine. Why? Because PHP is so much verbose, PHP doesn't support automatic output escaping and modern templating features, PHP doesn't ease separation of concerns (aka MVC architecture)... Of course, there is Twig to the rescue! A modern and powerful template engine you will love.

Most of well-known templating engine libraries also suck for many reasons. They mainly offer a very restricted syntax (only variables and loops) and they are not secure and flexible. They are also slow and not efficient as they don't cache anything and exploit regular expressions when parsing a template. So, what to do? Twig to the rescue!

My point of view about template engines has changed today since I use Twig with Symfony2 and I will give six main reasons why I really like Twig. Twig is a modern template engine written in PHP 5.2 by Fabien Potencier and sponsored by Sensio Labs, the company behind the Symfony framework. Twig offers a secure, concise and full featured API inherited from the famous Django Jinja templates in Python. But what makes Twig so powerful?

Twig is easy to learn!

First of all, Twig offers a really concise and easy to learn syntax based on three tags to remember. The {{ }} tag displays something, the {% %} evaluates an expression like a loop or a condition and the {# #} finally comments code blocks.

{# This is a commented line #}
 
{% if age > 18 %}
    Your age is {{ age }} and you can enter this site.
{% else %}
    Sorry dude but you must be older to enter this site.
{% endif %}

When it comes to output, Twig brings a nice API to render variables. Whatever variable type is (scalar, array or object), Twig tries to determine how to get the value whereas the end user syntax remains identical.

{{ user.firstName }}

The above snippet renders the first name of a user variable. Here, the user variable can be an associative array or an object. If it's an object, Twig tries to call a public property, a method or a getter method.

The Twig learning curve is really weak. In a couple of days, developers and web designers will be able to work on the same code base and speak the same language. At Sensio, both developers and HTML/CSS designers use Twig as the common speak. And believe me, web designers love speaking Twig instead of PHP echos.

Twig is secure!

When it comes to output escaping, PHP definitively sucks as you have to escape variables by yourselves wit functions like htmlspecialchars() or htmlentities(). That makes your code completely verbose and difficult to maintain. What if you forget to escape a dangerous variable? You might endorse a security breach (XSS for example) if this variable value comes from the end user.

Twig brings automatic output escaping by default, so that you don't need to escape variables by hand. Of course, the API is so flexible that you can have access to the raw variable content if necessary and if you are aware of your application security.

{# The variable is auto escaped #}
{{ article.content }}
 
{# The variable is not double escaped by the filter #}
{{ article.content|e }}
 
{# The variable is not escaped #}
{{ article.content|raw }}

Not only variables can be escaped. Indeed, you can escape a whole HTML block or leave it raw if you want.

{% autoescape true %}
<ul>
    <li>Escape this unordered list</li>
</ul>
{% endautoescape %}
 
{% raw %}
<ul>
    <li>Leave this list raw</li>
</ul>
{% endraw %}

As you can see, the API remains concise and templates easy to read and maintain. You are not still convinced? Keep reading this article to discover lots of new modern features.

Twig is full featured!

Compared to other template engine libraries, Twig brings a rich API with modern features. For instance, Twig supports a for loop, an if statement to perform decisions, logical, maths and comparision operators.

{% if name == 'Hugo' %}
    Welcome Hugo!
{% endif %}
 
{% for fruit in ['apple', 'banana', 'strawberry', 'pear'] %}
  * {{ fruit }}
{% else %}
  * No fruit to display...
{% endfor %}

Modern features you said? You kidding! No I don't! Twig has some real cool modern features. Look at the previous for loop and its else clause. That's a killer feature.

One of my favorite advanced tool is template inheritance. Basically, a template can extend another template and there is no limitations with the inheritance hierarchy.

Below is the template code for a base.html.twig layout...

{# base.html.twig #}
 
<html>
    <head>
        <title>{% block title %}Welcome on my website{% endblock %}</title>
    </head>
    <body>
        <h1>Hugo Hamon</h1>
        {% block body %}{% endblock %}
    </body>
</html>

... and the one of a resume.html.twig template that extends the previous one.

{# resume.html.twig #}
 
{% extends "base.html.twig" %}
 
{% block title %}
    Curriculum Vitae - Symfony2 web developer.
{% endblock %}
 
{% block body %}
    Below are listed my skills and education.
 
    <h2>Skills</h2>
 
    <ul>
        <li>PHP 5.3</li>
        <li>MySQL</li>
        <li>Symfony framework</li>
    </ul>
 
    <h2>Education</h2>
 
    {% include 'education.html.twig' %}
 
{% endblock %}

In the above example, the resume.html.twig template extends the base.html.twig. It defines two block contents (title and body) that will fill the two identical blocks in the parent template to reassemble the whole HTML page. Nice isn't it? Imagine that you can make the resume.html.twig inherit from an intermediate template that extends the base.html.twig template.

The resume.html.twig also includes a template fragment called education.html.twig thanks to the include keyword.

Twig also brings a bunch of filters and functions. A filter is a function that modifies a variable value. Filters can be chained thanks to the pipe character, |, to make the code more readable.

{{ '<strong>hello world</strong>'|striptags|upper }}

A function is like a global php function that performs some business logic. One of the most interesting function is the cycle() function that returns a value from an array depending on a counter value.

{% for i in 0..10 %}
    <span class="{{ cycle(['odd', 'even'], i) }}">
        Current number is {{ i }}
    </span>
{% endfor %}

One of the greatest features of Twig are macros. A macro is like a php function that you can define and call from a template or another macro. Basically, a macro performs some small presentation logic like generating a button.

{% macro input(name, value, type, size) %}
    <input type="{{ type|default('text') }}" 
        name="{{ name }}" 
        value="{{ value|e }}" 
        size="{{ size|default(20) }}" />
{% endmacro %}
 
<p>{{ forms.input('username') }}</p>
<p>{{ forms.input('password', none, 'password') }}</p>

Are you convinced now? I hope so. Just have a look to the official documentation of Twig on twig-project.org to discover some other hidden cool features.

Twig is fast... really!

Although Twig has a full featured API, you may probably think that it's slow. It must take lots of time to parse and render such templates. You're wrong! Twig isn't slow at all! Why and how?

Twig is a clever template engine. It compiles templates down to plain PHP classes and stores the raw result in a cached file. That way, Twig templates aren't parsed twice.

In October 2009, Fabien realized a couple of benchmarks to compare Twig to other well-known template engine libraries. At this moment, Twig already announced incredible performances whereas it wasn't entirely finished.

Twig is flexible and extensible!

Still not convinced by the power of Twig? You won't after this argument. Twig is so flexible that it can be extended at will. Changing tags to use brackets instead of braces is as simple as overriding a core class. Adding a new filter, function or test is also a piece of cake. You just need to create a new extension class and implement a couple of mandatory methods.

The example below shows how to register a new truncate filter and a new nl2br() global function.

class Text_Twig_Extension extends Twig_Extension
{
    public function getName()
    {
        return 'text';
    }
 
    public function getFilters()
    {
        return array(
            'truncate' => new \Twig_Filter_Method($this, 'truncate')
        );
    }
 
    public function truncate($text, $max = 30)
    {
        $lastSpace = 0;
 
        if (strlen($text) >= $max)
        {
            $text = substr($text, 0, $max);
            $lastSpace = strrpos($text,' ');
            $text = substr($text, 0, $lastSpace).'...';
        }
 
        return $text;
    }
 
    public function getFunctions()
    {
        return array(
            'nl2br' => \Twig_Function_Method($this, 'nl2br', array('is_safe' => array('html'))) 
        );
    }
 
    public function nl2br($text)
    {
        return nl2br($text);
    }
}

They are both then used as below from a Twig template.

{% set text = 'A super long string that I want to truncate up to 20 characters...' %}
{{ text|truncate(20) }}
 
{% set text = "A text with multiple lines.\n\nThey must be changed to <br/>" %}
{{ nl2br(text) }}

That makes Twig so powerful and professional against the other template engines. You can add your own features set to Twig and customize its API as you wish. This is possible because Twig runs a powerful Lexer parser. Last but not least, Twig has an incredible error management and syntax analyser. Debugging a template hasn't be so easy with Twig.

Twig is "enterprise ready"!

The main goal of a template engine is to separate the business logic from the view and make websites more maintainable and evolutive. Template engines also facilitate team work by providing a common language between developers and web designers.

With its simple, concise and easy to learn syntax, Twig helps developers and web designers to be more productive. They conceive clean templates and write them fast. At Sensio, we already took benefits by leveraging the power of Twig. Web designers learnt Twig in a couple of days and now use it daily.

Twig is "enterprise ready". It's fully unit tested and well documented. The new Symfony framework has already integrated Twig as its default presentation layer and encourages developers to switch from PHP to Twig.

As you can see, Twig really makes my life easier and better as a webdeveloper and I strongly encourage you to give it a try. You will love it and adopt it for your future developments. I bet!