Twig常用語法

原創 锅巴胸 2018-09-05 01:01

原鏈接：https://twig.symfony.com/doc/2.x/templates.html

概要

twig 的模板就是普通的文本文件，也不需要特別的擴展名，.html .htm .twig 都可以。

模板內的 變量 和 表達式 會在運行的時候被解析替換，標籤（tags）會來控制模板的邏輯

下面是個最小型的模板，用來說明一些基礎的東西

[html] view plaincopyprint?

  1. <!DOCTYPE html>  
  2. <html>  
  3.     <head>  
  4.         <title>My Webpage</title>  
  5.     </head>  
  6.     <body>  
  7.         <ul id="navigation">  
  8.         {% for item in navigation %}  
  9.             <li><a href="{{ item.href }}">{{ item.caption }}</a></li>  
  10.         {% endfor %}  
  11.         </ul>  
  12.   
  13.         <h1>My Webpage</h1>  
  14.         {{ a_variable }}  
  15.     </body>  
  16. </html>  


裏面包含兩種符號 {% ... %} 和 {{ ... }} 第一種用來控制的比如for循環什麼的，第二個是用來輸出變量和表達式的

 

ide 支持

很多ide 都對twig進行高亮支持。大夥自己找需要的吧。

變量

程序會傳遞給模板若干變量，你需要在模板裏輸出他們。例如輸出 $hello

[html] view plaincopyprint?

  1. {{ hello }}  

如果傳遞給模板的是對象或者數組，你可以使用點 . 來輸出對象的屬性或者方法，或者數組的成員。或者你可以使用下標的方式。

[html] view plaincopyprint?

  1. {{ foo.bar }}  
  2. {{ foo['bar'] }}  


如果你訪問的值不存在就會返回null。TWIG有一整套的流程來確認值是否存在。

 

for.bar會進行以下操作

。。。如果 foo是個數組，就嘗試返回bar成員，如果不存在的話，往下繼續

。。。如果foo是個對象，會嘗試返回bar屬性，如果不存在的話，往下繼續

。。。會嘗試運行bar方法，如果不存在的話，往下繼續

。。。會嘗試運行getBar方法，如果不存在的話，往下繼續

。。。會嘗試運行isBar方法，如果不存在的話，返回null

 

for['bar'] 就簡單很多了 for必須是個數組，嘗試返回bar成員，如果不就返回null

全局變量

TWIG定義了有一些全局變量

  • _self  這個參看macro標籤
  • _context 這個就是當前的環境
  • _charset: 當前的字符編碼

 

變量賦值

具體參見set標籤

[html] view plaincopyprint?

  1. {% set foo = 'foo' %}  
  2. {% set foo = [1, 2] %}  
  3. {% set foo = {'foo': 'bar'} %}  

 

過濾器 Firters

變量可以被過濾器修飾。過濾器和變量用（|）分割開。過濾器也是可以有參數的。過濾器也可以被多重使用。

下面這例子就使用了兩個過濾器。

[html] view plaincopyprint?

  1. {{ name|striptags|title }}  

striptas表示去除html標籤，title表示每個單詞的首字母大寫。更多過濾器參見我博客

 

過濾器也可以用在代碼塊中，參見 filter標籤

[html] view plaincopyprint?

  1. {% filter upper %}  
  2.   This text becomes uppercase  
  3. {% endfilter %}  

 

函數 Function

這個沒什麼好說的，會寫程序的都知道，TWIG內置了一些函數，參考我的博客

舉個例子 返回一個0到3的數組，就使用 range函數

[html] view plaincopyprint?

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

 

流程控制

支持for循環 和 if/elseif/else結構。直接看例子吧，沒什麼好說的。

[html] view plaincopyprint?

  1. <h1>Members</h1>  
  2. <ul>  
  3.     {% for user in users %}  
  4.         <li>{{ user.username|e }}</li>  
  5.     {% endfor %}  
  6. </ul>  

[html] view plaincopyprint?

  1. {% if users|length > 0 %}  
  2.     <ul>  
  3.         {% for user in users %}  
  4.             <li>{{ user.username|e }}</li>  
  5.         {% endfor %}  
  6.     </ul>  
  7. {% endif %}  

 

註釋

