Latte 2.10 a novinka {iterateWhile}

Přidal jsem do Latte značku s pracovním názvem {iterateWhile} (původní název byl innerForeach, post jsem pak upravil). Hodí se na různé chytrystyky ve foreach cyklech.

Máme takovouto tabulku položek:

id	catId	name
1	1	Lorem
2	1	ipsum
3	2	dolor
4	3	sit
5	3	amet
6	3	consectetuer

Budu je vykreslovat v cyklu foreach, ale chtěl bych, aby každá kategorie byla v samostatné tabulce.

Tohle se dá řešit v různých šablonovacích systémem (dosaďte si jakýkoliv) zhruba tímto způsobem:

{var $prevCatId = null}
{foreach $items as $item}
	{if $item->catId !== $prevCatId}
		{* uzavřeme minulou kategorii *}
		{if $prevCatId !== null}
			</tbody>
		</table>
		{/if}

		{* otevřeme novou kategorii *}
		{do $prevCatId = $item->catId}
		<table>
			<thead>...</thead>
			<tbody>
	{/if}

	<tr>
		<td>{$item->name}
	</tr>
{/foreach}

{if $prevCatId !== null}  {* uzavřeme poslední kategorii *}
		</tbody>
	</table>
{/if}
</table>

Latte má výhodu v tom, že jeho $iterator zná následující položku, takže se dá odstranit duplicitní uzavírání tabulky a výsledek vypadá srozumitelněji.

{var $prevCatId = null}
{foreach $items as $item}
    {* otevřeme novou kategorii *}
	{if $item->catId !== $prevCatId}
		{do $prevCatId = $item->catId}
		<table>
			<thead>...</thead>
			<tbody>
	{/if}

	<tr>
		<td>{$item->name}
	</tr>

    {* uzavřeme minulou kategorii *}
	{if !$iterator->hasNext() || $iterator->nextValue->catId !== $item->catId}
			</tbody>
		</table>
	{/if}
{/foreach}

Ale stále nevypadá tak, abych s tím byl spokojen :)

Vzniká tu nerovnovážná situace, kdy se HTML značky otevírají v bloku podmínky {if}, ale zavírají se v jiném bloku. Kvůli tomu nepůjde ani ve značce <table> používat n:atributy. Celkově to nepůsobí moc blbuvzdorně.

{iterateWhile}

Pomocí iterateWhile můžeme nechat iteraci probíhat po určitou dobu (např. dokud je stejná kategorie) ve vnitřním cyklu:

{foreach $items as $item}
    {* otevřeme novou kategorii *}
	<table>
		<thead>...</thead>
		<tbody>

		{iterateWhile}
			<tr>
				<td>{$item->name}
			</tr>
		{/iterateWhile $iterator->nextValue->catId === $item->catId}

	    {* uzavřeme minulou kategorii *}
		</tbody>
	</table>
{/foreach}

Nepotřebujeme žádné pomocné proměnné jako $prevCatId, není tu nerovnováha v podobě otevíracích značek v jiném bloku než jsou uzavírací, hezky sedí odsazení, je to blbuvzdorné.

Samozřejmě je potřeba se naučit tento zápis číst, bez toho může vypadat komplikovaně. Možná by pomohl i lepší název než iterateWhile, napadá vás?

Pokud uvedeme podmínku v otevírací značce {iterateWhile}, tak se chování mění obdobně jako v cyklech do {} while a while {}. Tedy podmínka (a přechod na další prvek) se vykoná na začátku inner cyklu. Zatímco do {iterateWhile} se vstoupí vždy, do {iterateWhile $cond} jen při splnění podmínky a $item se mění.

Takže v tomto příkladě se první položka kategorie vykreslí uvnitř <thead> a další až v <tbody>:

{foreach $items as $item}
    {* otevřeme novou kategorii *}
	<table>
		<thead>
			<tr>
				<td>{$item->name}
			</tr>
		</thead>
		<tbody>

		{* pokracujeme následujícím prvek pokud je ve stejné kategorii *}
		{iterateWhile $iterator->nextValue->catId === $item->catId}
			<tr>
				<td>{$item->name}
			</tr>
		{/iterateWhile}

	    {* uzavřeme minulou kategorii *}
		</tbody>
	</table>
{/foreach}

Aby se v případě jediného prvku v kategorii nevypsalo prázdné <tbody></tbody>, lze mu doplnit podmínku do n:if.

Také je možné podmínku vůbec neuvádět. Začíná se tedy značkou {foreach}, pak celý cyklus proběhne v {iterateWhile} ... {/iterateWhile}, pak se pokračuje k {/foreach} a konec.

{foreach $items as $item}
	<table>
		<thead>...{$item->name}...</thead>
		<tbody>

		{iterateWhile}
			<tr>
				<td>{$item->name}
			</tr>
		{/iterateWhile}

		</tbody>
	</table>
{/foreach}

Jak se to liší od toho, že bychom použili uvnitř rovnou {foreach}? Jednak tím, že pokud je pole $items prázdné, nevykreslí se tabulka. A dále $item s prvním prvek máme k dispozici už dříve, viz <thead>

Vnořené smyčky

V rámci jednoho cyklu můžeme vytvářet více inner-smyček a dokonce je zanořovat. Takže by se daly ohraničit třeba podkategorie atd.

Představme si, že v tabulce je ještě sloupec subCatId. Každá kategorie bude v samostatném <table>, každá podkategorie v samostatném <tbody>:

{foreach $items as $item}
	<table>
		{iterateWhile}
			<tbody>
				{iterateWhile}
					<tr>
						<td>{$item->name}
					</tr>
				{/iterateWhile $iterator->nextValue->subCatId === $item->subCatId}
			</tbody>
		{/iterateWhile $iterator->nextValue->catId === $item->catId}
	</table>
{/foreach}

Filtr |batch

Seskupování lineárních položek řeší i filtr batch, který je spojuje po určitém počtu:

<table>
{foreach ($items|batch:3) as $row}
    <tr>
        {foreach $row as $column}
            <td>{$column}</td>
        {/foreach}
    </tr>
{/foreach}
</table>

Lze jej nahradit za iterateWhile tímto způsobem:

<table>
{foreach $items as $item}
    <tr>
        {iterateWhile}
            <td>{$item}</td>
        {/iterateWhile $iterator->counter0 % 3}
    </tr>
{/foreach}
</table>

Rozdíl je opět v tom, že $item s prvním prvek máme k dispozici vně vnitřního cyklu, na rozdíl od $column.