Nette Documentation Preview

syntax 
Változók átadása sablonok között
********************************

Ez az útmutató elmagyarázza, hogyan adódnak át a változók a sablonok között a Latte-ban különböző tagek, mint például `{include}`, `{import}`, `{embed}`, `{layout}`, `{sandbox}` és mások segítségével. Megtudhatod azt is, hogyan dolgozz a változókkal a `{block}` és `{define}` tagekben, és mire szolgál a `{parameters}` tag.


Változók típusai
----------------
A Latte változóit három kategóriába sorolhatjuk attól függően, hogyan és hol vannak definiálva:

**Bemeneti változók** azok, amelyeket kívülről adnak át a sablonnak, például egy PHP szkriptből vagy egy tag, mint például `{include}` segítségével.

```php
$latte->render('template.latte', ['userName' => 'Jan', 'userAge' => 30]);
```

**Környezeti változók** azok a változók, amelyek egy adott tag helyén léteznek. Tartalmazzák az összes bemeneti változót és más, tagek, mint például `{var}`, `{default}` vagy a `{foreach}` ciklus keretében létrehozott változókat.

```latte
{foreach $users as $user}
	{include 'userBox.latte', user: $user}
{/foreach}
```

**Explicit változók** azok, amelyeket közvetlenül a tagben specifikálnak, és a cél sablonnak küldenek.

```latte
{include 'userBox.latte', name: $user->name, age: $user->age}
```


`{block}`
---------
A `{block}` tag újra felhasználható kódblokkok definiálására szolgál, amelyeket az öröklődő sablonokban testre lehet szabni vagy bővíteni. A blokk előtt definiált környezeti változók elérhetők a blokkon belül, de a változók bármilyen módosítása csak a blokkon belül érvényesül.

```latte
{var $foo = 'eredeti'}
{block example}
	{var $foo = 'megváltozott'}
{/block}

{$foo}    // kiírja: eredeti
```


`{define}`
----------
A `{define}` tag olyan blokkok létrehozására szolgál, amelyek csak akkor renderelődnek, amikor a `{include}` segítségével meghívják őket. Az ezekben a blokkokban elérhető változók attól függnek, hogy a definícióban meg vannak-e adva paraméterek. Ha igen, csak ezekhez a paraméterekhez férnek hozzá. Ha nem, akkor hozzáférnek a sablon összes bemeneti változójához, amelyben a blokkok definiálva vannak.

```latte
{define hello}
	{* hozzáfér a sablon összes bemeneti változójához *}
{/define}

{define hello $name}
	{* csak a $name paraméterhez fér hozzá *}
{/define}
```


`{parameters}`
--------------
A `{parameters}` tag a várt bemeneti változók explicit deklarálására szolgál a sablon elején. Ezzel a módszerrel könnyen dokumentálhatók a várt változók és azok adattípusai. Lehetőség van alapértelmezett értékek definiálására is.

```latte
{parameters int $age, string $name = 'ismeretlen'}
<p>Kor: {$age}, Név: {$name}</p>
```


`{include file}`
----------------
A `{include file}` tag egy teljes sablon beillesztésére szolgál. Ennek a sablonnak átadódnak mind a sablon bemeneti változói, amelyben a tagot használják, mind a benne expliciten definiált változók. A cél sablon azonban korlátozhatja a hatókört a `{parameters}` segítségével.

```latte
{include 'profile.latte', userId: $user->id}
```


`{include block}`
-----------------
Amikor egy ugyanabban a sablonban definiált blokkot illesztesz be, átadódnak neki az összes környezeti és expliciten definiált változó:

```latte
{define blockName}
	<p>Név: {$name}, Kor: {$age}</p>
{/define}

{var $name = 'Jan', $age = 30}
{include blockName}
```

Ebben a példában a `$name` és `$age` változók átadódnak a `blockName` blokknak. Ugyanígy viselkedik a `{include parent}` is.

Amikor egy másik sablonból származó blokkot illesztesz be, csak a bemeneti és az expliciten definiált változók adódnak át. A környezeti változók nem érhetők el automatikusan.

```latte
{include blockInOtherTemplate, name: $name, age: $age}
```


`{layout}` vagy `{extends}`
---------------------------
Ezek a tagek definiálják a layoutot, amelynek átadódnak az alárendelt sablon bemeneti változói, valamint a kódblokkok előtt létrehozott változók:

```latte
{layout 'layout.latte'}
{var $seo = 'index, follow'}
```

A `layout.latte` sablon:

```latte
<head>
	<meta name="robots" content="{$seo}">
</head>
```


`{embed}`
---------
A `{embed}` tag hasonló a `{include}` taghez, de lehetővé teszi blokkok beágyazását a sablonba. Ellentétben a `{include}`-dal, csak az expliciten deklarált változók adódnak át:

```latte
{embed 'menu.latte', items: $menuItems}
{/embed}
```

Ebben a példában a `menu.latte` sablon csak az `$items` változóhoz fér hozzá.

Ezzel szemben a `{embed}` belüli blokkokban hozzáférés van az összes környezeti változóhoz:

```latte
{var $name = 'Jan'}
{embed 'menu.latte', items: $menuItems}
	{block foo}
		{$nam}
	{/block}
{/embed}
```


`{import}`
----------
A `{import}` tag más sablonokból származó blokkok betöltésére szolgál. Mind a bemeneti, mind az expliciten deklarált változók átadódnak az importált blokkoknak.