{# ... #} 包圍的內容會被註釋掉，可以是單行 也可以是多行。

 

載入其他模板

詳見include標籤（我博客內已經翻譯好哦），會返回經過渲染的內容到當前的模板裏

[html] view plaincopyprint?

  1. {% include 'sidebar.html' %}  

當前模板的變量也會傳遞到 被include的模板裏，在那裏面可以直接訪問你這個模板的變量。

比如

[html] view plaincopyprint?

  1. {% for box in boxes %}  
  2.     {% include "render_box.html" %}  
  3. {% endfor %}  

在 render_box.html 是可以訪問 box變量的
加入其他參數可以使被載入的模板只訪問部分變量，或者完全訪問不到。參考手冊

 

模板繼承

TWIG中最有用到功能就是模板繼承，他允許你建立一個“骨骼模板”，然後你用不同到block來覆蓋父模板中任意到部分。而且使用起來非常到簡單。

我們先定義一個基本骨骼頁base.html 他包含許多block塊，這些都可以被子模板覆蓋。

[html] view plaincopyprint?

  1. <!DOCTYPE html>  
  2. <html>  
  3.     <head>  
  4.         {% block head %}  
  5.             <link rel="stylesheet" href="style.css" />  
  6.             <title>{% block title %}{% endblock %} - My Webpage</title>  
  7.         {% endblock %}  
  8.     </head>  
  9.     <body>  
  10.         <div id="content">{% block content %}{% endblock %}</div>  
  11.         <div id="footer">  
  12.             {% block footer %}  
  13.                 © Copyright 2011 by <a href="http://domain.invalid/">you</a>.  
  14.             {% endblock %}  
  15.         </div>  
  16.     </body>  
  17. </html>  

我們定義了4個block塊，分別是 block head, block title, block content, block footer 

注意

1、block是可以嵌套的。

2、block可以設置默認值（中間包圍的內容），如果子模板裏沒有覆蓋，那就直接顯示默認值。比如block footer ，大部分頁面你不需要修改（省力），但你需要到時候仍可以方便到修改（靈活）

下面我看下 子模板應該怎麼定義。

[html] view plaincopyprint?

  1. {% extends "base.html" %}  
  2.   
  3. {% block title %}Index{% endblock %}  
  4. {% block head %}  
  5.     {{ parent() }}  
  6.     <style type="text/css">  
  7.         .important { color: #336699; }  
  8.     </style>  
  9. {% endblock %}  
  10. {% block content %}  
  11.     <h1>Index</h1>  
  12.     <p class="important">  
  13.         Welcome on my awesome homepage.  
  14.     </p>  
  15. {% endblock %}  

注意 {% extends "base.html" %} 必須是第一個標籤。其中 block footer就沒有定義，所以顯示父模板中設置的默認值

如果你需要增加一個block的內容，而不是全覆蓋，你可以使用 parent函數

[html] view plaincopyprint?

  1. {% block sidebar %}  
  2.     <h3>Table Of Contents</h3>  
  3.     ...  
  4.     {{ parent() }}  
  5. {% endblock %}  


extends標籤只能有一個，所以你只能有一個父模板，但有種變通到方法來達到重用多個模板到目的，具體參見手冊的use標籤

 

HTML轉義

主要是幫助轉義 尖括號等  <, >,  &,  "  可以有兩種辦法。一種是用標籤，另一種是使用過濾器。其實TWIG內部就是調用 php 的htmlspecialchars 函數

[html] view plaincopyprint?

  1. {{ user.username|e }}  
  2. {{ user.username|e('js') }}  
  3.   
  4. {% autoescape true %}  
  5.     Everything will be automatically escaped in this block  
  6. {% endautoescape %}  


因爲{{是TWIG的操作符，如果你需要輸出兩個花括號，最簡單到辦法就是

[html] view plaincopyprint?

  1. {{ '{{' }}  


還可以使用 raw 標籤和raw 過濾器，詳細參考手冊

[html] view plaincopyprint?

  1. {% raw %}  
  2.     <ul>  
  3.     {% for item in seq %}  
  4.         <li>{{ item }}</li>  
  5.     {% endfor %}  
  6.     </ul>  
  7. {% endraw %}  

 

macros宏

宏有點類似於函數，常用於輸出一些html標籤。

這裏有個簡單示例，定義了一個輸出input標籤的宏。

[html] view plaincopyprint?

  1. {% macro input(name, value, type, size) %}  
  2.     <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />  
  3. {% endmacro %}  

宏參數是沒有默認值的，但你可以通過default過濾器來實現。

一般來說宏會定義在其他到頁面，然後通過import標籤來導入，

[html] view plaincopyprint?

  1. {% import "forms.html" as forms %}  
  2.   
  3. <p>{{ forms.input('username') }}</p>  

你也可以只導入一個文件中部分宏，你還可以再重命名。

[html] view plaincopyprint?

  1. {% from 'forms.html' import input as input_field, textarea %}  
  2.   
  3. <dl>  
  4.     <dt>Username</dt>  
  5.     <dd>{{ input_field('username') }}</dd>  
  6.     <dt>Password</dt>  
  7.     <dd>{{ input_field('password', type='password') }}</dd>  
  8. </dl>  
  9. <p>{{ textarea('comment') }}</p>  

上面的代碼表示 從forms.html中導入了 input 和 textarea宏，並給input重命名爲input_field。

表達式

TWIG允許你在任何地方使用表達式，他的規則和PHP幾乎一模一樣，就算你不會PHP 仍然會覺得很簡單。

最簡單的有 

字符串：“hello world”  或者 'hello world'  

數字：42 或者 42.33

數組：['a','b','c']

哈希：{'a':'av', 'b':'bv'} 其中keys 可以不要引號 也可以是數字 還可以是一個表達式，比如{a:'av', b:'bv'}  {1:'1v', 2:'2v'}  {1+2:'12v'}

邏輯： true 或者 false

最後還有null

你可以嵌套定義

[html] view plaincopyprint?

  1. {% set foo = [1, {"foo": "bar"}] %}  

運算符

包括數字運算+ - * /  %(求餘數)  //(整除) **(乘方)

[html] view plaincopyprint?

  1. <p>{{ 2 * 3 }}=6  
  2. <p>{{ 2 * 3 }}=8  

邏輯運算 and or  not

比較運算 > < >= <= == !=

包含運算 in 以下的代碼會返回 true

[html] view plaincopyprint?

  1. {{ 1 in [1, 2, 3] }}  
  2. {{ 'cd' in 'abcde' }}  

測試運算 is 這個不用多說 直接看代碼

[html] view plaincopyprint?

  1. {{ name is odd }}  
  2. {% if loop.index is divisibleby(3) %}  
  3. {% if loop.index is not divisibleby(3) %}  
  4. {# is equivalent to #}  
  5. {% if not (loop.index is divisibleby(3)) %}  

其他操作符

.. 建立一個指定開始到結束的數組，他是range函數的縮寫，具體參看手冊

[html] view plaincopyprint?

  1. <pre name="code" class="html">{% for i in 0..3 %}  
  2.     {{ i }},  
  3. {% endfor %}</pre>  
  4. <pre></pre>  

| 使用一個過濾器

[html] view plaincopyprint?

  1. {# output will be HELLO #}  
  2. {{ "hello"|upper }}  

~ 強制字符串連接

[html] view plaincopyprint?

  1. {{ "Hello " ~ name ~ "!" }}  

?:  三元操作符

[html] view plaincopyprint?

  1. {{ foo ? 'yes' : 'no' }}  

. [] 得到一個對象的屬性，比如以下是相等的。

[html] view plaincopyprint?

  1. {{ foo.bar }}  
  2. {{ foo['bar'] }}  


你還可以在一個字符串內部插入一個表達式，通常這個表達式是變量。 格式是 #{表達式}

[html] view plaincopyprint?

  1. {{ "foo #{bar} baz" }}  
  2. {{ "foo #{1 + 2} baz" }}  

 

空白控制

和 php一樣，在TWIG模板標籤之後的第一個換行符會被自動刪掉，其餘的空白（包括 空格 tab 換行等）都會被原樣輸出。

使用spaceless標籤就可以刪除這些HTML標籤之間的空白

[html] view plaincopyprint?

  1. {% spaceless %}  
  2.     <div>  
  3.         <strong>foo</strong>  
  4.     </div>  
  5. {% endspaceless %}  
  6.   
  7. {# output will be <div><strong>foo</strong></div> #}  


使用-操作符，可以很方便的刪除TWIG標籤之前或之後與html標籤之間的空白。

[html] view plaincopyprint?

  1. {% set value = 'no spaces' %}  
  2. {#- No leading/trailing whitespace -#}  
  3. {%- if true -%}  
  4.     {{- value -}}  
  5. {%- endif -%}  
  6.   
  7. {# output 'no spaces' #}  

[html] view plaincopyprint?

  1. {% set value = 'no spaces' %}  
  2. <li>    {{- value }}    </li>  
  3.   
  4. {# outputs '<li>no spaces    </li>' #}  

 

結束，如果你堅持看到這裏，恭喜自己吧，你又多掌握了一些知識，恭喜恭喜

原頁：

Twig for Template Designers

This document describes the syntax and semantics of the template engine and will be most useful as reference to those creating Twig templates.

Synopsis

A template is simply a text file. It can generate any text-based format (HTML, XML, CSV, LaTeX, etc.). It doesn't have a specific extension, .html or .xml are just fine.

A template contains variables or expressions, which get replaced with values when the template is evaluated, and tags, which control the logic of the template.

Below is a minimal template that illustrates a few basics. We will cover further details later on:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
 
<!DOCTYPE html>
<html>
    <head>
        <title>My Webpage</title>
    </head>
    <body>
        <ul id="navigation">
        {% for item in navigation %}
            <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
        {% endfor %}
        </ul>

        <h1>My Webpage</h1>
        {{ a_variable }}
    </body>
</html>

There are two kinds of delimiters: {% ... %} and {{ ... }}. The first one is used to execute statements such as for-loops, the latter prints the result of an expression to the template.

IDEs Integration

Many IDEs support syntax highlighting and auto-completion for Twig:

Also, TwigFiddle is an online service that allows you to execute Twig templates from a browser; it supports all versions of Twig.

Variables

The application passes variables to the templates for manipulation in the template. Variables may have attributes or elements you can access, too. The visual representation of a variable depends heavily on the application providing it.

You can use a dot (.) to access attributes of a variable (methods or properties of a PHP object, or items of a PHP array), or the so-called "subscript" syntax ([]):

1
2
 
{{ foo.bar }}
{{ foo['bar'] }}

When the attribute contains special characters (like - that would be interpreted as the minus operator), use the attribute function instead to access the variable attribute:

1
2
 
{# equivalent to the non-working foo.data-foo #}
{{ attribute(foo, 'data-foo') }}

It's important to know that the curly braces are not part of the variable but the print statement. When accessing variables inside tags, don't put the braces around them.

If a variable or attribute does not exist, you will receive a null value when the strict_variables option is set to false; alternatively, if strict_variables is set, Twig will throw an error (see environment options).

Implementation

For convenience's sake foo.bar does the following things on the PHP layer:

  • check if foo is an array and bar a valid element;
  • if not, and if foo is an object, check that bar is a valid property;
  • if not, and if foo is an object, check that bar is a valid method (even if bar is the constructor - use __construct() instead);
  • if not, and if foo is an object, check that getBar is a valid method;
  • if not, and if foo is an object, check that isBar is a valid method;
  • if not, and if foo is an object, check that hasBar is a valid method;
  • if not, return a null value.

foo['bar'] on the other hand only works with PHP arrays:

  • check if foo is an array and bar a valid element;
  • if not, return a null value.

If you want to access a dynamic attribute of a variable, use the attribute function instead.

Global Variables

The following variables are always available in templates:

  • _self: references the current template name;
  • _context: references the current context;
  • _charset: references the current charset.

Setting Variables

You can assign values to variables inside code blocks. Assignments use the set tag:

1
2
3
 
{% set foo = 'foo' %}
{% set foo = [1, 2] %}
{% set foo = {'foo': 'bar'} %}

Filters

Variables can be modified by filters. Filters are separated from the variable by a pipe symbol (|) and may have optional arguments in parentheses. Multiple filters can be chained. The output of one filter is applied to the next.

The following example removes all HTML tags from the name and title-cases it:

1
 
{{ name|striptags|title }}

Filters that accept arguments have parentheses around the arguments. This example will join a list by commas:

1
 
{{ list|join(', ') }}

To apply a filter on a section of code, wrap it in the filter tag:

1
2
3
 
{% filter upper %}
    This text becomes uppercase
{% endfilter %}

Go to the filters page to learn more about built-in filters.

Functions

Functions can be called to generate content. Functions are called by their name followed by parentheses (()) and may have arguments.

For instance, the range function returns a list containing an arithmetic progression of integers:

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

Go to the functions page to learn more about the built-in functions.

Named Arguments

1
2
3
 
{% for i in range(low=1, high=10, step=2) %}
    {{ i }},
{% endfor %}

Using named arguments makes your templates more explicit about the meaning of the values you pass as arguments:

1
2
3
4
5
 
{{ data|convert_encoding('UTF-8', 'iso-2022-jp') }}

{# versus #}

{{ data|convert_encoding(from='iso-2022-jp', to='UTF-8') }}

Named arguments also allow you to skip some arguments for which you don't want to change the default value:

1
2
3
4
5
 
{# the first argument is the date format, which defaults to the global date format if null is passed #}
{{ "now"|date(null, "Europe/Paris") }}

{# or skip the format value by using a named argument for the time zone #}
{{ "now"|date(timezone="Europe/Paris") }}

You can also use both positional and named arguments in one call, in which case positional arguments must always come before named arguments:

1
 
{{ "now"|date('d/m/Y H:i', timezone="Europe/Paris") }}

Each function and filter documentation page has a section where the names of all arguments are listed when supported.

Control Structure

A control structure refers to all those things that control the flow of a program - conditionals (i.e. if/elseif/else), for-loops, as well as things like blocks. Control structures appear inside {% ... %} blocks.

For example, to display a list of users provided in a variable called users, use the for tag:

1
2
3
4
5
6
 
<h1>Members</h1>
<ul>
    {% for user in users %}
        <li>{{ user.username|e }}</li>
    {% endfor %}
</ul>

The if tag can be used to test an expression:

1
2
3
4
5
6
7
 
{% if users|length > 0 %}
    <ul>
        {% for user in users %}
            <li>{{ user.username|e }}</li>
        {% endfor %}
    </ul>
{% endif %}

Go to the tags page to learn more about the built-in tags.

Comments

To comment-out part of a line in a template, use the comment syntax {# ... #}. This is useful for debugging or to add information for other template designers or yourself:

1
2
3
4
5
 
{# note: disabled template because we no longer use this
    {% for user in users %}
        ...
    {% endfor %}
#}

Including other Templates

The include function is useful to include a template and return the rendered content of that template into the current one:

1
 
{{ include('sidebar.html') }}

By default, included templates have access to the same context as the template which includes them. This means that any variable defined in the main template will be available in the included template too:

1
2
3
 
{% for box in boxes %}
    {{ include('render_box.html') }}
{% endfor %}

The included template render_box.html is able to access the box variable.

The name of the template depends on the template loader. For instance, the Twig_Loader_Filesystem allows you to access other templates by giving the filename. You can access templates in subdirectories with a slash:

1
 
{{ include('sections/articles/sidebar.html') }}

This behavior depends on the application embedding Twig.

Template Inheritance

The most powerful part of Twig is template inheritance. Template inheritance allows you to build a base "skeleton" template that contains all the common elements of your site and defines blocks that child templates can override.

Sounds complicated but it is very basic. It's easier to understand it by starting with an example.

Let's define a base template, base.html, which defines a simple HTML skeleton document that you might use for a simple two-column page:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
 
<!DOCTYPE html>
<html>
    <head>
        {% block head %}
            <link rel="stylesheet" href="style.css" />
            <title>{% block title %}{% endblock %} - My Webpage</title>
        {% endblock %}
    </head>
    <body>
        <div id="content">{% block content %}{% endblock %}</div>
        <div id="footer">
            {% block footer %}
                &copy; Copyright 2011 by <a href="http://domain.invalid/">you</a>.
            {% endblock %}
        </div>
    </body>
</html>

In this example, the block tags define four blocks that child templates can fill in. All the block tag does is to tell the template engine that a child template may override those portions of the template.

A child template might look like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
 
{% extends "base.html" %}

{% block title %}Index{% endblock %}
{% block head %}
    {{ parent() }}
    <style type="text/css">
        .important { color: #336699; }
    </style>
{% endblock %}
{% block content %}
    <h1>Index</h1>
    <p class="important">
        Welcome to my awesome homepage.
    </p>
{% endblock %}

The extends tag is the key here. It tells the template engine that this template "extends" another template. When the template system evaluates this template, first it locates the parent. The extends tag should be the first tag in the template.

Note that since the child template doesn't define the footer block, the value from the parent template is used instead.

It's possible to render the contents of the parent block by using the parent function. This gives back the results of the parent block:

1
2
3
4
5
 
{% block sidebar %}
    <h3>Table Of Contents</h3>
    ...
    {{ parent() }}
{% endblock %}

The documentation page for the extends tag describes more advanced features like block nesting, scope, dynamic inheritance, and conditional inheritance.

Twig also supports multiple inheritance with the so called horizontal reuse with the help of the use tag. This is an advanced feature hardly ever needed in regular templates.

HTML Escaping

When generating HTML from templates, there's always a risk that a variable will include characters that affect the resulting HTML. There are two approaches: manually escaping each variable or automatically escaping everything by default.

Twig supports both, automatic escaping is enabled by default.

The automatic escaping strategy can be configured via the autoescape option and defaults to html.

Working with Manual Escaping

If manual escaping is enabled, it is your responsibility to escape variables if needed. What to escape? Any variable you don't trust.

Escaping works by piping the variable through the escape or e filter:

1
 
{{ user.username|e }}

By default, the escape filter uses the html strategy, but depending on the escaping context, you might want to explicitly use any other available strategies:

1
2
3
4
 
{{ user.username|e('js') }}
{{ user.username|e('css') }}
{{ user.username|e('url') }}
{{ user.username|e('html_attr') }}

Working with Automatic Escaping

Whether automatic escaping is enabled or not, you can mark a section of a template to be escaped or not by using the autoescape tag:

1
2
3
 
{% autoescape %}
    Everything will be automatically escaped in this block (using the HTML strategy)
{% endautoescape %}

By default, auto-escaping uses the html escaping strategy. If you output variables in other contexts, you need to explicitly escape them with the appropriate escaping strategy:

1
2
3
 
{% autoescape 'js' %}
    Everything will be automatically escaped in this block (using the JS strategy)
{% endautoescape %}

Escaping

It is sometimes desirable or even necessary to have Twig ignore parts it would otherwise handle as variables or blocks. For example if the default syntax is used and you want to use {{ as raw string in the template and not start a variable you have to use a trick.

The easiest way is to output the variable delimiter ({{) by using a variable expression:

1
 
{{ '{{' }}

For bigger sections it makes sense to mark a block verbatim.

Macros

Macros are comparable with functions in regular programming languages. They are useful to reuse often used HTML fragments to not repeat yourself.

A macro is defined via the macro tag. Here is a small example (subsequently called forms.html) of a macro that renders a form element:

1
2
3
 
{% macro input(name, value, type, size) %}
    <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
{% endmacro %}

Macros can be defined in any template, and need to be "imported" via the import tag before being used:

1
2
3
 
{% import "forms.html" as forms %}

<p>{{ forms.input('username') }}</p>

Alternatively, you can import individual macro names from a template into the current namespace via the from tag and optionally alias them:

1
2
3
4
5
6
7
8
 
{% from 'forms.html' import input as input_field %}

<dl>
    <dt>Username</dt>
    <dd>{{ input_field('username') }}</dd>
    <dt>Password</dt>
    <dd>{{ input_field('password', '', 'password') }}</dd>
</dl>

A default value can also be defined for macro arguments when not provided in a macro call:

1
2
3
 
{% macro input(name, value = "", type = "text", size = 20) %}
    <input type="{{ type }}" name="{{ name }}" value="{{ value|e }}" size="{{ size }}" />
{% endmacro %}

If extra positional arguments are passed to a macro call, they end up in the special varargs variable as a list of values.

Expressions

Twig allows expressions everywhere. These work very similar to regular PHP and even if you're not working with PHP you should feel comfortable with it.

The operator precedence is as follows, with the lowest-precedence operators listed first: b-and, b-xor, b-or, or, and, ==, !=, <, >, >=, <=, in, matches, starts with, ends with, .., +, -, ~, *, /, //, %, is, **, |, [], and .:

1
2
3
4
5
6
7
 
{% set greeting = 'Hello ' %}
{% set name = 'Fabien' %}

{{ greeting ~ name|lower }}   {# Hello fabien #}

{# use parenthesis to change precedence #}
{{ (greeting ~ name)|lower }} {# hello fabien #}

Literals

The simplest form of expressions are literals. Literals are representations for PHP types such as strings, numbers, and arrays. The following literals exist:

  • "Hello World": Everything between two double or single quotes is a string. They are useful whenever you need a string in the template (for example as arguments to function calls, filters or just to extend or include a template). A string can contain a delimiter if it is preceded by a backslash (\) -- like in 'It\'s good'. If the string contains a backslash (e.g. 'c:\Program Files') escape it by doubling it (e.g. 'c:\\Program Files').

  • 42 / 42.23: Integers and floating point numbers are created by just writing the number down. If a dot is present the number is a float, otherwise an integer.

  • ["foo", "bar"]: Arrays are defined by a sequence of expressions separated by a comma (,) and wrapped with squared brackets ([]).

  • {"foo": "bar"}: Hashes are defined by a list of keys and values separated by a comma (,) and wrapped with curly braces ({}):

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    		 
    {# keys as string #}
{ 'foo': 'foo', 'bar': 'bar' }

{# keys as names (equivalent to the previous hash) #}
{ foo: 'foo', bar: 'bar' }

{# keys as integer #}
{ 2: 'foo', 4: 'bar' }

{# keys as expressions (the expression must be enclosed into parentheses) #}
{% set foo = 'foo' %}
{ (foo): 'foo', (1 + 1): 'bar', (foo ~ 'b'): 'baz' }

  • true / false: true represents the true value, false represents the false value.

  • null: null represents no specific value. This is the value returned when a variable does not exist. none is an alias for null.

Arrays and hashes can be nested:

1
 
{% set foo = [1, {"foo": "bar"}] %}

Using double-quoted or single-quoted strings has no impact on performance but string interpolation is only supported in double-quoted strings.

Math

Twig allows you to calculate with values. This is rarely useful in templates but exists for completeness' sake. The following operators are supported:

  • +: Adds two objects together (the operands are casted to numbers). {{ 1 + 1 }} is 2.
  • -: Subtracts the second number from the first one. {{ 3 - 2 }} is 1.
  • /: Divides two numbers. The returned value will be a floating point number. {{ 1 / 2 }} is {{ 0.5 }}.
  • %: Calculates the remainder of an integer division. {{ 11 % 7 }} is 4.
  • //: Divides two numbers and returns the floored integer result. {{ 20 // 7 }} is 2, {{ -20 // 7 }} is -3 (this is just syntactic sugar for the round filter).
  • *: Multiplies the left operand with the right one. {{ 2 * 2 }} would return 4.
  • **: Raises the left operand to the power of the right operand. {{ 2 ** 3 }} would return 8.

Logic

You can combine multiple expressions with the following operators:

  • and: Returns true if the left and the right operands are both true.
  • or: Returns true if the left or the right operand is true.
  • not: Negates a statement.
  • (expr): Groups an expression.

Twig also support bitwise operators (b-and, b-xor, and b-or).

Operators are case sensitive.

Comparisons

The following comparison operators are supported in any expression: ==, !=, <, >, >=, and <=.

You can also check if a string starts with or ends with another string:

1
2
3
4
5
 
{% if 'Fabien' starts with 'F' %}
{% endif %}

{% if 'Fabien' ends with 'n' %}
{% endif %}

For complex string comparisons, the matches operator allows you to use regular expressions:

1
2
 
{% if phone matches '/^[\\d\\.]+$/' %}
{% endif %}

Containment Operator

The in operator performs containment test.

It returns true if the left operand is contained in the right:

1
2
3
4
5
 
{# returns true #}

{{ 1 in [1, 2, 3] }}

{{ 'cd' in 'abcde' }}

You can use this filter to perform a containment test on strings, arrays, or objects implementing the Traversable interface.

To perform a negative test, use the not in operator:

1
2
3
4
 
{% if 1 not in [1, 2, 3] %}

{# is equivalent to #}
{% if not (1 in [1, 2, 3]) %}

Test Operator

The is operator performs tests. Tests can be used to test a variable against a common expression. The right operand is name of the test:

1
2
3
 
{# find out if a variable is odd #}

{{ name is odd }}

Tests can accept arguments too:

1
 
{% if post.status is constant('Post::PUBLISHED') %}

Tests can be negated by using the is not operator:

1
2
3
4
 
{% if post.status is not constant('Post::PUBLISHED') %}

{# is equivalent to #}
{% if not (post.status is constant('Post::PUBLISHED')) %}

Go to the tests page to learn more about the built-in tests.

Other Operators

The following operators don't fit into any of the other categories:

  • |: Applies a filter.

  • ..: Creates a sequence based on the operand before and after the operator (this is just syntactic sugar for the range function):

    1
2
3
4
    		 
    {{ 1..5 }}

{# equivalent to #}
{{ range(1, 5) }}

    Note that you must use parentheses when combining it with the filter operator due to the operator precedence rules:

    1
    		 
    (1..5)|join(', ')

  • ~: Converts all operands into strings and concatenates them. {{ "Hello " ~ name ~ "!" }} would return (assuming name is 'John') Hello John!.

  • ., []: Gets an attribute of an object.

  • ?:: The ternary operator:

    1
2
3
    		 
    {{ foo ? 'yes' : 'no' }}
{{ foo ?: 'no' }} is the same as {{ foo ? foo : 'no' }}
{{ foo ? 'yes' }} is the same as {{ foo ? 'yes' : '' }}

  • ??: The null-coalescing operator:

    1
2
    		 
    {# returns the value of foo if it is defined and not null, 'no' otherwise #}
{{ foo ?? 'no' }}

String Interpolation

String interpolation (#{expression}) allows any valid expression to appear within a double-quoted string. The result of evaluating that expression is inserted into the string:

1
2
 
{{ "foo #{bar} baz" }}
{{ "foo #{1 + 2} baz" }}

Whitespace Control

The first newline after a template tag is removed automatically (like in PHP.) Whitespace is not further modified by the template engine, so each whitespace (spaces, tabs, newlines etc.) is returned unchanged.

Use the spaceless tag to remove whitespace between HTML tags:

1
2
3
4
5
6
7
 
{% spaceless %}
    <div>
        <strong>foo bar</strong>
    </div>
{% endspaceless %}

{# output will be <div><strong>foo bar</strong></div> #}

In addition to the spaceless tag you can also control whitespace on a per tag level. By using the whitespace control modifier on your tags, you can trim leading and or trailing whitespace:

1
2
3
4
5
6
7
 
{% set value = 'no spaces' %}
{#- No leading/trailing whitespace -#}
{%- if true -%}
    {{- value -}}
{%- endif -%}

{# output 'no spaces' #}

The above sample shows the default whitespace control modifier, and how you can use it to remove whitespace around tags. Trimming space will consume all whitespace for that side of the tag. It is possible to use whitespace trimming on one side of a tag:

1
2
3
4
 
{% set value = 'no spaces' %}
<li>    {{- value }}    </li>

{# outputs '<li>no spaces    </li>' #}

Extensions

Twig can be easily extended.

If you are looking for new tags, filters, or functions, have a look at the Twig official extension repository.

If you want to create your own, read the Creating an Extension chapter.

« Installation | Twig for Developers »

 

 

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

PHP 代碼行數統計

<?php // 行數 $line = 0; // 需要統計的文件類型 $arr = array("php", "html", "css", "js"); // 過濾的文件夾 $filtering = array("ui", "dist

avenjan 2020-07-08 12:38:08

慎用PHP $_REQUEST數組

我平時總是喜歡用$_REQUEST這個數組，不是因爲別的，簡單，而且想用GET時候就用GET直接測試即可。還可以把URL打出來，很是方便。從而很少用$_GET和$_POST超全局變量。 不過，從今以後我會盡量不再使用$_REQUEST

二两天涯 2020-07-08 12:16:43

php函數名前面加@是何意

一、、、、@ 運算符只對表達式有效。對新手來說一個簡單的規則就是：如果能從某處得到值，就能在它前面加上 @ 運算符。例如，可以把它放在變量，函數和 include() 調用，常量，等等之前。不能把它放在函數或類的定義之前，也不能用於條件

二两天涯 2020-07-08 12:16:42

PHP和Javascript的JSON交互（處理一個二維數組）(轉)

xmphoenix 2020-07-08 12:00:47

php,checkbox多選框上傳失敗

用慣java和其他語言的時候，表單上傳只需要checkbox的name相同的時候就可以上傳了 <input type="checkbox" name="checkbox" value="1"> 選項1 <input type="c

阿冰介 2020-07-08 11:48:15

php中的&&運算符

今天看discuz源碼，在一個函數裏發現這麼個語句: http:// $output && print($ret); 其中$output是這個函數的一個參數，值爲true或false;$ret是一個字符串. 測試了一下，如果$output

yangmingysc 2020-07-08 11:45:39

php+mysql存儲html文件

$fileContent = trim($fileContent); $fileContent=$queueList->characet($fileContent);

moliyiran 2020-07-08 11:15:53

php+go實現grpc

1.先安裝編譯器:https://github.com/google/protobuf/releases把bin下的exe放到環境PATH目錄。做成環境變量. 2.獲取go支持庫的插件: // gRPC運行時接口編解碼支持庫 g

moliyiran 2020-07-08 11:15:42

Linux中PHP鏈接擴展.so動態庫

前幾天的一個實驗中涉及到使用PHP將本地文件部署到雲端，但是具體的實現卻還是需要費一番手腳，在網上找到的資料很多都沒辦法解決我自己遇到的實際困難，因此記錄下來僅供參考。 1、初始 我使用的雲端服務器是CentOS7.6，PHP版本是PHP

寒. 2020-07-08 11:14:55

PHP之TRUE與FALSE總結

以下代碼主要用於測試PHP中進行條件判斷時各種情況。 <?php /** * the file use to test all kinds of true and false. */ class Sample { public f

taotaoyouarebaby 2020-07-08 11:05:39

PHP配置使PHP在頁面中支持輸出內容

解決辦法： 找到系統中php.ini文件編輯，查找short_open_tag關鍵字，並將其設置爲：short_open_tag = On 注：需要找到short_open_tag = xx片段，可能會找到描述片段，修改並不起

念旧丶 2020-07-08 11:00:42

php操作xml最快的速度學習

做分享做總結 不多嗶嗶，直接上代碼：掌握php如何通過dom對象創建xml文件，php如何讀取xml及如何讀取xml文件，獲取到讀取的xml對象就可以直接操作了  <?php /** * Created by PhpStorm. *

jacklin_001 2020-07-08 10:52:26

wordpress數據字典

1.wordpress數據字典： 1.wp_categories: 用於保存分類相關信息的表。包括了5個字段，分別是: cat_ID – 每個分類唯一的ID號，爲一個bigint(20)值，且帶有附加屬性au

incloud_anke 2020-07-08 10:22:11

linux下面安裝php xdebug擴展

1.在框架裏經常會遇到debug模式！開啓選項就可以通過日誌文件快速的定位到問題 在win下面通過集成的開發包比如phpstudy就可以很容易的安裝xdebug的擴展 2.在linux下面就要通過編譯安裝來實現xde

incloud_anke 2020-07-08 10:22:10

wordpress rest api插件使用

1.wordpress rest api 插件下載： https://wordpress.org/plugins/rest-api/ 2.將下載的包解壓到wp-content/plugins目錄下 3.刷新後

incloud_anke 2020-07-08 10:22:10