Functions

template_from_string

The template_from_string function loads a template from a string:

{{ include(template_from_string("Hello {{ name }}")) }}
{{ include(template_from_string(page.template)) }}

Arguments

• template: The template

source

The source function returns the content of a template without rendering it:

{{ source('template.html') }}
{{ source(some_var) }}

When you set the ignore_missing flag, Twig will return an empty string if the template does not exist:

{{ source('template.html', ignore_missing = true) }}

The function uses the same template loaders as the ones used to include templates. So, if you are using the filesystem loader, the templates are looked for in the paths defined by it.

Arguments

• name: The name of the template to read
• ignore_missing: Whether to ignore missing templates or not

range

Returns a list containing an arithmetic progression of integers:

{% for i in range(0, 3) %}
    {{ i }},
{% endfor %}

{# outputs 0, 1, 2, 3, #}

When step is given (as the third parameter), it specifies the increment (or decrement):

{% for i in range(0, 6, 2) %}
    {{ i }},
{% endfor %}

{# outputs 0, 2, 4, 6, #}

The Twig built-in .. operator is just syntactic sugar for the range function (with a step of 1):

{% for i in 0..3 %}
    {{ i }},
{% endfor %}

Arguments

• low: The first value of the sequence.
• high: The highest possible value of the sequence.
• step: The increment between elements of the sequence.

random

The random function returns a random value depending on the supplied parameter type:

• a random item from a sequence;
• a random character from a string;
• a random integer between 0 and the integer parameter (inclusive).

{{ random(['apple', 'orange', 'citrus']) }} {# example output: orange #}
{{ random('ABC') }}                         {# example output: C #}
{{ random() }}                              {# example output: 15386094 (works as the native PHP mt_rand function) #}
{{ random(5) }}                             {# example output: 3 #}

Arguments

• values: The values

parent

When a template uses inheritance, it's possible to render the contents of the parent block when overriding a block by using the parent function:

{% extends "base.html" %}

{% block sidebar %}
    <h3>Table Of Contents</h3>
    ...
    {{ parent() }}
{% endblock %}

The parent() call will return the content of the sidebar block as defined in the base.html template.

min

min returns the lowest value of a sequence or a set of values:

{{ min(1, 3, 2) }}
{{ min([1, 3, 2]) }}

When called with a mapping, min ignores keys and only compares values:

{{ min({2: "e", 3: "a", 1: "b", 5: "d", 4: "c"}) }}
{# returns "a" #}

max

max returns the biggest value of a sequence or a set of values:

{{ max(1, 3, 2) }}
{{ max([1, 3, 2]) }}

When called with a mapping, max ignores keys and only compares values:

{{ max({2: "e", 1: "a", 3: "b", 5: "d", 4: "c"}) }}
{# returns "e" #}

include

The include function returns the rendered content of a template:

{{ include('template.html') }}
{{ include(some_var) }}

Included templates have access to the variables of the active context.

If you are using the filesystem loader, the templates are looked for in the paths defined by it.

The context is passed by default to the template but you can also pass additional variables:

{# template.html will have access to the variables from the current context and the additional ones provided #}
{{ include('template.html', {foo: 'bar'}) }}

You can disable access to the context by setting with_context to false:

{# only the foo variable will be accessible #}
{{ include('template.html', {foo: 'bar'}, with_context = false) }}

{# no variables will be accessible #}
{{ include('template.html', with_context = false) }}

When you set the ignore_missing flag, Twig will return an empty string if the template does not exist:

{{ include('sidebar.html', ignore_missing = true) }}

You can also provide a list of templates that are checked for existence before inclusion. The first template that exists will be rendered:

{{ include(['page_detailed.html', 'page.html']) }}

Arguments

• template: The template to render
• variables: The variables to pass to the template
• with_context: Whether to pass the current context variables or not
• ignore_missing: Whether to ignore missing templates or not
• sandboxed: Whether to sandbox the template or not

date

Converts an argument to a date to allow date comparison:

{% if date(user.created_at) < date('-2days') %}
    {# do something #}
{% endif %}

The argument must be in one of PHP’s supported date and time formats.

You can pass a timezone as the second argument:

{% if date(user.created_at) < date('-2days', 'Europe/Paris') %}
    {# do something #}
{% endif %}

If no argument is passed, the function returns the current date:

{% if date(user.created_at) < date() %}
    {# always! #}
{% endif %}

Arguments

• date: The date
• timezone: The timezone

cycle

The cycle function cycles on an array of values:

{% set start_year = date() | date('Y') %}
{% set end_year = start_year + 5 %}

{% for year in start_year..end_year %}
    {{ cycle(['odd', 'even'], loop.index0) }}
{% endfor %}

The array can contain any number of values:

{% set fruits = ['apple', 'orange', 'citrus'] %}

{% for i in 0..10 %}
    {{ cycle(fruits, i) }}
{% endfor %}

Arguments

• position: The cycle position

constant

constant returns the constant value for a given string:

{{ some_date|date(constant('DATE_W3C')) }}
{{ constant('Namespace\\Classname::CONSTANT_NAME') }}

You can read constants from object instances as well:

{{ constant('RSS', date) }}

block

When a template uses inheritance and if you want to print a block multiple times, use the block function:

<title>{% block title %}{% endblock %}</title>

<h1>{{ block('title') }}</h1>

{% block body %}{% endblock %}

attribute

The attribute function can be used to access a "dynamic" attribute of a variable:

{{ attribute(object, method) }}
{{ attribute(object, method, arguments) }}
{{ attribute(array, item) }}

In addition, the defined test can check for the existence of a dynamic attribute:

{{ attribute(object, method) is defined ? 'Method exists' : 'Method does not exist' }}