Nette Documentation Preview

syntax
ラテのタグ
*****

.[perex]
Latte内蔵の全タグの概要と説明。

.[table-latte-tags language-latte]
|## 印刷
|`{$var}`,`{...}` or`{=...}` |[エスケープされた変数や式を印刷します。|#printing]
|`{$var\|filter}` |[フィルタリングして印刷する|#filters]
|`{l}` または`{r}` |`{` or `}` の文字を表示します。

.[table-latte-tags language-latte]
|## 条件
|`{if}`...`{elseif}`...`{else}`...`{/if}` | [条件 if |#if-elseif-else]
|`{ifset}`...`{elseifset}`...`{/ifset}` |[条件 ifset |#ifset-elseifset]
|`{ifchanged}`...`{/ifchanged}` |[変化があったかどうかのテスト|#ifchanged]
|`{switch}` `{case}` `{default}` `{/switch}` |[条件スイッチ |#switch-case-default]
|`n:else` |[コンディションの代替コンテンツ |#n:else]

.[table-latte-tags language-latte]
|## ループ
|`{foreach}`...`{/foreach}` |[foreach |#foreach]
|`{for}`...`{/for}` |[for |#for]
|`{while}`...`{/while}` |[while |#while]
|`{continueIf $cond}` |[次の反復に進む |#continueif-skipif-breakif]
|`{skipIf $cond}` |[現在のループの反復をスキップする|#continueif-skipif-breakif]
|`{breakIf $cond}` |[ループを 中断|#continueif-skipif-breakif]
|`{exitIf $cond}` |[早期終了 |#exitif]
|`{first}`...`{/first}` |[最初のイテレーションか? |#first-last-sep]
|`{last}`...`{/last}` |[それは最後の反復ですか?|#first-last-sep]
|`{sep}`...`{/sep}` |[次の反復が続くか?|#first-last-sep]
|`{iterateWhile}`...`{/iterateWhile}` |[構造化されたforeach |#iterateWhile]
|`$iterator` |[foreachループ内の特殊変数 |#$iterator]

.[table-latte-tags language-latte]
|## 他のテンプレートをインクルードする
|`{include 'file.latte'}` |[他のファイルからテンプレートをインクルードする|#include]
|`{sandbox 'file.latte'}` |[サンドボックスモードでテンプレートをインクルードする|#sandbox]

.[table-latte-tags language-latte]
|## ブロック、レイアウト、テンプレートの継承
|`{block}` |[匿名ブロック |#block]
|`{block blockname}` |[ブロックの定義 |template-inheritance#blocks]
|`{define blockname}` |[将来使用するブロックの定義 |template-inheritance#definitions]
|`{include blockname}` |[ブロックを印刷する|template-inheritance#printing-blocks]
|`{include blockname from 'file.latte'}` |[ファイルからのブロックの印刷|template-inheritance#printing-blocks]
|`{import 'file.latte'}` |[別のテンプレートからブロックをロードする|template-inheritance#horizontal-reuse]
|`{layout 'file.latte'}` /`{extends}` |[レイアウトファイルの指定 |template-inheritance#layout-inheritance]
|`{embed}`...`{/embed}` |[テンプレートまたはブロックをロードし、ブロックを上書きすることができます。|template-inheritance#unit-inheritance]
|`{ifset blockname}`...`{/ifset}` |[ブロックが定義されている場合の条件 |template-inheritance#checking-block-existence]

.[table-latte-tags language-latte]
|## 例外処理
|`{try}`...`{else}`...`{/try}` |[例外をキャッチする |#try]
|`{rollback}` |[トライブロックを破棄する|#rollback]

.[table-latte-tags language-latte]
|## 変数
|`{var $foo = value}` |[変数の作成 |#var-default]
|`{default $foo = value}` |[変数が宣言されていないときのデフォルト値 |#var-default]
|`{parameters}` | [変数の宣言、デフォルト値のタイプ|#parameters]
|`{capture}`...`{/capture}` |[セクションを変数に取り込む |#capture]

.[table-latte-tags language-latte]
|## タイプ
|`{varType}` |[変数のタイプを宣言|type-system#varType]
|`{varPrint}` |[変数の種類を提案する|type-system#varPrint]
|`{templateType}` |[クラスを使った変数の型の宣言|type-system#templateType]
|`{templatePrint}` |[プロパティを含むクラスを生成 |type-system#templatePrint]

.[table-latte-tags language-latte]
|## 翻訳
|`{_string}` |[翻訳された内容を表示する |#Translation]
|`{translate}`...`{/translate}` |[内容を 翻訳する|#Translation]

.[table-latte-tags language-latte]
|## その他
|`{contentType}` |[エスケープモードを切り替え、HTTPヘッダを送信 します。|#contenttype]
|`{debugbreak}` |[コードにブレークポイントを設定 します。|#debugbreak]
|`{do}` |[式を表示せずに評価 する|#do]
|`{dump}` |[トレイシーバーに変数をダンプ する|#dump]
|`{php}` |[任意のPHPコードを実行する |#php]
|`{spaceless}`...`{/spaceless}` |[不要な空白を削除する|#spaceless]
|`{syntax}` |[実行時に構文を切り替えます。|#syntax]
|`{trace}` |[スタックトレースを表示する|#trace]

.[table-latte-tags language-latte]
|## HTMLタグヘルパー
|`n:class` |[スマートなクラス属性|#n:class]
|`n:attr` | [スマートなHTML属性 |#n:attr]
|`n:tag` |[HTML 要素の動的な名前 |#n:tag]
|`n:ifcontent` |[空の HTML タグを省略する|#n:ifcontent]

.[table-latte-tags language-latte]
|## Nette Framework のみで利用可能
|`n:href` |[`<a>` HTML要素内のリンク |application:en:creating-links#In the Presenter Template]
|`{link}` |[リンクを表示する|application:en:creating-links#In the Presenter Template]
|`{plink}` |[プレゼンターへのリンクを表示する|application:en:creating-links#In the Presenter Template]
|`{control}` |[コンポーネントを表示します|application:en:components#Rendering]
|`{snippet}`...`{/snippet}` |[AJAXで送信可能なテンプレートスニペット |application:en:ajax#snippets-in-latte]
|`{snippetArea}` | [スニペットの封筒 |application:en:ajax#snippet-areas]
|`{cache}`...`{/cache}` |[テンプレートセクションをキャッシュする|caching:en#caching-in-latte]

.[table-latte-tags language-latte]
|## Nette Forms のみで利用可能
|`{form}`...`{/form}` |[フォームエレメントを表示します。|forms:en:rendering#form]
|`{label}`...`{/label}` |[フォーム入力ラベルを表示します。|forms:en:rendering#label-input]
|`{input}` |[フォーム入力要素を表示します。|forms:en:rendering#label-input]
|`{inputError}` | [フォーム入力要素のエラーメッセージを表示します。|forms:en:rendering#inputError]
|`n:name` |[HTML入力要素をアクティブにする|forms:en:rendering#n:name]
|`{formContainer}`...`{/formContainer}` |[フォームコンテナのレンダリング |forms:en:rendering#special-cases]


印刷 .[#toc-printing]
===================


`{$var}` `{...}` `{=...}`
-------------------------

Latteでは、`{=...}` タグを使って、任意の式を出力しています。式の先頭が変数や関数呼び出しの場合、等号を書く必要はありません。つまり、実際には、ほとんど書く必要がないのです。

```latte
Name: {$name} {$surname}<br>
Age: {date('Y') - $birth}<br>
```

PHP で知っていることは何でも式として書くことができます。新しい言語を学ぶ必要がないだけです。例えば


```latte
{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}
```

前の例で意味を探さないでください。もしそこで意味を見つけたら、私たちに書いてください :-)


エスケープ出力 .[#toc-escaping-output]
-------------------------------

テンプレートシステムの最も重要なタスクは何ですか?セキュリティホールを回避することです。そして、それはまさにLatteが出力に何かを印刷するときに行うことです。それは自動的にすべてをエスケープします。

```latte
<p>{='one < two'}</p>   {* prints: '<p>one &lt; two</p>' *}
```

正確には、Latteは文脈依存のエスケープを行います。これは非常に重要かつユニークな機能なので、[別の章を設けて |safety-first#context-aware-escaping] 解説しています。

また、HTMLコード化されたコンテンツを信頼できるところから印刷する場合は?それなら簡単にエスケープをオフにすることができます。

```latte
{$trustedHtmlString|noescape}
```

.[warning]
`noescape` フィルタを誤用すると、XSS 脆弱性につながる可能性があります!自分が何をしているのか、そして印刷する文字列が信頼できるソースから来たものであることが **絶対に** 確実でない限り、決してこれを使用しないでください。


JavaScriptで印刷する .[#toc-printing-in-javascript]
----------------------------------------------

文脈依存のエスケープのおかげで、JavaScriptの内部で変数を印刷するのは驚くほど簡単で、Latteはそれらを適切にエスケープします。

変数は文字列である必要はなく、どんなデータ型にも対応し、JSONとしてエンコードされます。

```latte
{var $foo = ['hello', true, 1]}
<script>
	alert({$foo});
</script>
```

を生成します。

```latte
<script>
	alert(["hello", true, 1]);
</script>
```

これは、**変数を引用符で囲まないでください**という理由でもあります。ラテは文字列を引用符で囲みます。また、文字列の変数を別の文字列に入れたい場合は、単純に連結してください。

```latte
<script>
	alert('Hello ' + {$name} + '!');  // OK

	alert({="Hello $name!"});         // OK

	alert('Hello {$name} !');         // ERROR!
</script>
```


フィルタ .[#toc-filters]
--------------------

印刷された式は、[フィルターによって |syntax#filters]変更することができます。例えば、この例では文字列を大文字に変換し、最大30文字に短縮しています。

```latte
{$string|upper|truncate:30}
```

また、以下のように式の一部にフィルタを適用することもできます。

```latte
{$left . ($middle|upper) . $right}
```


条件 .[#toc-conditions]
=====================


`{if}` `{elseif}` `{else}`
--------------------------

条件は、PHP の条件と同じように動作します。PHP でおなじみの表現が使えるので、新しい言語を学ぶ必要はありません。

```latte
{if $product->inStock > Stock::Minimum}
	In stock
{elseif $product->isOnWay()}
	On the way
{else}
	Not available
{/if}
```

他のペアタグと同様に、`{if} ... {/ if}` のペアは、例えば[n:attribute |syntax#n:attributes] のように書くことができます。

```latte
<p n:if="$count > 0">In stock {$count} items</p>
```

n:attributesに接頭辞`tag-` を付けることができることをご存知でしょうか?この場合、HTMLタグにのみ影響を与え、その間の内容は常に印刷されます。

```latte
<a href="..." n:tag-if="$clickable">Hello</a>

{* prints 'Hello' when $clickable is falsey *}
{* prints '<a href="...">Hello</a>' when $clickable is truthy *}
```

いいですね。


`n:else` .{data-version:3.0.11}
-------------------------------

 の条件を`{if} ... {/if}` [n:属性の |syntax#n:attributes]形で記述した場合、 を使って別の分岐を指定するオプションがある:



 。`n:else````latte
<strong n:if="$count > 0">In stock {$count} items</strong>

<em n:else>not available</em>
``` `n:else` [`n:ifset` |#ifset-elseifset], [`n:foreach` |#foreach], [`n:try` |#try], [`n:ifcontent` |#n:ifcontent]および [`n:ifchanged` |#ifchanged].


`{/if $cond}`
-------------

`{if}` 条件の式も終了タグで指定できることに驚かれたかもしれません。これは、タグが開かれたときに、まだ条件の値がわからないような場合に便利です。遅延判定とでも言いましょうか。

たとえば、データベースからレコードを取得してテーブルのリストアップを開始し、レポートが完成した後で、データベースにレコードがないことに気がついたとします。そこで、終了タグ`{/if}` に条件を入れて、レコードがなければ、何も印刷されないようにします。

```latte
{if}
	<h1>Printing rows from the database</h1>

	<table>
	{foreach $resultSet as $row}
		...
	{/foreach}
	</table>
{/if isset($row)}
```

便利でしょう?

繰延条件では`{else}` も使えますが、`{elseif}` は使えません。


`{ifset}` `{elseifset}`
-----------------------

.[note]
参照 [`{ifset block}` |template-inheritance#checking-block-existence]

変数(あるいは複数の変数)が存在し、かつ非 null 値であるかどうかを調べるには、`{ifset $var}` 条件を使用します。これは、実際にはPHPの`if (isset($var))` と同じです。他のペアタグと同様に、[n:attributeの |syntax#n:attributes]形式で書くことができますので、例で紹介しましょう。

```latte
<meta name="robots" content="{$robots}" n:ifset="$robots">
```


`{ifchanged}`
-------------

`{ifchanged}` は、ループ(foreach、for、while)内の最後の反復から、変数の値が変化したかどうかをチェックします。

タグの中で1つ以上の変数を指定すると、それらの変数のいずれかが変更されたかどうかをチェックし、それに応じて内容を表示します。たとえば、次の例では、名前をリストアップするときに、変更されるたびに名前の最初の文字を見出しとしてプリントしています。

```latte
{foreach ($names|sort) as $name}
	{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}

	<p>{$name}</p>
{/foreach}
```

しかし、引数が与えられない場合は、レンダリングされた内容そのものが以前の状態と照らし合わされる。つまり、先ほどの例では、タグの引数を省略しても大丈夫ということです。また、もちろん[n:attributeを |syntax#n:attributes]使うこともできます。

```latte
{foreach ($names|sort) as $name}
	<h2 n:ifchanged>{$name[0]}</h2>

	<p>{$name}</p>
{/foreach}
```

の中に`{else}` 節を入れることもできます。`{ifchanged}`.


`{switch}` `{case}` `{default}`
-------------------------------
値を複数のオプションと比較します。これは、PHPでおなじみの`switch` の構造に似ています。しかし、Latteではそれを改良しています。

- 厳密な比較を行う (`===`)
- は必要ありません。`break`

つまり、PHP 8.0が搭載している`match` 構造とまったく同じものです。

```latte
{switch $transport}
	{case train}
		By train
	{case plane}
		By plane
	{default}
		Differently
{/switch}
```

節`{case}` は、カンマで区切られた複数の値を含むことができます。

```latte
{switch $status}
{case $status::New}<b>new item</b>
{case $status::Sold, $status::Unknown}<i>not available</i>
{/switch}
```


ループ .[#toc-loops]
=================

Latteでは、PHPでおなじみのforeach、for、whileといったループが利用可能です。


`{foreach}`
-----------

サイクルはPHPと全く同じように書きます。

```latte
{foreach $langs as $code => $lang}
	<span>{$lang}</span>
{/foreach}
```

さらに、これから説明するような便利な調整もあるそうです。

例えば、ラテは作成した変数が誤って同じ名前のグローバル変数を上書きしないようにチェックしています。これは、`$lang` がそのページの現在の言語であると仮定したときに、`foreach $langs as $lang` がその変数を上書きしてしまったことに気づかなかったときの救いになります。

foreachループも[n:attributeを |syntax#n:attributes]使えば非常にエレガントかつ経済的に書くことができる。

```latte
<ul>
	<li n:foreach="$items as $item">{$item->name}</li>
</ul>
```

n:attributeの前に`inner-` というプレフィックスを付けることができることをご存知ですか?これで、ループの中で要素の内側の部分だけが繰り返されるようになります。

```latte
<div n:inner-foreach="$items as $item">
	<h4>{$item->title}</h4>
	<p>{$item->description}</p>
</div>
```

というわけで、次のような感じでプリントされます。

```latte
<div>
	<h4>Foo</h4>
	<p>Lorem ipsum.</p>
	<h4>Bar</h4>
	<p>Sit dolor.</p>
</div>
```


`{else}` .{toc: foreach-else}
-----------------------------

`foreach` ループでは、オプションで`{else}` 節を指定することができ、そのテキストは与えられた配列が空の場合に表示されます。

```latte
<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Sorry, no users in this list</em></li>
	{/foreach}
</ul>
```


`$iterator`
-----------

`foreach` ループの内部では、変数`$iterator` が初期化されます。これは、現在のループに関する重要な情報を保持します。

-`$iterator->first` - これは最初の反復処理か?
-`$iterator->last` - これは最後の反復処理ですか?
-`$iterator->counter` - 反復カウンタ、1 から始まる。
-`$iterator->counter0` - 反復カウンタ、0から開始。
-`$iterator->odd` - この反復は奇数ですか?
-`$iterator->even` - この反復は偶数か?
-`$iterator->parent` - 現在のイテレータを囲むイテレータ
-`$iterator->nextValue` - ループ内の次のアイテム
-`$iterator->nextKey` - ループ内の次のアイテムのキー


```latte
{foreach $rows as $row}
	{if $iterator->first}<table>{/if}

	<tr id="row-{$iterator->counter}">
		<td>{$row->name}</td>
		<td>{$row->email}</td>
	</tr>

	{if $iterator->last}</table>{/if}
{/foreach}
```

ラテは賢く、`$iterator->last` 配列だけでなく、事前に項目数が分からない一般的なイテレータ上でループを実行する場合にも有効です。


`{first}` `{last}` `{sep}`
--------------------------

これらのタグは、`{foreach}` のループの中で使用することができます。`{first}` のコンテンツは、最初のパスでレンダリングされます。
`{last}` のコンテンツがレンダリングされる......わかるかな?そう、最後のパスです。これらは実は、`{if $iterator->first}` と`{if $iterator->last}` のショートカットです。

タグは[n:attributesと |syntax#n:attributes]書くこともできる.

```latte
{foreach $rows as $row}
	{first}<h1>List of names</h1>{/first}

	<p>{$row->name}</p>

	<hr n:last>
{/foreach}
```

`{sep}` の内容は、反復が最後でない場合にレンダリングされるので、リストされた項目の間にカンマなどの区切り文字を印刷するのに適しています。

```latte
{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}
```

かなり実用的ですね。


`{iterateWhile}`
----------------

条件を満たす限りネストしたループで反復処理を行うことで、foreachループでの反復処理中の線形データのグループ化を簡略化します。[クックブックの |cookbook/iteratewhile]説明をお読みください。

また、上の例の`{first}` と`{last}` をエレガントに置き換えることができます。

```latte
{foreach $rows as $row}
	<table>

	{iterateWhile}
	<tr id="row-{$iterator->counter}">
		<td>{$row->name}</td>
		<td>{$row->email}</td>
	</tr>
	{/iterateWhile true}

	</table>
{/foreach}
```


`{for}`
-------

サイクルはPHPと全く同じように書きます。

```latte
{for $i = 0; $i < 10; $i++}
	<span>Item #{$i}</span>
{/for}
```

タグは[n:attributeと |syntax#n:attributes]書くこともできる。

```latte
<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>
```


`{while}`
---------

ここでも、PHPと全く同じ方法でサイクルを書きます。

```latte
{while $row = $result->fetch()}
	<span>{$row->title}</span>
{/while}
```

あるいは[n:attributeの |syntax#n:attributes]ように。

```latte
<span n:while="$row = $result->fetch()">
	{$row->title}
</span>
```

終了タグに条件を指定するバリアントは、PHP の do-while ループに相当します。

```latte
{while}
	<span>{$item->title}</span>
{/while $item = $item->getNext()}
```


`{continueIf}` `{skipIf}` `{breakIf}`
-------------------------------------

ループを制御するために使用できる特別なタグがあります。`{continueIf ?}` と`{breakIf ?}` はそれぞれ、条件が満たされた場合に次の反復処理にジャンプし、ループを終了させるものです。

```latte
{foreach $rows as $row}
	{continueIf $row->date < $now}
	{breakIf $row->parent === null}
	...
{/foreach}
```


タグ`{skipIf}` は`{continueIf}` と非常によく似ていますが、カウンターをインクリメントしません。したがって、`$iterator->counter` を表示して、いくつかの項目をスキップしても、番号付けに穴が開くことはありません。また、{else}句はすべての項目をスキップするときに表示されます。

```latte
<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Sorry, no adult users in this list</em></li>
	{/foreach}
</ul>
```


`{exitIf}` .{data-version:3.0.5}
--------------------------------

ある条件が満たされたとき、テンプレートまたはブロックのレンダリングを終了します(すなわち、「早期終了」)。

```latte
{exitIf !$messages}

<h1>Messages</h1>
<div n:foreach="$messages as $message">
   {$message}
</div>
```


テンプレートを含む .[#toc-including-templates]
=====================================


`{include 'file.latte'}` .{toc: include}
----------------------------------------

.[note]
参照 [`{include block}` |template-inheritance#printing-blocks]

`{include}` タグは、指定されたテンプレートを読み込み、レンダリングします。私たちの大好きなPHP言語では、次のような感じです。

```php
<?php include 'header.phtml'; ?>
```

インクルードされたテンプレートは、アクティブなコンテキストの変数にはアクセスできませんが、グローバル変数にはアクセスできます。

挿入されたテンプレートには、以下の方法で変数を渡すことができます:

```latte
{include 'template.latte', foo: 'bar', id: 123}
```

テンプレート名には、任意の PHP 式を指定することができます。

```latte
{include $someVar}
{include $ajax ? 'ajax.latte' : 'not-ajax.latte'}
```

挿入される内容は、[フィルタを用いて |syntax#filters]変更することができます。次の例は、すべての HTML を削除し、大文字小文字を調整するものです。

```latte
<title>{include 'heading.latte' |stripHtml|capitalize}</title>
```

[テンプレートの継承は |template inheritance]デフォルトでは **関与**しません。インクルードされたテンプレートにブロックタグを追加することはできますが、インクルードされたテンプレート内のマッチするブロックを置き換えることはありません。インクルードは、ページやモジュールの独立したシールドされた部分だと考えてください。この動作は、修飾子`with blocks` を使って変更できます:

```latte
{include 'template.latte' with blocks}
```

タグで指定されたファイル名とディスク上のファイルとの関係は、[ローダーの |extending-latte#Loaders]問題です。


`{sandbox}`
-----------

エンドユーザーが作成したテンプレートをインクルードする場合、サンドボックス化を検討する必要があります(詳細は[サンドボックスのドキュメントを |sandbox]参照してください)。

```latte
{sandbox 'untrusted.latte', level: 3, data: $menu}
```


`{block}`
=========

.[note]
こちらもご覧ください [`{block name}` |template-inheritance#blocks]

名前のないブロックは、テンプレートの一部に[フィルタを |syntax#filters]適用する機能を提供します。例えば、[ストリップ |filters#strip]フィルターを適用して不要なスペースを削除することができます。

```latte
{block|strip}
<ul>
	<li>Hello World</li>
</ul>
{/block}
```


例外処理 .[#toc-exception-handling]
===============================


`{try}`
-------

このタグを使うと、非常に簡単に堅牢なテンプレートを構築することができます。

`{try}` ブロックのレンダリング中に例外が発生した場合、ブロック全体がスローされ、その後にレンダリングが続行されます。

```latte
{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
{/try}
```

オプションの節`{else}` の内容は、例外が発生したときだけレンダリングされる。

```latte
{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Sorry, the tweets could not be loaded.</p>
{/try}
```

このタグは[n:attributeと |syntax#n:attributes]書くこともできる.

```latte
<ul n:try>
	...
</ul>
```

また、ロギングなどのための[例外ハンドラを独自 |develop#exception handler]に定義することも可能です。


`{rollback}`
------------

`{try}` ブロックは、`{rollback}` を使って手動で停止したり、スキップしたりすることもできます。そのため、事前にすべての入力データをチェックする必要はなく、レンダリング中にのみ、オブジェクトをレンダリングすることに意味があるかどうかを判断することができます。

```latte
{try}
<ul>
	{foreach $people as $person}
 		{skipIf $person->age < 18}
 		<li>{$person->name}</li>
	{else}
		{rollback}
	{/foreach}
</ul>
{/try}
```


変数 .[#toc-variables]
====================


`{var}` `{default}`
-------------------

`{var}` タグを使用して、テンプレート内に新しい変数を作成することにします。

```latte
{var $name = 'John Smith'}
{var $age = 27}

{* Multiple declaration *}
{var $name = 'John Smith', $age = 27}
```

`{default}` タグも同様に動作しますが、変数が存在しない場合にのみ変数を作成する点が異なります。

```latte
{default $lang = 'cs'}
```

[変数の種類を |type-system]指定することもできる。今のところ、これらは情報提供であり、ラテはチェックしない。

```latte
{var string $name = $article->getTitle()}
{default int $id = 0}
```


`{parameters}`
--------------

関数がパラメータを宣言するのと同じように,テンプレートもその先頭で変数を宣言することができます.

```latte
{parameters
	$a,
	?int $b,
	int|string $c = 10
}
```

デフォルト値のない変数`$a` と`$b` は自動的にデフォルト値`null` を持ちます.宣言された型はまだ参考値であり,Latteはそれをチェックしません.

その他、宣言された変数はテンプレートに渡されません。この点は`{default}` タグとの違いです。


`{capture}`
-----------

`{capture}` タグを使用することで、出力を変数に取り込むことができます。

```latte
{capture $var}
<ul>
	<li>Hello World</li>
</ul>
{/capture}

<p>Captured: {$var}</p>
```

このタグは、他のペアタグと同様に[n:attributeと |syntax#n:attributes]書くこともできる:

```latte
<ul n:capture="$var">
	<li>Hello World</li>
</ul>
```

HTML出力は、印刷時に[不要なエスケープを避ける |develop#disabling-auto-escaping-of-variable]ため、`Latte\Runtime\Html` オブジェクトとして`$var` 変数に格納される。


その他 .[#toc-others]
==================


`{contentType}`
---------------

タグを使用して、テンプレートが表すコンテンツの種類を指定します。オプションは以下の通りです。

-`html` (デフォルトのタイプ)
-`xml`
-`javascript`
-`css`
-`calendar` (iCal)
-`text`

この機能は,[文脈に応じたエスケープを |safety-first#context-aware-escaping]設定し,Latteが正しくエスケープできるようにするために重要です.例えば、`{contentType xml}` はXMLモードに切り替わり、`{contentType text}` はエスケープを完全にオフにします。

パラメータが`application/xml` のようなフル機能の MIME タイプの場合、ブラウザに HTTP ヘッダ`Content-Type` も送信します。

```latte
{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
	<channel>
		<title>RSS feed</title>
		<item>
			...
		</item>
	</channel>
</rss>
```


`{debugbreak}`
--------------

コードの実行が中断される場所を指定します。プログラマが実行環境を検査し、コードが期待通りに実行されることを確認するためのデバッグ目的で使用されます。[Xdebugに |https://xdebug.org]対応しています。さらに、コードがブレークする条件を指定することができます。

```latte
{debugbreak}                {* breaks the program *}

{debugbreak $counter == 1}  {* breaks the program if the condition is met *}
```


`{do}`
------

PHPコードを実行し、何も表示しません。他のタグと同様に、PHPコードは単一の式です。[PHPの制限を |syntax#PHP Limitations in Latte]参照してください。

```latte
{do $num++}
```


`{dump}`
--------

変数または現在のコンテキストをダンプします。

```latte
{dump $name} {* dumps the $name variable *}

{dump}       {* dumps all the defined variables *}
```

.[caution]
[Tracy |tracy:en] パッケージが必要です。


`{php}`
-------

任意の PHP コードを実行できるようにします。このタグは[RawPhpExtension |develop#RawPhpExtension]エクステンションを使用してアクティブにする必要があります。


`{spaceless}`
-------------

不要な空白を削除する。[スペースレスフィルタと似て |filters#spaceless]いる。

```latte
{spaceless}
	<ul>
		<li>Hello</li>
	</ul>
{/spaceless}
```

出力は

```latte
<ul> <li>Hello</li> </ul>
```

タグは、[n:attributeと |syntax#n:attributes]書くこともできる。


`{syntax}`
----------

ラテタグは中括弧だけで囲む必要はありません。実行時であっても、別のセパレータを選択することができます。これは、`{syntax…}` 、パラメータにすることができます。

- doubleとする。 `{{...}}`
- off: Latteタグを完全に無効にする

n:attributeという記法を用いると、JavaScriptのブロックに対してのみLatteを無効にすることができます。

```latte
<script n:syntax="off">
	var obj = {var: 123}; // this isn't a tag any more
</script>
```

JavaScriptでもLatteは快適に使えますが、この例のように`{`の直後に文字が来るような構成は避けてください、詳しくは[JavaScriptやCSSでのLatteを |recipes#Latte inside JavaScript or CSS]ご覧ください。

`{syntax off}` (つまりn:属性ではなくタグ)でLatteをオフにすると、`{/syntax}` までのタグは厳密に無視されます。


{trace}
-------

`Latte\RuntimeException` 例外をスローします。そのスタックトレースはテンプレートの精神に則っています。したがって、関数やメソッドを呼び出す代わりに、ブロックを呼び出したり、テンプレートを挿入することになります。[Tracyの |tracy:en]ようなスローされた例外を明確に表示するツールを使用すると、渡されたすべての引数を含むコールスタックを明確に見ることができます。


HTMLタグヘルパー .[#toc-html-tag-helpers]
===================================


n:class .[#toc-n-class]
-----------------------

`n:class` のおかげで、必要な HTML 属性`class` を正確に生成することが非常に簡単になりました。

例を挙げましょう。active 要素に`active` というクラスが必要です。

```latte
{foreach $items as $item}
	<a n:class="$item->isActive() ? active">...</a>
{/foreach}
```

さらに、最初の要素に`first` と`main` というクラスを持たせる必要があります。

```latte
{foreach $items as $item}
	<a n:class="$item->isActive() ? active, $iterator->first ? 'first main'">...</a>
{/foreach}
```

そして、すべての要素が`list-item` クラスを持つ必要があります。

```latte
{foreach $items as $item}
	<a n:class="$item->isActive() ? active, $iterator->first ? 'first main', list-item">...</a>
{/foreach}
```

驚くほどシンプルでしょう?


n:attr .[#toc-n-attr]
---------------------

`n:attr` 属性は[n:class |#n:class] と同じエレガンスを持った任意の HTML 属性を生成することができます。

```latte
{foreach $data as $item}
	<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}
```

返された値に応じて、例えば次のように表示します。

```latte
<input type="checkbox">

<input type="checkbox" value="Hello">

<input type="checkbox" value="Hello" checked>
```


n:タグ .[#toc-n-tag]
------------------

`n:tag` 属性は、HTML 要素の名前を動的に変更することができます。

```latte
<h1 n:tag="$heading" class="main">{$title}</h1>
```

もし`$heading === null` 、その `<h1>`タグは変更されずに表示されます。そうでない場合は、要素名を変数の値に変更するので、`$heading === 'h3'` の場合は、次のように書きます。

```latte
<h3 class="main">...</h3>
```

Latteは安全なテンプレートシステムなので、新しいタグ名が有効で、不要な値や悪意のある値が含まれていないことをチェックします。


n:ifcontent .[#toc-n-ifcontent]
-------------------------------

空の HTML 要素、つまり空白しか含まない要素が表示されないようにします。

```latte
<div>
	<div class="error" n:ifcontent>{$error}</div>
</div>
```

変数`$error` の値によって、印刷されます。

```latte
{* $error = '' *}
<div>
</div>

{* $error = 'Required' *}
<div>
	<div class="error">Required</div>
</div>
```


翻訳 .[#toc-translation]
======================

翻訳タグを動作させるには、[トランスレータを |develop#TranslatorExtension]設定する必要があります。また、翻訳用の [`translate` |filters#translate]フィルタを使用して翻訳することもできます。


`{_...}`
--------

値を他の言語に翻訳します。

```latte
<a href="basket">{_'Basket'}</a>
<span>{_$item}</span>
```

他のパラメータもトランスレータに渡すことができます。

```latte
<a href="basket">{_'Basket', domain: order}</a>
```


`{translate}`
-------------

Překládá části šablony:

```latte
<h1>{translate}Order{/translate}</h1>

{translate domain: order}Lorem ipsum .. .{/translate}
```

タグは、要素の内部を翻訳するために、[n:attributeと |syntax#n:attributes]記述することも可能です。

```latte
<h1 n:translate>Order</h1>
```

ラテのタグ

Latte内蔵の全タグの概要と説明。

印刷
{$var},{...} or{=...} エスケープされた変数や式を印刷します。
{$var|filter} フィルタリングして印刷する
{l} または{r} { or } の文字を表示します。
条件
{if}{elseif}{else}{/if} 条件 if
{ifset}{elseifset}{/ifset} 条件 ifset
{ifchanged}{/ifchanged} 変化があったかどうかのテスト
{switch} {case} {default} {/switch} 条件スイッチ
n:elseコンディションの代替コンテンツ  
ループ
{foreach}{/foreach} foreach
{for}{/for} for
{while}{/while} while
{continueIf $cond} 次の反復に進む
{skipIf $cond} 現在のループの反復をスキップする
{breakIf $cond} ループを 中断
{exitIf $cond} 早期終了
{first}{/first} 最初のイテレーションか?
{last}{/last} それは最後の反復ですか?
{sep}{/sep} 次の反復が続くか?
{iterateWhile}{/iterateWhile} 構造化されたforeach
$iterator foreachループ内の特殊変数
他のテンプレートをインクルードする
{include 'file.latte'} 他のファイルからテンプレートをインクルードする
{sandbox 'file.latte'} サンドボックスモードでテンプレートをインクルードする
ブロック、レイアウト、テンプレートの継承
{block} 匿名ブロック
{block blockname} ブロックの定義
{define blockname} 将来使用するブロックの定義
{include blockname} ブロックを印刷する
{include blockname from 'file.latte'} ファイルからのブロックの印刷
{import 'file.latte'} 別のテンプレートからブロックをロードする
{layout 'file.latte'} /{extends} レイアウトファイルの指定
{embed}{/embed} テンプレートまたはブロックをロードし、ブロックを上書きすることができます。
{ifset blockname}{/ifset} ブロックが定義されている場合の条件
例外処理
{try}{else}{/try} 例外をキャッチする
{rollback} トライブロックを破棄する
変数
{var $foo = value} 変数の作成
{default $foo = value} 変数が宣言されていないときのデフォルト値
{parameters} 変数の宣言、デフォルト値のタイプ
{capture}{/capture} セクションを変数に取り込む
タイプ
{varType} 変数のタイプを宣言
{varPrint} 変数の種類を提案する
{templateType} クラスを使った変数の型の宣言
{templatePrint} プロパティを含むクラスを生成
翻訳
{_string} 翻訳された内容を表示する
{translate}{/translate} 内容を 翻訳する
その他
{contentType} エスケープモードを切り替え、HTTPヘッダを送信 します。
{debugbreak} コードにブレークポイントを設定 します。
{do} 式を表示せずに評価 する
{dump} トレイシーバーに変数をダンプ する
{php} 任意のPHPコードを実行する
{spaceless}{/spaceless} 不要な空白を削除する
{syntax} 実行時に構文を切り替えます。
{trace} スタックトレースを表示する
HTMLタグヘルパー
n:class スマートなクラス属性
n:attr スマートなHTML属性
n:tag HTML 要素の動的な名前
n:ifcontent 空の HTML タグを省略する
Nette Framework のみで利用可能
n:href <a> HTML要素内のリンク
{link} リンクを表示する
{plink} プレゼンターへのリンクを表示する
{control} コンポーネントを表示します
{snippet}{/snippet} AJAXで送信可能なテンプレートスニペット
{snippetArea} スニペットの封筒
{cache}{/cache} テンプレートセクションをキャッシュする
Nette Forms のみで利用可能
{form}{/form} フォームエレメントを表示します。
{label}{/label} フォーム入力ラベルを表示します。
{input} フォーム入力要素を表示します。
{inputError} フォーム入力要素のエラーメッセージを表示します。
n:name HTML入力要素をアクティブにする
{formContainer}{/formContainer} フォームコンテナのレンダリング

印刷

{$var} {...} {=...}

Latteでは、{=...} タグを使って、任意の式を出力しています。式の先頭が変数や関数呼び出しの場合、等号を書く必要はありません。つまり、実際には、ほとんど書く必要がないのです。

Name: {$name} {$surname}<br>
Age: {date('Y') - $birth}<br>

PHP で知っていることは何でも式として書くことができます。新しい言語を学ぶ必要がないだけです。例えば

{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}

前の例で意味を探さないでください。もしそこで意味を見つけたら、私たちに書いてください :-)

エスケープ出力

テンプレートシステムの最も重要なタスクは何ですか?セキュリティホールを回避することです。そして、それはまさにLatteが出力に何かを印刷するときに行うことです。それは自動的にすべてをエスケープします。

<p>{='one < two'}</p>   {* prints: '<p>one &lt; two</p>' *}

正確には、Latteは文脈依存のエスケープを行います。これは非常に重要かつユニークな機能なので、別の章を設けて 解説しています。

また、HTMLコード化されたコンテンツを信頼できるところから印刷する場合は?それなら簡単にエスケープをオフにすることができます。

{$trustedHtmlString|noescape}

noescape フィルタを誤用すると、XSS 脆弱性につながる可能性があります!自分が何をしているのか、そして印刷する文字列が信頼できるソースから来たものであることが 絶対に 確実でない限り、決してこれを使用しないでください。

JavaScriptで印刷する

文脈依存のエスケープのおかげで、JavaScriptの内部で変数を印刷するのは驚くほど簡単で、Latteはそれらを適切にエスケープします。

変数は文字列である必要はなく、どんなデータ型にも対応し、JSONとしてエンコードされます。

{var $foo = ['hello', true, 1]}
<script>
	alert({$foo});
</script>

を生成します。

<script>
	alert(["hello", true, 1]);
</script>

これは、変数を引用符で囲まないでくださいという理由でもあります。ラテは文字列を引用符で囲みます。また、文字列の変数を別の文字列に入れたい場合は、単純に連結してください。

<script>
	alert('Hello ' + {$name} + '!');  // OK

	alert({="Hello $name!"});         // OK

	alert('Hello {$name} !');         // ERROR!
</script>

フィルタ

印刷された式は、フィルターによって変更することができます。例えば、この例では文字列を大文字に変換し、最大30文字に短縮しています。

{$string|upper|truncate:30}

また、以下のように式の一部にフィルタを適用することもできます。

{$left . ($middle|upper) . $right}

条件

{if} {elseif} {else}

条件は、PHP の条件と同じように動作します。PHP でおなじみの表現が使えるので、新しい言語を学ぶ必要はありません。

{if $product->inStock > Stock::Minimum}
	In stock
{elseif $product->isOnWay()}
	On the way
{else}
	Not available
{/if}

他のペアタグと同様に、{if} ... {/ if} のペアは、例えばn:attribute のように書くことができます。

<p n:if="$count > 0">In stock {$count} items</p>

n:attributesに接頭辞tag- を付けることができることをご存知でしょうか?この場合、HTMLタグにのみ影響を与え、その間の内容は常に印刷されます。

<a href="..." n:tag-if="$clickable">Hello</a>

{* prints 'Hello' when $clickable is falsey *}
{* prints '<a href="...">Hello</a>' when $clickable is truthy *}

いいですね。

n:else

の条件を{if} ... {/if} n:属性の形で記述した場合、 を使って別の分岐を指定するオプションがある:

n:else`latte In stock {$count} items

not available ` n:else n:ifset, n:foreach, n:try, n:ifcontentおよび n:ifchanged.

{/if $cond}

{if} 条件の式も終了タグで指定できることに驚かれたかもしれません。これは、タグが開かれたときに、まだ条件の値がわからないような場合に便利です。遅延判定とでも言いましょうか。

たとえば、データベースからレコードを取得してテーブルのリストアップを開始し、レポートが完成した後で、データベースにレコードがないことに気がついたとします。そこで、終了タグ{/if} に条件を入れて、レコードがなければ、何も印刷されないようにします。

{if}
	<h1>Printing rows from the database</h1>

	<table>
	{foreach $resultSet as $row}
		...
	{/foreach}
	</table>
{/if isset($row)}

便利でしょう?

繰延条件では{else} も使えますが、{elseif} は使えません。

{ifset} {elseifset}

参照 {ifset block}

変数(あるいは複数の変数)が存在し、かつ非 null 値であるかどうかを調べるには、{ifset $var} 条件を使用します。これは、実際にはPHPのif (isset($var)) と同じです。他のペアタグと同様に、n:attributeの形式で書くことができますので、例で紹介しましょう。

<meta name="robots" content="{$robots}" n:ifset="$robots">

{ifchanged}

{ifchanged} は、ループ(foreach、for、while)内の最後の反復から、変数の値が変化したかどうかをチェックします。

タグの中で1つ以上の変数を指定すると、それらの変数のいずれかが変更されたかどうかをチェックし、それに応じて内容を表示します。たとえば、次の例では、名前をリストアップするときに、変更されるたびに名前の最初の文字を見出しとしてプリントしています。

{foreach ($names|sort) as $name}
	{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}

	<p>{$name}</p>
{/foreach}

しかし、引数が与えられない場合は、レンダリングされた内容そのものが以前の状態と照らし合わされる。つまり、先ほどの例では、タグの引数を省略しても大丈夫ということです。また、もちろんn:attributeを使うこともできます。

{foreach ($names|sort) as $name}
	<h2 n:ifchanged>{$name[0]}</h2>

	<p>{$name}</p>
{/foreach}

の中に{else} 節を入れることもできます。{ifchanged}.

{switch} {case} {default}

値を複数のオプションと比較します。これは、PHPでおなじみのswitch の構造に似ています。しかし、Latteではそれを改良しています。

  • 厳密な比較を行う (===)
  • は必要ありません。break

つまり、PHP 8.0が搭載しているmatch 構造とまったく同じものです。

{switch $transport}
	{case train}
		By train
	{case plane}
		By plane
	{default}
		Differently
{/switch}

{case} は、カンマで区切られた複数の値を含むことができます。

{switch $status}
{case $status::New}<b>new item</b>
{case $status::Sold, $status::Unknown}<i>not available</i>
{/switch}

ループ

Latteでは、PHPでおなじみのforeach、for、whileといったループが利用可能です。

{foreach}

サイクルはPHPと全く同じように書きます。

{foreach $langs as $code => $lang}
	<span>{$lang}</span>
{/foreach}

さらに、これから説明するような便利な調整もあるそうです。

例えば、ラテは作成した変数が誤って同じ名前のグローバル変数を上書きしないようにチェックしています。これは、$lang がそのページの現在の言語であると仮定したときに、foreach $langs as $lang がその変数を上書きしてしまったことに気づかなかったときの救いになります。

foreachループもn:attributeを使えば非常にエレガントかつ経済的に書くことができる。

<ul>
	<li n:foreach="$items as $item">{$item->name}</li>
</ul>

n:attributeの前にinner- というプレフィックスを付けることができることをご存知ですか?これで、ループの中で要素の内側の部分だけが繰り返されるようになります。

<div n:inner-foreach="$items as $item">
	<h4>{$item->title}</h4>
	<p>{$item->description}</p>
</div>

というわけで、次のような感じでプリントされます。

<div>
	<h4>Foo</h4>
	<p>Lorem ipsum.</p>
	<h4>Bar</h4>
	<p>Sit dolor.</p>
</div>

{else}

foreach ループでは、オプションで{else} 節を指定することができ、そのテキストは与えられた配列が空の場合に表示されます。

<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Sorry, no users in this list</em></li>
	{/foreach}
</ul>

$iterator

foreach ループの内部では、変数$iterator が初期化されます。これは、現在のループに関する重要な情報を保持します。

  • $iterator->first – これは最初の反復処理か?
  • $iterator->last – これは最後の反復処理ですか?
  • $iterator->counter – 反復カウンタ、1 から始まる。
  • $iterator->counter0 – 反復カウンタ、0から開始。
  • $iterator->odd – この反復は奇数ですか?
  • $iterator->even – この反復は偶数か?
  • $iterator->parent – 現在のイテレータを囲むイテレータ
  • $iterator->nextValue – ループ内の次のアイテム
  • $iterator->nextKey – ループ内の次のアイテムのキー
{foreach $rows as $row}
	{if $iterator->first}<table>{/if}

	<tr id="row-{$iterator->counter}">
		<td>{$row->name}</td>
		<td>{$row->email}</td>
	</tr>

	{if $iterator->last}</table>{/if}
{/foreach}

ラテは賢く、$iterator->last 配列だけでなく、事前に項目数が分からない一般的なイテレータ上でループを実行する場合にも有効です。

{first} {last} {sep}

これらのタグは、{foreach} のループの中で使用することができます。{first} のコンテンツは、最初のパスでレンダリングされます。 {last} のコンテンツがレンダリングされる......わかるかな?そう、最後のパスです。これらは実は、{if $iterator->first}{if $iterator->last} のショートカットです。

タグはn:attributesと書くこともできる.

{foreach $rows as $row}
	{first}<h1>List of names</h1>{/first}

	<p>{$row->name}</p>

	<hr n:last>
{/foreach}

{sep} の内容は、反復が最後でない場合にレンダリングされるので、リストされた項目の間にカンマなどの区切り文字を印刷するのに適しています。

{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}

かなり実用的ですね。

{iterateWhile}

条件を満たす限りネストしたループで反復処理を行うことで、foreachループでの反復処理中の線形データのグループ化を簡略化します。クックブックの説明をお読みください。

また、上の例の{first}{last} をエレガントに置き換えることができます。

{foreach $rows as $row}
	<table>

	{iterateWhile}
	<tr id="row-{$iterator->counter}">
		<td>{$row->name}</td>
		<td>{$row->email}</td>
	</tr>
	{/iterateWhile true}

	</table>
{/foreach}

{for}

サイクルはPHPと全く同じように書きます。

{for $i = 0; $i < 10; $i++}
	<span>Item #{$i}</span>
{/for}

タグはn:attributeと書くこともできる。

<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>

{while}

ここでも、PHPと全く同じ方法でサイクルを書きます。

{while $row = $result->fetch()}
	<span>{$row->title}</span>
{/while}

あるいはn:attributeのように。

<span n:while="$row = $result->fetch()">
	{$row->title}
</span>

終了タグに条件を指定するバリアントは、PHP の do-while ループに相当します。

{while}
	<span>{$item->title}</span>
{/while $item = $item->getNext()}

{continueIf} {skipIf} {breakIf}

ループを制御するために使用できる特別なタグがあります。{continueIf ?}{breakIf ?} はそれぞれ、条件が満たされた場合に次の反復処理にジャンプし、ループを終了させるものです。

{foreach $rows as $row}
	{continueIf $row->date < $now}
	{breakIf $row->parent === null}
	...
{/foreach}

タグ{skipIf}{continueIf} と非常によく似ていますが、カウンターをインクリメントしません。したがって、$iterator->counter を表示して、いくつかの項目をスキップしても、番号付けに穴が開くことはありません。また、{else}句はすべての項目をスキップするときに表示されます。

<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Sorry, no adult users in this list</em></li>
	{/foreach}
</ul>

{exitIf}

ある条件が満たされたとき、テンプレートまたはブロックのレンダリングを終了します(すなわち、「早期終了」)。

{exitIf !$messages}

<h1>Messages</h1>
<div n:foreach="$messages as $message">
   {$message}
</div>

テンプレートを含む

{include 'file.latte'}

参照 {include block}

{include} タグは、指定されたテンプレートを読み込み、レンダリングします。私たちの大好きなPHP言語では、次のような感じです。

<?php include 'header.phtml'; ?>

インクルードされたテンプレートは、アクティブなコンテキストの変数にはアクセスできませんが、グローバル変数にはアクセスできます。

挿入されたテンプレートには、以下の方法で変数を渡すことができます:

{include 'template.latte', foo: 'bar', id: 123}

テンプレート名には、任意の PHP 式を指定することができます。

{include $someVar}
{include $ajax ? 'ajax.latte' : 'not-ajax.latte'}

挿入される内容は、フィルタを用いて変更することができます。次の例は、すべての HTML を削除し、大文字小文字を調整するものです。

<title>{include 'heading.latte' |stripHtml|capitalize}</title>

テンプレートの継承はデフォルトでは 関与しません。インクルードされたテンプレートにブロックタグを追加することはできますが、インクルードされたテンプレート内のマッチするブロックを置き換えることはありません。インクルードは、ページやモジュールの独立したシールドされた部分だと考えてください。この動作は、修飾子with blocks を使って変更できます:

{include 'template.latte' with blocks}

タグで指定されたファイル名とディスク上のファイルとの関係は、ローダーの問題です。

{sandbox}

エンドユーザーが作成したテンプレートをインクルードする場合、サンドボックス化を検討する必要があります(詳細はサンドボックスのドキュメントを参照してください)。

{sandbox 'untrusted.latte', level: 3, data: $menu}

{block}

こちらもご覧ください {block name}

名前のないブロックは、テンプレートの一部にフィルタを適用する機能を提供します。例えば、ストリップフィルターを適用して不要なスペースを削除することができます。

{block|strip}
<ul>
	<li>Hello World</li>
</ul>
{/block}

例外処理

{try}

このタグを使うと、非常に簡単に堅牢なテンプレートを構築することができます。

{try} ブロックのレンダリング中に例外が発生した場合、ブロック全体がスローされ、その後にレンダリングが続行されます。

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
{/try}

オプションの節{else} の内容は、例外が発生したときだけレンダリングされる。

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Sorry, the tweets could not be loaded.</p>
{/try}

このタグはn:attributeと書くこともできる.

<ul n:try>
	...
</ul>

また、ロギングなどのための例外ハンドラを独自に定義することも可能です。

{rollback}

{try} ブロックは、{rollback} を使って手動で停止したり、スキップしたりすることもできます。そのため、事前にすべての入力データをチェックする必要はなく、レンダリング中にのみ、オブジェクトをレンダリングすることに意味があるかどうかを判断することができます。

{try}
<ul>
	{foreach $people as $person}
 		{skipIf $person->age < 18}
 		<li>{$person->name}</li>
	{else}
		{rollback}
	{/foreach}
</ul>
{/try}

変数

{var} {default}

{var} タグを使用して、テンプレート内に新しい変数を作成することにします。

{var $name = 'John Smith'}
{var $age = 27}

{* Multiple declaration *}
{var $name = 'John Smith', $age = 27}

{default} タグも同様に動作しますが、変数が存在しない場合にのみ変数を作成する点が異なります。

{default $lang = 'cs'}

変数の種類を指定することもできる。今のところ、これらは情報提供であり、ラテはチェックしない。

{var string $name = $article->getTitle()}
{default int $id = 0}

{parameters}

関数がパラメータを宣言するのと同じように,テンプレートもその先頭で変数を宣言することができます.

{parameters
	$a,
	?int $b,
	int|string $c = 10
}

デフォルト値のない変数$a$b は自動的にデフォルト値null を持ちます.宣言された型はまだ参考値であり,Latteはそれをチェックしません.

その他、宣言された変数はテンプレートに渡されません。この点は{default} タグとの違いです。

{capture}

{capture} タグを使用することで、出力を変数に取り込むことができます。

{capture $var}
<ul>
	<li>Hello World</li>
</ul>
{/capture}

<p>Captured: {$var}</p>

このタグは、他のペアタグと同様にn:attributeと書くこともできる:

<ul n:capture="$var">
	<li>Hello World</li>
</ul>

HTML出力は、印刷時に不要なエスケープを避けるため、Latte\Runtime\Html オブジェクトとして$var 変数に格納される。

その他

{contentType}

タグを使用して、テンプレートが表すコンテンツの種類を指定します。オプションは以下の通りです。

  • html (デフォルトのタイプ)
  • xml
  • javascript
  • css
  • calendar (iCal)
  • text

この機能は,文脈に応じたエスケープを設定し,Latteが正しくエスケープできるようにするために重要です.例えば、{contentType xml} はXMLモードに切り替わり、{contentType text} はエスケープを完全にオフにします。

パラメータがapplication/xml のようなフル機能の MIME タイプの場合、ブラウザに HTTP ヘッダContent-Type も送信します。

{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
	<channel>
		<title>RSS feed</title>
		<item>
			...
		</item>
	</channel>
</rss>

{debugbreak}

コードの実行が中断される場所を指定します。プログラマが実行環境を検査し、コードが期待通りに実行されることを確認するためのデバッグ目的で使用されます。Xdebugに対応しています。さらに、コードがブレークする条件を指定することができます。

{debugbreak}                {* breaks the program *}

{debugbreak $counter == 1}  {* breaks the program if the condition is met *}

{do}

PHPコードを実行し、何も表示しません。他のタグと同様に、PHPコードは単一の式です。PHPの制限を参照してください。

{do $num++}

{dump}

変数または現在のコンテキストをダンプします。

{dump $name} {* dumps the $name variable *}

{dump}       {* dumps all the defined variables *}

Tracy パッケージが必要です。

{php}

任意の PHP コードを実行できるようにします。このタグはRawPhpExtensionエクステンションを使用してアクティブにする必要があります。

{spaceless}

不要な空白を削除する。スペースレスフィルタと似ている。

{spaceless}
	<ul>
		<li>Hello</li>
	</ul>
{/spaceless}

出力は

<ul> <li>Hello</li> </ul>

タグは、n:attributeと書くこともできる。

{syntax}

ラテタグは中括弧だけで囲む必要はありません。実行時であっても、別のセパレータを選択することができます。これは、{syntax…} 、パラメータにすることができます。

  • doubleとする。 {{...}}
  • off: Latteタグを完全に無効にする

n:attributeという記法を用いると、JavaScriptのブロックに対してのみLatteを無効にすることができます。

<script n:syntax="off">
	var obj = {var: 123}; // this isn't a tag any more
</script>

JavaScriptでもLatteは快適に使えますが、この例のように{の直後に文字が来るような構成は避けてください、詳しくはJavaScriptやCSSでのLatteをご覧ください。

{syntax off} (つまりn:属性ではなくタグ)でLatteをオフにすると、{/syntax} までのタグは厳密に無視されます。

{trace}

Latte\RuntimeException 例外をスローします。そのスタックトレースはテンプレートの精神に則っています。したがって、関数やメソッドを呼び出す代わりに、ブロックを呼び出したり、テンプレートを挿入することになります。Tracyのようなスローされた例外を明確に表示するツールを使用すると、渡されたすべての引数を含むコールスタックを明確に見ることができます。

HTMLタグヘルパー

n:class

n:class のおかげで、必要な HTML 属性class を正確に生成することが非常に簡単になりました。

例を挙げましょう。active 要素にactive というクラスが必要です。

{foreach $items as $item}
	<a n:class="$item->isActive() ? active">...</a>
{/foreach}

さらに、最初の要素にfirstmain というクラスを持たせる必要があります。

{foreach $items as $item}
	<a n:class="$item->isActive() ? active, $iterator->first ? 'first main'">...</a>
{/foreach}

そして、すべての要素がlist-item クラスを持つ必要があります。

{foreach $items as $item}
	<a n:class="$item->isActive() ? active, $iterator->first ? 'first main', list-item">...</a>
{/foreach}

驚くほどシンプルでしょう?

n:attr

n:attr 属性はn:class と同じエレガンスを持った任意の HTML 属性を生成することができます。

{foreach $data as $item}
	<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}

返された値に応じて、例えば次のように表示します。

<input type="checkbox">

<input type="checkbox" value="Hello">

<input type="checkbox" value="Hello" checked>

n:タグ

n:tag 属性は、HTML 要素の名前を動的に変更することができます。

<h1 n:tag="$heading" class="main">{$title}</h1>

もし$heading === null 、その <h1>タグは変更されずに表示されます。そうでない場合は、要素名を変数の値に変更するので、$heading === 'h3' の場合は、次のように書きます。

<h3 class="main">...</h3>

Latteは安全なテンプレートシステムなので、新しいタグ名が有効で、不要な値や悪意のある値が含まれていないことをチェックします。

n:ifcontent

空の HTML 要素、つまり空白しか含まない要素が表示されないようにします。

<div>
	<div class="error" n:ifcontent>{$error}</div>
</div>

変数$error の値によって、印刷されます。

{* $error = '' *}
<div>
</div>

{* $error = 'Required' *}
<div>
	<div class="error">Required</div>
</div>

翻訳

翻訳タグを動作させるには、トランスレータを設定する必要があります。また、翻訳用の translateフィルタを使用して翻訳することもできます。

{_...}

値を他の言語に翻訳します。

<a href="basket">{_'Basket'}</a>
<span>{_$item}</span>

他のパラメータもトランスレータに渡すことができます。

<a href="basket">{_'Basket', domain: order}</a>

{translate}

Překládá části šablony:

<h1>{translate}Order{/translate}</h1>

{translate domain: order}Lorem ipsum .. .{/translate}

タグは、要素の内部を翻訳するために、n:attributeと記述することも可能です。

<h1 n:translate>Order</h1>