```latte
{import 'buttons.latte'}
```


`{sandbox}`
-----------
A `{sandbox}` tag izolálja a sablont a biztonságos feldolgozáshoz. A változók kizárólag expliciten adódnak át.

```latte
{sandbox 'secure.latte', data: $secureData}
```


{{leftbar: /@left-menu}}

Változók átadása sablonok között

Ez az útmutató elmagyarázza, hogyan adódnak át a változók a sablonok között a Latte-ban különböző tagek, mint például {include}, {import}, {embed}, {layout}, {sandbox} és mások segítségével. Megtudhatod azt is, hogyan dolgozz a változókkal a {block} és {define} tagekben, és mire szolgál a {parameters} tag.

Változók típusai

A Latte változóit három kategóriába sorolhatjuk attól függően, hogyan és hol vannak definiálva:

Bemeneti változók azok, amelyeket kívülről adnak át a sablonnak, például egy PHP szkriptből vagy egy tag, mint például {include} segítségével.

$latte->render('template.latte', ['userName' => 'Jan', 'userAge' => 30]);

Környezeti változók azok a változók, amelyek egy adott tag helyén léteznek. Tartalmazzák az összes bemeneti változót és más, tagek, mint például {var}, {default} vagy a {foreach} ciklus keretében létrehozott változókat.

{foreach $users as $user}
	{include 'userBox.latte', user: $user}
{/foreach}

Explicit változók azok, amelyeket közvetlenül a tagben specifikálnak, és a cél sablonnak küldenek.

{include 'userBox.latte', name: $user->name, age: $user->age}

{block}

A {block} tag újra felhasználható kódblokkok definiálására szolgál, amelyeket az öröklődő sablonokban testre lehet szabni vagy bővíteni. A blokk előtt definiált környezeti változók elérhetők a blokkon belül, de a változók bármilyen módosítása csak a blokkon belül érvényesül.

{var $foo = 'eredeti'}
{block example}
	{var $foo = 'megváltozott'}
{/block}

{$foo}    // kiírja: eredeti

{define}

A {define} tag olyan blokkok létrehozására szolgál, amelyek csak akkor renderelődnek, amikor a {include} segítségével meghívják őket. Az ezekben a blokkokban elérhető változók attól függnek, hogy a definícióban meg vannak-e adva paraméterek. Ha igen, csak ezekhez a paraméterekhez férnek hozzá. Ha nem, akkor hozzáférnek a sablon összes bemeneti változójához, amelyben a blokkok definiálva vannak.

{define hello}
	{* hozzáfér a sablon összes bemeneti változójához *}
{/define}

{define hello $name}
	{* csak a $name paraméterhez fér hozzá *}
{/define}

{parameters}

A {parameters} tag a várt bemeneti változók explicit deklarálására szolgál a sablon elején. Ezzel a módszerrel könnyen dokumentálhatók a várt változók és azok adattípusai. Lehetőség van alapértelmezett értékek definiálására is.

{parameters int $age, string $name = 'ismeretlen'}
<p>Kor: {$age}, Név: {$name}</p>

{include file}

A {include file} tag egy teljes sablon beillesztésére szolgál. Ennek a sablonnak átadódnak mind a sablon bemeneti változói, amelyben a tagot használják, mind a benne expliciten definiált változók. A cél sablon azonban korlátozhatja a hatókört a {parameters} segítségével.

{include 'profile.latte', userId: $user->id}

{include block}

Amikor egy ugyanabban a sablonban definiált blokkot illesztesz be, átadódnak neki az összes környezeti és expliciten definiált változó:

{define blockName}
	<p>Név: {$name}, Kor: {$age}</p>
{/define}

{var $name = 'Jan', $age = 30}
{include blockName}

Ebben a példában a $name és $age változók átadódnak a blockName blokknak. Ugyanígy viselkedik a {include parent} is.

Amikor egy másik sablonból származó blokkot illesztesz be, csak a bemeneti és az expliciten definiált változók adódnak át. A környezeti változók nem érhetők el automatikusan.

{include blockInOtherTemplate, name: $name, age: $age}

{layout} vagy {extends}

Ezek a tagek definiálják a layoutot, amelynek átadódnak az alárendelt sablon bemeneti változói, valamint a kódblokkok előtt létrehozott változók:

{layout 'layout.latte'}
{var $seo = 'index, follow'}

A layout.latte sablon:

<head>
	<meta name="robots" content="{$seo}">
</head>

{embed}

A {embed} tag hasonló a {include} taghez, de lehetővé teszi blokkok beágyazását a sablonba. Ellentétben a {include}-dal, csak az expliciten deklarált változók adódnak át:

{embed 'menu.latte', items: $menuItems}
{/embed}

Ebben a példában a menu.latte sablon csak az $items változóhoz fér hozzá.

Ezzel szemben a {embed} belüli blokkokban hozzáférés van az összes környezeti változóhoz:

{var $name = 'Jan'}
{embed 'menu.latte', items: $menuItems}
	{block foo}
		{$nam}
	{/block}
{/embed}

{import}

A {import} tag más sablonokból származó blokkok betöltésére szolgál. Mind a bemeneti, mind az expliciten deklarált változók átadódnak az importált blokkoknak.

{import 'buttons.latte'}

{sandbox}

A {sandbox} tag izolálja a sablont a biztonságos feldolgozáshoz. A változók kizárólag expliciten adódnak át.

{sandbox 'secure.latte', data: $secureData}