Volt: Template Engine Phalcon

Volt adalah bahasa template ultra-cepat dan desainer- friendly ditulis dalam C untuk PHP. Ini memberikan Anda satu set helper untuk menulis view dengan cara yang mudah.  Volt sangat terintegrasi dengan komponen lain dari Phalcon, seperti Anda dapat menggunakannya sebagai komponen yang berdiri sendiri dalam aplikasi Anda.

volt

Volt terinspirasi oleh Jinja , awalnya diciptakan oleh Armin Ronacher . Oleh karena itu banyak pengembang akan familier karena menggunakan sintaks yang mirip. Sintaks dan fitur Volt ini telah ditingkatkan dengan lebih banyak elemen dan tentu saja dengan kinerja yang sepadan dengan Phalcon.

Pendahuluan 

Views Volt yang dikompilasi ke kode PHP murni, jadi pada dasarnya akan menghemat upaya menulis kode PHP manual:

{# app/views/products/show.volt #}

{% block last_products %}

{% for product in products %}
    * Name: {{ product.name|e }}
    {% if product.status == "Active" %}
       Price: {{ product.price + product.taxes/100 }}
    {% endif  %}
{% endfor  %}

{% endblock %}

Mengaktifkan Volt 

Sebagai mesin template lainnya, Anda dapat mendaftarkan Volt dalam komponen view, menggunakan ekstensi baru atau menggunakan kembali standar .phtml:

<?php

//Registering Volt as template engine
$di->set('view', function() {

    $view = new \Phalcon\Mvc\View();

    $view->setViewsDir('../app/views/');

    $view->registerEngines(array(
        ".volt" => 'Phalcon\Mvc\View\Engine\Volt'
    ));

    return $view;
});

Menggunakan standar ekstensi “. Phtml” :

<?php

$view->registerEngines(array(
    ".phtml" => 'Phalcon\Mvc\View\Engine\Volt'
));

Penggunaan dasar 

View terdiri dari kode Volt, PHP dan HTML. Satu set pembatas khusus tersedia untuk masuk ke modus Volt. {% …%} Digunakan untuk mengeksekusi pernyataan seperti for-loop atau menetapkan nilai-nilai dan {{…}}, mencetak hasil dari sebuah ekspresi ke template.

Di bawah ini adalah template minimal yang menggambarkan beberapa dasar-dasar:

{# app/views/posts/show.phtml #}
<!DOCTYPE html>
<html>
    <head>
        <title>{{ title }} - An example blog</title>
    </head>
    <body>

        {% if show_navigation %}
            <ul id="navigation">
            {% for item in menu %}
                <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
            {% endfor %}
            </ul>
        {% endif %}

        <h1>{{ post.title }}</h1>

        <div class="content">
            {{ post.content }}
        </div>

    </body>
</html>

Menggunakan Phalcon \ MVC \ View Anda dapat memberikan variabel dari controller untuk view. Dalam contoh di atas, tiga variabel yang dilewatkan ke view: title, menu dan post:

<?php

class PostsController extends \Phalcon\Mvc\Controller
{

    public function showAction()
    {

        $post = Post::findFirst();

        $this->view->title = $post->title;
        $this->view->post = $post;
        $this->view->menu = Menu::find();
        $this->view->show_navigation = true;

    }

}

Variabel 

Variabel objek mungkin memiliki atribut yang dapat diakses menggunakan sintaks: foo.bar. Jika Anda memberikan array, Anda harus menggunakan sintaks kurung persegi: foo[‘bar’]

{{ post.title }} {# for $post->title #}
{{ post['title'] }} {# for $post['title'] #}

Filter 

Variabel dapat diformat atau diubah menggunakan filter. Operator pipa | digunakan untuk menerapkan filter untuk variabel:

{{ post.title|e }}
{{ post.content|striptags }}
{{ name|capitalize|trim }}

Berikut ini adalah daftar tersedia built-in filter dalam Volt:

Filter Deskripsi
e Menerapkan Phalcon\Escaper->escapeHtml ke nilai
escape Menerapkan Phalcon\Escaper->escapeHtml ke nilai
escape_css Menerapkan Phalcon\Escaper->escapeCss ke nilai
escape_js Menerapkan Phalcon\Escaper->escapeJs dengan nilai
escape_attr Menerapkan Phalcon\Escaper->escapeHtmlAttr ke nilai
trim Menerapkan trim fungsi PHP untuk nilai. Menghapus spasi
left_trim Menerapkan ltrim fungsi PHP untuk nilai. Menghapus spasi
right_trim Menerapkan rtrim fungsi PHP untuk nilai. Menghapus spasi
striptags Menerapkan striptags fungsi PHP untuk nilai. Menghapus tag HTML
slashes Menerapkan garis miring fungsi PHP untuk nilai. Escaping nilai
stripslashes Menerapkan stripslashes fungsi PHP untuk nilai. Menghapus lolos kutipan
capitalize Mengkapitalisasi string dengan menerapkan ucwords fungsi PHP untuk nilai
lower Mengubah string ke huruf kecil
upper Mengubah string ke huruf besar
length Hitungan panjang string atau berapa banyak item dalam array atau obyek yang
nl2br Perubahan baris \n oleh jeda baris (<br />). Menggunakan fungsi PHP nl2br
sort Mengurutkan array menggunakan fungsi PHP asort
keys Mengembalikan kunci array menggunakan array_keys
join Menggabungkan array menggunakan pemisah join
format Format string menggunakan sprintf .
json_encode Mengkonversi nilainya ke representasi JSON 
json_decode Mengkonversi nilai dari representasi JSON ke representasi PHP
abs Menerapkan abs fungsi PHP untuk nilai.
url_encode Menerapkan urlencode fungsi PHP untuk nilai
default Menetapkan nilai default dalam jika nilai ekspresi yg dievaluasi kosong (tidak diatur atau mengevaluasi ke nilai falsy)
convert_encoding Mengubah string dari satu ke yang lain charset

Contoh:

{# e or escape filter #}
{{ "<h1>Hello<h1>"|e }}
{{ "<h1>Hello<h1>"|escape }}

{# trim filter #}
{{ "   hello   "|trim }}

{# striptags filter #}
{{ "<h1>Hello<h1>"|striptags }}

{# slashes filter #}
{{ "'this is a string'"|slashes }}

{# stripslashes filter #}
{{ "\'this is a string\'"|stripslashes }}

{# capitalize filter #}
{{ "hello"|capitalize }}

{# lower filter #}
{{ "HELLO"|lower }}

{# upper filter #}
{{ "hello"|upper }}

{# length filter #}
{{ "robots"|length }}
{{ [1, 2, 3]|length }}

{# nl2br filter #}
{{ "some\ntext"|nl2br }}

{# sort filter #}
{% set sorted=[3, 1, 2]|sort %}

{# keys filter #}
{% set keys=['first': 1, 'second': 2, 'third': 3]|keys %}

{# json_encode filter #}
{% robots|json_encode %}

{# json_decode filter #}
{% set decoded='{"one":1,"two":2,"three":3}'|json_decode %}

{# url_encode filter #}
{{ post.permanent_link|url_encode }}

{# convert_encoding filter #}
{{ "désolé"|convert_encoding('utf8', 'latin1') }}

Komentar 

Komentar juga dapat ditambahkan ke template menggunakan pembatas {# … #} . Seluruh teks di dalamnya hanya diabaikan dalam hasil akhir:

{# note: this is a comment
    {% set price = 100; %}
#}

Daftar Pengendalian Struktur 

Volt menyediakan satu set struktur kontrol dasar tapi kuat untuk digunakan dalam template:

For 

Loop pada setiap item secara berurutan. Contoh berikut menunjukkan bagaimana untuk menelusuri satu set “robots” dan mencetak / namanya:

<h1>Robots</h1>
<ul>
{% for robot in robots %}
  <li>{{ robot.name|e }}</li>
{% endfor %}
</ul>

for-loop juga dapat bersarang/nested:

<h1>Robots</h1>
{% for robot in robots %}
  {% for part in robot.parts %}
  Robot: {{ robot.name|e }} Part: {{ part.name|e }} <br/>
  {% endfor %}
{% endfor %}

Anda bisa mendapatkan elemen “key” seperti dalam PHP menggunakan sintaks berikut:

{% set numbers = ['one': 1, 'two': 2, 'three': 3] %}

{% for name, value in numbers %}
  Name: {{ name }} Value: {{ value }}
{% endfor %}

opsi evaluasi “if”  dapat ditambahkan:

{% set numbers = ['one': 1, 'two': 2, 'three': 3] %}

{% for value in numbers if value < 2 %}
  Name: {{ name }} Value: {{ value }}
{% endfor %}

{% for name, value in numbers if name != 'two' %}
  Name: {{ name }} Value: {{ value }}
{% endfor %}

Jika didefinisikan ‘else’ di dalam ‘for’, itu akan dijalankan jika ekspresi dalam objek iterator nol/kosong:

<h1>Robots</h1>
{% for robot in robots %}
    Robot: {{ robot.name|e }} Part: {{ part.name|e }} <br/>
{% else %}
    There are no robots to show
{% endfor %}

Sintaks alternatif:

<h1>Robots</h1>
{% for robot in robots %}
    Robot: {{ robot.name|e }} Part: {{ part.name|e }} <br/>
{% elsefor %}
    There are no robots to show
{% endfor %}

Kontrol Perulangan 

Statemen ‘break’ dan ‘lanjutkan’ dapat digunakan untuk keluar dari perulangan atau memaksa iterasi di blok saat ini:

{# skip the even robots #}
{% for index, robot in robots %}
    {% if index is even %}
        {% continue %}
    {% endif %}
    ...
{% endfor %}
{# exit the foreach on the first even robot #}
{% for index, robot in robots %}
    {% if index is even %}
        {% break %}
    {% endif %}
    ...
{% endfor %}

If 

Sebagaimana PHP, “if” mengecek jika ekspresi yg dievaluasi sebagai benar atau salah:

<h1>Cyborg Robots</h1>
<ul>
{% for robot in robots %}
  {% if robot.type == "cyborg" %}
  <li>{{ robot.name|e }}</li>
  {% endif %}
{% endfor %}
</ul>

Klausa else juga didukung:

<h1>Robots</h1>
<ul>
{% for robot in robots %}
  {% if robot.type == "cyborg" %}
  <li>{{ robot.name|e }}</li>
  {% else %}
  <li>{{ robot.name|e }} (not a cyborg)</li>
  {% endif %}
{% endfor %}
</ul>

Struktur aliran kontrol ‘elseif’ jg dapat digunakan bersamaan untuk meniru ‘switch’ block:

{% if robot.type == "cyborg" %}
    Robot is a cyborg
{% elseif robot.type == "virtual" %}
    Robot is virtual
{% elseif robot.type == "mechanical" %}
    Robot is mechanical
{% endif %}

Kontek Perulangan 

Sebuah variabel khusus tersedia dalam ‘for’ memberikan Anda informasi tentang blok tsb

Variabel Deskripsi
loop.index Iterasi saat loop. (1 diindeks)
loop.index0 Iterasi saat loop. (0 diindeks)
loop.revindex Jumlah iterasi dari akhir loop (1 diindeks)
loop.revindex0 Jumlah iterasi dari akhir loop (0 diindeks)
loop.first Benar jika pada iterasi pertama.
loop.last Benar jika dalam iterasi terakhir.
loop.length Jumlah item untuk iterate
{% for robot in robots %}
    {% if loop.first %}
        <table>
        <tr>
            <th>#</th>
            <th>Id</th>
            <th>Name</th>
        </tr>
    {% endif %}
        <tr>
            <td>{{ loop.index }}</td>
            <td>{{ robot.id }}</td>
            <td>{{ robot.name }}</td>
        </tr>
    {% if loop.last %}
        </table>
    {% endif %}
{% endfor %}

Penugasan 

Variabel dapat diubah dalam template menggunakan instruksi “set”:

{% set fruits = ['Apple', 'Banana', 'Orange'] %}
{% set name = robot.name %}

Beberapa penugasan diperbolehkan dalam instruksi yang sama:

{% set fruits = ['Apple', 'Banana', 'Orange'], name = robot.name, active = true %}

Selain itu, Anda dapat menggunakan operator penugasan:

{% set price += 100.00 %}
{% set age *= 5 %}

Operator berikut tersedia:

Operator Deskripsi
= Standard penugasan
+ = penugasan Penambahan
– = penugasan pengurangan
* = penugasan perkalian
/ = penugasan Divisi

Ekspresi 

Volt menyediakan satu set dasar dukungan ekspresi, termasuk literal dan operator umum.

Ekspresi dapat dievaluasi dan dicetak dengan menggunakan pembatas ‘{{‘ dan ‘}}’:

{{ (1 + 1) * 2 }}

Jika ekspresi perlu dievaluasi tanpa harus dicetak pernyataan ‘do’  dapat digunakan:

{% do (1 + 1) * 2 %}

Literal 

Literal berikut ini didukung:

Filter Deskripsi
“Ini adalah string” Teks antara tanda kutip ganda atau tanda kutip tunggal akan ditangani sebagai string
100,25 Bilangan desimal dengan bagian ditangani sebagai double / float
100 Bilangan tanpa bagian desimal ditangani sebagai integer
false Konstan “false” adalah nilai palsu boolean
true Konstan “true” adalah nilai boolean true
null Konstan “null” adalah nilai Null

Array 

Apakah Anda menggunakan PHP 5.3, 5.4 atau 5.5, Anda dapat membuat array dengan melampirkan daftar nilai dalam tanda kurung siku:

{# Simple array #}
{{ ['Apple', 'Banana', 'Orange'] }}

{# Other simple array #}
{{ ['Apple', 1, 2.5, false, null] }}

{# Multi-Dimensional array #}
{{ [[1, 2], [3, 4], [5, 6]] }}

{# Hash-style array #}
{{ ['first': 1, 'second': 4/2, 'third': '3'] }}

Kurung kurawal juga dapat digunakan untuk mendefinisikan array atau hash:

{% set myArray = {'Apple', 'Banana', 'Orange'} %}
{% set myHash = {'first': 1, 'second': 4/2, 'third': '3'} %}

Math 

Anda dapat membuat perhitungan dalam template menggunakan operator berikut:

Operator Deskripsi
+ Melakukan operasi menambahkan. {{2 + 3}} return 5
Melakukan operasi Substraction {{2 – 3}} return -1
* Melakukan operasi perkalian {{2 * 3}} return 6
/ Melakukan operasi pembagian {{10/2}} return 5
% Hitung sisa dari pembagian integer {{10% 3}} return 1

Perbandingan 

Operator perbandingan berikut ini tersedia:

Operator Deskripsi
== Periksa apakah kedua operan adalah sama
! = Periksa apakah kedua operan tidak sama
<> Periksa apakah kedua operan tidak sama
> Periksa apakah operan kiri lebih besar dari operan kanan
< Periksa apakah operan kiri kurang dari operan kanan
<= Periksa apakah operan kiri kurang atau sama dari operan kanan
> = Periksa apakah operan kiri lebih besar atau sama dari operan kanan
=== Periksa apakah kedua operan adalah identik
! == Periksa apakah kedua operan tidak identik

Logika 

Operator logika berguna dalam evaluasi ekspresi “if” untuk menggabungkan beberapa tes:

Operator Deskripsi
or Return true jika kiri atau operan kanan dievaluasi sebagai benar
and Return true jika kedua kiri dan operan kanan dievaluasi sebagai benar
not Meniadakan ekspresi
(Expr) Kelompok kurung ekspresi

Operator lainnya 

Operator lain melihat operator berikut tersedia:

Operator Deskripsi
~ Gabungkan kedua operan {{“halo” ~ “dunia”}}
| Berlaku filter dalam operan kanan ke kiri {{“halo” | uppercase}}
.. Menciptakan kisaran/range {{‘a’ .. ‘z’}} {{1 .. 10}}
is Sama seperti == (sama), juga melakukan tes
in Untuk memeriksa apakah ekspresi yang terkandung dalam ungkapan lain jika “a” dalam “abc”
is not Sama seperti! = (Tidak sama dengan)
‘A’? ‘B’: ‘c’ Operator ternary. Sama seperti operator terner PHP
+ + Akan menambahkan nilai
Decrements nilai

Contoh berikut menunjukkan bagaimana menggunakan operator:

{% set robots = ['Voltron', 'Astro Boy', 'Terminator', 'C3PO'] %}

{% for index in 0..robots|length %}
    {% if robots[index] is defined %}
        {{ "Name: " ~ robots[index] }}
    {% endif %}
{% endfor %}

Tes 

Pengujian dapat digunakan untuk menguji apakah suatu variabel memiliki nilai yang diharapkan valid. Operator “adalah” digunakan untuk melakukan tes:

{% set robots = ['1': 'Voltron', '2': 'Astro Boy', '3': 'Terminator', '4': 'C3PO'] %}

{% for position, name in robots %}
    {% if position is odd %}
        {{ value }}
    {% endif %}
{% endfor %}

Berikut tes built-in yang tersedia dalam Volt:

Uji Deskripsi
defined Memeriksa apakah variabel didefinisikan (isset)
empty Cek jika variabel kosong
even Memeriksa apakah nilai numerik genap
odd Memeriksa apakah nilai numerik ganjil
numeric Cek jika nilai numerik
scalar Cek jika nilai skalar (bukan array atau objek)
iterable Memeriksa apakah nilai yang iterable. Dapat dilalui oleh “untuk” pernyataan
divisibleby Cek apakah nilai dibagi oleh nilai lain
sameas Cek apakah nilai identik dengan nilai lain
type Cek jika nilai adalah dari jenis tertentu

Contoh lainnya:

{% if robot is defined %}
    The robot variable is defined
{% endif %}

{% if robot is empty %}
    The robot is null or isn't defined
{% endif %}

{% for key, name in [1: 'Voltron', 2: 'Astroy Boy', 3: 'Bender'] %}
    {% if key is even %}
        {{ name }}
    {% endif %}
{% endfor %}

{% for key, name in [1: 'Voltron', 2: 'Astroy Boy', 3: 'Bender'] %}
    {% if key is odd %}
        {{ name }}
    {% endif %}
{% endfor %}

{% for key, name in [1: 'Voltron', 2: 'Astroy Boy', 'third': 'Bender'] %}
    {% if key is numeric %}
        {{ name }}
    {% endif %}
{% endfor %}

{% set robots = [1: 'Voltron', 2: 'Astroy Boy'] %}
{% if robots is iterable %}
    {% for robot in robots %}
        ...
    {% endfor %}
{% endif %}

{% set world = "hello" %}
{% if world is sameas("hello") %}
    {{ "it's hello" }}
{% endif %}

{% set external = false %}
{% if external is type('boolean') %}
    {{ "external is false or true" }}
{% endif %}

Macro 

Macro dapat digunakan untuk menggunakan kembali logika dalam template, macro bertindak sebagai fungsi PHP, dapat menerima parameter dan mengembalikan nilai:

{%- macro related_bar(related_links) %}
    <ul>
        {%- for rellink in related_links %}
            <li><a href="{{ url(link.url) }}" title="{{ link.title|striptags }}">{{ link.text }}</a></li>
        {%- endfor %}
    </ul>
{%- endmacro %}

{# Print related links #}
{{ related_bar(links) }}

<div>This is the content</div>

{# Print related links again #}
{{ related_bar(links) }}

Saat memanggil macro, parameter dapat dilewatkan dengan nama:

{%- macro error_messages(message, field, type) %}
    <div>
        <span class="error-type">{{ type }}</span>
        <span class="error-field">{{ field }}</span>
        <span class="error-message">{{ message }}</span>
    </div>
{%- endmacro %}

{# Call the macro #}
{{ error_messages('type': 'Invalid', 'message': 'The name is invalid', 'field': 'name') }}

Macro dapat mengembalikan nilai:

{%- macro my_input(name, class) %}
    {% return text_field(name, 'class': class) %}
{%- endmacro %}

{# Call the macro #}
{{ '<p>' ~ my_input('name', 'input-text') ~ '</p>' }}

Dan menerima parameter opsional:

{%- macro my_input(name, class="input-text") %}
    {% return text_field(name, 'class': class) %}
{%- endmacro %}

{# Call the macro #}
{{ '<p>' ~ my_input('name') ~ '</p>' }}
{{ '<p>' ~ my_input('name', 'input-text') ~ '</p>' }}

Menggunakan Tag Helper 

Volt sangat terintegrasi dengan Phalcon \ Tag , sehingga mudah untuk menggunakan helper yang disediakan oleh komponen tsb di dalam template Volt:

{{ javascript_include("js/jquery.js") }}

{{ form('products/save', 'method': 'post') }}

    <label>Name</label>
    {{ text_field("name", "size": 32) }}

    <label>Type</label>
    {{ select("type", productTypes, 'using': ['id', 'name']) }}

    {{ submit_button('Send') }}

</form>

PHP berikut yg dihasilkan:

<?php echo Phalcon\Tag::javascriptInclude("js/jquery.js") ?>

<?php echo Phalcon\Tag::form(array('products/save', 'method' => 'post')); ?>

    <label>Name</label>
    <?php echo Phalcon\Tag::textField(array('name', 'size' => 32)); ?>

    <label>Type</label>
    <?php echo Phalcon\Tag::select(array('type', $productTypes, 'using' => array('id', 'name'))); ?>

    <?php echo Phalcon\Tag::submitButton('Send'); ?>

</form>

Untuk memanggil helper Phalcon \ Tag, Anda hanya perlu memanggil versi metodenya tanpa camel-case:

Metode Fungsi Volt
Phalcon \ Tag :: linkTo link_to
Phalcon \ Tag :: textField text_field
Phalcon \ Tag :: passwordField password_field
Phalcon \ Tag :: HiddenField hidden_field
Phalcon \ Tag :: fileField file_field
Phalcon \ Tag :: checkField check_field
Phalcon \ Tag :: radioField radio_field
Phalcon \ Tag :: DateField date_field
Phalcon \ Tag :: emailField email_field
Phalcon \ Tag :: numberField number_field
Phalcon \ Tag :: SubmitButton submit_button
Phalcon \ Tag :: selectStatic select_static
Phalcon \ Tag :: select select
Phalcon \ Tag :: textarea text_area
Phalcon \ Tag :: form form
Phalcon \ Tag :: endForm end_form
Phalcon \ Tag :: getTitle get_title
Phalcon \ Tag :: stylesheetLink stylesheet_link
Phalcon \ Tag :: javascriptInclude javascript_include
Phalcon \ Tag :: image image
Phalcon \ Tag :: friendlyTitle friendly_title

Fungsi 

Berikut fungsi built-in yang tersedia di Volt:

Nama Deskripsi
content Memasukan konten yang dihasilkan dalam tahap render sebelumnya
get_content Sama seperti ‘konten’
partial Dinamis beban pandangan parsial dalam template saat ini
super Membuat isi dari blok induk
time Memanggil fungsi PHP dengan nama yang sama
date Memanggil fungsi PHP dengan nama yang sama
dump Memanggil fungsi PHP ‘var_dump’
version Mengembalikan versi terbaru dari kerangka
constant Membaca konstan PHP
url Menghasilkan URL menggunakan ‘url’ layanan

Integrasi View  

Dan juga, Volt terintegrasi dengan Phalcon \ MVC \ View , Anda dapat bermain dengan tampilan hirarki dan termasuk parsial juga:

{{ content() }}

<!-- Simple include of a partial -->
<div id="footer">{{ partial("partials/footer") }}</div>

<!-- Passing extra variables -->
<div id="footer">{{ partial("partials/footer", ['links': $links]) }}</div>

Sebuah parsial dimasukan saat runtime, Volt juga menyediakan “include”, ini mengkompilasi isi dari view dan mengembalikan isinya sebagai bagian dari view yang disertakan:

{# Simple include of a partial #}
<div id="footer">{% include "partials/footer" %}</div>

{# Passing extra variables #}
<div id="footer">{% include "partials/footer" with ['links': links] %}</div>

Include 

‘include’ memiliki perilaku khusus yang akan membantu kita sedikit meningkatkan kinerja ketika menggunakan Volt, jika Anda menentukan ekstensi ketika termasuk file dan ada ketika template dikompilasi, Volt dapat menyisipkan isi template dalam template induk yg melakukan include. Template tidak inline jika ‘include’ memiliki variabel yg diberikan dengan ‘with’:

{# The contents of 'partials/footer.volt' is compiled and inlined #}
<div id="footer">{% include "partials/footer.volt" %}</div>

Pewarisan Template 

Dengan pewarisan template, Anda dapat membuat basis template yang dapat diperpanjang oleh template lain  yang memungkinkan untuk menggunakan kode kembali . Template dasar menentukan blok yang bisa diganti dengan template-anak. Mari kita berpura-pura bahwa kita memiliki template dasar berikut:

{# templates/base.volt #}
<!DOCTYPE html>
<html>
    <head>
        {% block head %}
            <link rel="stylesheet" href="style.css" />
        {% endblock %}
        <title>{% block title %}{% endblock %} - My Webpage</title>
    </head>
    <body>
        <div id="content">{% block content %}{% endblock %}</div>
        <div id="footer">
            {% block footer %}© Copyright 2012, All rights reserved.{% endblock %}
        </div>
    </body>
</html>

Dari template lain kita bisa memperpanjang dasar template dan menggantikan blok yg ada:

{% extends "templates/base.volt" %}

{% block title %}Index{% endblock %}

{% block head %}<style type="text/css">.important { color: #336699; }</style>{% endblock %}

{% block content %}
    <h1>Index</h1>
    <p class="important">Welcome on my awesome homepage.</p>
{% endblock %}

Tidak semua blok harus diganti di template anak, hanya yang diperlukan saja. Hasil akhir yang dihasilkan akan menjadi sebagai berikut:

<!DOCTYPE html>
<html>
    <head>
        <style type="text/css">.important { color: #336699; }</style>
        <title>Index - My Webpage</title>
    </head>
    <body>
        <div id="content">
            <h1>Index</h1>
            <p class="important">Welcome on my awesome homepage.</p>
        </div>
        <div id="footer">
            © Copyright 2012, All rights reserved.
        </div>
    </body>
</html>

Pewarisan Ganda 

Sumber extend template dapat extend template lain. Contoh berikut menggambarkan hal ini:

{# main.volt #}
<!DOCTYPE html>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        {% block content %}{% endblock %}
    </body>
</html>

Template “layout.volt” extend “main.volt”

{# layout.volt #}
{% extends "main.volt" %}

{% block content %}

    <h1>Table of contents</h1>

{% endblock %}

Akhirnya view yang extend “layout.volt”:

{# index.volt #}
{% extends "layout.volt" %}

{% block content %}

    {{ super() }}

    <ul>
        <li>Some option</li>
        <li>Some other option</li>
    </ul>

{% endblock %}

Rendering “index.volt” menghasilkan:

<!DOCTYPE html>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>

        <h1>Table of contents</h1>

        <ul>
            <li>Some option</li>
            <li>Some other option</li>
        </ul>

    </body>
</html>

Perhatikan bahwa panggilan ke fungsi “super()”. Dengan fungsi ini sangat memungkinkan untuk mengambil isi dari blok induk.

Sebagai parsial, path diatur ke “extends” adalah path relatif di bawah direktori tampilan saat ini (yaitu app / views /).

Secara default, dan untuk alasan kinerja, Volt hanya memeriksa perubahan pada anak-anak template untuk mengetahui kapan harus melakukan kompilasi ulang menjadi PHP biasa lagi, sehingga dianjurkan menginisialisasi Volt dengan opsi ‘compileAlways’ => true. Dengan demikian, template disusun dgn selalu mempertimbangkan perubahan dalam induk template.

Mode Autoescape 

Anda dapat mengaktifkan auto-escape dari semua variabel dicetak dalam blok menggunakan modus autoescape:

Manually escaped: {{ robot.name|e }}

{% autoescape true %}
    Autoescaped: {{ robot.name }}
    {% autoescape false %}
        No Autoescaped: {{ robot.name }}
    {% endautoescape %}
{% endautoescape %}

Set-up Volt Engine 

Volt dapat dikonfigurasi untuk mengubah perilaku default, contoh berikut menjelaskan bagaimana untuk melakukannya:

<?php

use Phalcon\Mvc\View,
    Phalcon\Mvc\View\Engine\Volt;

//Register Volt as a service
$di->set('voltService', function($view, $di) {

    $volt = new Volt($view, $di);

    $volt->setOptions(array(
        "compiledPath" => "../app/compiled-templates/",
        "compiledExtension" => ".compiled"
    ));

    return $volt;
});

//Register Volt as template engine
$di->set('view', function() {

    $view = new View();

    $view->setViewsDir('../app/views/');

    $view->registerEngines(array(
        ".volt" => 'voltService'
    ));

    return $view;
});

Jika Anda tidak ingin menggunakan kembali Volt sebagai layanan, Anda dapat melewati fungsi anonim untuk mendaftarkan mesinnya bukan nama layanan:

<?php

//Register Volt as template engine with an anonymous function
$di->set('view', function() {

    $view = new \Phalcon\Mvc\View();

    $view->setViewsDir('../app/views/');

    $view->registerEngines(array(
        ".volt" => function($view, $di) {
            $volt = new \Phalcon\Mvc\View\Engine\Volt($view, $di);

            //set some options here

            return $volt;
        }
    ));

    return $view;
});

Pilihan berikut tersedia dalam Volt:

Pilihan Deskripsi Kegagalan
compiledPath Sebuah path writeable di mana PHP template terkompilasi akan ditempatkan . /
compiledExtension Extension tambahan ditambahkan ke file PHP yg dikompilasi Php.
compiledSeparator Volt menggantikan pemisah direktori / dan \ oleh separator ini untuk membuat file tunggal dalam direktori compile %%
Stat Apakah Phalcon harus memeriksa apakah ada perbedaan antara file template dan direktori compile benar
compileAlways Beritahu Volt jika template harus dikompilasi dalam setiap permintaan atau hanya ketika ada perubahan palsu
prefix Memungkinkan untuk tambahkan awalan ke template di direktori kompilasi batal

direktori kompilasi dibuat sesuai dengan pilihan di atas, jika pengembang ingin kebebasan total mendefinisikan path kompilasi, fungsi anonim dapat digunakan untuk menghasilkannya, fungsi ini menerima path relatif ke template di direktori views. Contoh berikut ini menunjukkan bagaimana untuk mengubah jalur kompilasi dinamis:

<?php

// Just append the .php extension to the template path
// leaving the compiled templates in the same directory
$volt->setOptions(array(
    'compiledPath' => function($templatePath) {
        return $templatePath . '.php';
    }
));

// ​​Recursively create the same structure in another directory
$volt->setOptions(array(
    'compiledPath' => function($templatePath) {
        $dirName = dirname($templatePath);
        if (!is_dir('cache/' . $dirName)) {
            mkdir('cache/' . $dirName);
        }
        return 'cache/' . $dirName . '/'. $templatePath . '.php';
    }
));

Extend Volt 

Tidak seperti mesin template lainnya, komponen Volt itu sendiri tidak diperlukan untuk menjalankan template yg telah terkompilasi. Setelah template disusun tidak ada ketergantungan pada Volt. Dengan kemerdekaan kinerja dalam pikiran, Volt hanya bertindak sebagai compiler untuk PHP template.

The Volt compiler memungkinkan Anda untuk extend; menambahkan fungsi, tes atau filter yang sudah ada.

Fungsi 

Fungsi bertindak sebagai fungsi PHP normal, nama string yang valid diperlukan sebagai nama fungsi. Fungsi dapat ditambahkan dengan menggunakan dua strategi, kembali string sederhana atau menggunakan fungsi anonim. Strategi yang dipilih tetap harus mengembalikan ekspresi PHP string yang valid:

<?php

$volt = new \Phalcon\Mvc\View\Engine\Volt($view, $di);

$compiler = $volt->getCompiler();

//This binds the function name 'shuffle' in Volt to the PHP function 'str_shuffle'
$compiler->addFunction('shuffle', 'str_shuffle');

Mendaftarkan fungsi dengan fungsi anonim. Kali ini kita menggunakan $resolvedArgs untuk meneruskan argumen persis seperti yang diberikan pada argumen:

<?php

$compiler->addFunction('widget', function($resolvedArgs, $exprArgs) {
    return 'MyLibrary\Widgets::get(' . $resolvedArgs . ')';
});

Perlakukan argumen independen dan tanpa resolve:

<?php

$compiler->addFunction('repeat', function($resolvedArgs, $exprArgs) use ($compiler) {

    //Resolve the first argument
    $firstArgument = $compiler->expression($exprArgs[0]['expr']);

    //Checks if the second argument was passed
    if (isset($exprArgs[1])) {
        $secondArgument = $compiler->expression($exprArgs[1]['expr']);
    } else {
        //Use '10' as default
        $secondArgument = '10';
    }

    return 'str_repeat(' . $firstArgument . ', ' . $secondArgument . ')';
});

Menghasilkan kode didasarkan pada beberapa ketersediaan fungsi:

<?php

$compiler->addFunction('contains_text', function($resolvedArgs, $exprArgs) {
    if (function_exists('mb_stripos')) {
        return 'mb_stripos(' . $resolvedArgs . ')';
    } else {
        return 'stripos(' . $resolvedArgs . ')';
    }
});

Fungsi built-in dapat diganti menambahkan fungsi dengan nama yg sama:

<?php

//Replace built-in function dump
$compiler->addFunction('dump', 'print_r');

Filter 

Filter memiliki format berikut dalam template: leftExpr|name(optional-args). Menambahkan filter baru ini mirip seperti yang terlihat dengan fungsi:

<?php

//This creates a filter 'hash' that uses the PHP function 'md5'
$compiler->addFilter('hash', 'md5');
<?php

$compiler->addFilter('int', function($resolvedArgs, $exprArgs) {
    return 'intval(' . $resolvedArgs . ')';
});

Built-in filter dapat diganti menambahkan fungsi dengan nama:

<?php

//Replace built-in filter 'capitalize'
$compiler->addFilter('capitalize', 'lcfirst');

Ekstensi 

Dengan ekstensi pengembang memiliki lebih banyak fleksibilitas untuk extend template engine, dan overide kompilasi instruksi tertentu, mengubah perilaku dari sebuah ekspresi atau operator, menambahkan fungsi / filter, dan banyak lagi.

Ekstensi adalah class yang mengimplementasikan event yg dipicu oleh Volt sebagai metode sendiri.

Sebagai contoh, kelas bawah memungkinkan untuk menggunakan fungsi PHP dalam Volt:

<?php

class PhpFunctionExtension
{
    /**
     * This method is called on any attempt to compile a function call
     */
    public function compileFunction($name, $arguments)
    {
        if (function_exists($name)) {
            return $name . '('. $arguments . ')';
        }
    }
}

Class diatas mengimplementasikan metode ‘compileFunction’ yang dipanggil sebelum tiap upaya untuk mengkompilasi pemanggilan fungsi di setiap template. Tujuan dari ekstensi ini adalah untuk memverifikasi apakah fungsi untuk dikompilasi adalah fungsi PHP yang memungkinkan untuk dipanggil dari template. Event di ekstensi harus mengembalikan kode PHP yang valid, ini akan digunakan sebagai hasil kompilasi bukan yang dihasilkan oleh Volt. Jika suatu event tidak mengembalikan string, kompilasi dilakukan dengan menggunakan perilaku default yang disediakan oleh mesin.

Event kompilasi berikut ini tersedia untuk diterapkan dalam ekstensi:

Acara / Metode Deskripsi
compileFunction Dipicu sebelum mencoba untuk mengkompilasi setiap panggilan fungsi dalam template
compileFilter Dipicu sebelum mencoba untuk mengkompilasi setiap panggilan filter dalam template
resolveExpression Dipicu sebelum mencoba untuk mengkompilasi ekspresi apapun. Hal ini memungkinkan pengembang untuk overide operator
compileStatement Dipicu sebelum mencoba untuk mengkompilasi ekspresi apapun.Hal ini memungkinkan pengembang untuk overide pernyataan apapun

Ekstensi Volt harus dalam terdaftar di compiler membuatnya tersedia dalam waktu kompilasi:

<?php

//Register the extension in the compiler
$compiler->addExtension(new PhpFunctionExtension());

Cache Fragmen View 

Dengan Volt mudah untuk men-cache fragmen view. Cache ini meningkatkan kinerja, mencegah bahwa isi dari suatu blok dieksekusi oleh PHP setiap kali view ditampilkan:

{% cache "sidebar" %}
    <!-- generate this content is slow so we are going to cache it -->
{% endcache %}

Menetapkan jumlah tertentu detik:

{# cache the sidebar by 1 hour #}
{% cache "sidebar" 3600 %}
    <!-- generate this content is slow so we are going to cache it -->
{% endcache %}

Setiap ekspresi yang valid dapat digunakan sebagai key cache:

{% cache ("article-" ~ post.id) 3600 %}

    <h1>{{ post.title }}</h1>

    <p>{{ post.content }}</p>

{% endcache %}

Cache dilakukan oleh komponen Phalcon\Cache melalui komponen view. Pelajari lebih lanjut tentang cara integrasi ini bekerja di bagian “Caching View Fragmen” .

Inject Layanan ke Template 

Jika wadah pelayanan (DI) yang tersedia untuk Volt, Anda dapat menggunakan layanan dengan hanya mengakses nama layanan dr dalam template:

{# Inject the 'flash' service #}
<div id="messages">{{ flash.output() }}</div>

{# Inject the 'security' service #}
<input type="hidden" name="token" value="{{ security.getToken() }}">

Stand-alone komponen 

Menggunakan Volt dalam mode stand-alone dapat ditunjukkan di bawah ini:

<?php

//Create a compiler
$compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();

//Optionally add some options
$compiler->setOptions(array(
    //...
));

//Compile a template string returning PHP code
echo $compiler->compileString('{{ "hello" }}');

//Compile a template in a file specifying the destination file
$compiler->compileFile('layouts/main.volt', 'cache/layouts/main.volt.php');

//Compile a template in a file based on the options passed to the compiler
$compiler->compile('layouts/main.volt');

//Require the compiled templated (optional)
require $compiler->getCompiledTemplatePath();

Sumber eksternal 

 

Terjemah dr Volt: Template Engine Phalcon
http://docs.phalconphp.com/en/latest/reference/volt.html