Funções do Latte
****************

.[perex]
Além das funções comuns do PHP, você também pode usá-las em modelos.

.[table-latte-filters]
| `clamp` | [valor dos grampos para a faixa |#clamp]
| `divisibleBy`| [verifica se uma variável é divisível por um número |#divisibleBy]
| `even` | [verifica se o número dado é igual |#even]
| `first` | [devolve o primeiro elemento de matriz ou caráter de cadeia |#first]
| `group` | [agrupa dados de acordo com vários critérios |#group]
| `hasBlock` | [detecta a existência de um bloco |#hasBlock]
| `last` | [retorna o último elemento de matriz ou caráter de cadeia |#last]
| `odd` | [verifica se o número dado é ímpar |#odd]
| `slice` | [extrai uma fatia de uma matriz ou um fio |#slice]


Utilização .[#toc-usage]
========================

As funções são usadas da mesma forma que as funções comuns do PHP e podem ser usadas em todas as expressões:

```latte
<p>{clamp($num, 1, 100)}</p>

{if odd($num)} ... {/if}
```

[As funções personalizadas |extending-latte#functions] podem ser registradas desta forma:

```php
$latte = new Latte\Engine;
$latte->addFunction('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len));
```

Usamo-lo em um modelo como este:

```latte
<p>{shortify($text)}</p>
<p>{shortify($text, 100)}</p>
```


Funções .[#toc-functions]
=========================


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Retorna o valor fixado para a faixa inclusiva de min e max.

```latte
{=clamp($level, 0, 255)}
```

Veja também a [braçadeira do filtro |filters#clamp]:


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Verifica se uma variável é divisível por um número.

```latte
{if divisibleBy($num, 5)} ... {/if}
```


even(int $value): bool .[method]
--------------------------------
Verifica se o número dado é igual.

```latte
{if even($num)} ... {/if}
```


first(string|iterable $value): mixed .[method]
----------------------------------------------
Devolve o primeiro elemento de matriz ou caráter de corda:

```latte
{=first([1, 2, 3, 4])}    {* resultados 1 *}
{=first('abcd')}          {* resultados 'a' *}
```

Ver também [por último |#last], [filtrar primeiro |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Essa função agrupa dados de acordo com diferentes critérios.

Neste exemplo, as linhas da tabela são agrupadas pela coluna `categoryId`. O resultado é uma matriz de campos em que a chave é o valor da coluna `categoryId`. Leia as [instruções detalhadas |cookbook/grouping].

```latte
{foreach group($items, categoryId) as $categoryId => $categoryItems}
    <ul>
        {foreach $categoryItems as $item}
            <li>{$item->name}</li>
        {/foreach}
    </ul>
{/foreach}
```

Consulte também [grupo de |filters#group] filtros.


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Verifica se o bloco com o nome especificado existe:

```latte
{if hasBlock(header)} ... {/if}
```

Consulte também [verificação de existência de bloco |template-inheritance#Checking Block Existence].


last(string|array $value): mixed .[method]
------------------------------------------
Retorna o último elemento de matriz ou caráter de corda:

```latte
{=last([1, 2, 3, 4])}    {* saídas 4 *}
{=last('abcd')}          {* saídas 'd' *}
```

Ver também [primeiro |#first], [filtrar por último |filters#last].


odd(int $value): bool .[method]
-------------------------------
Verifica se o número dado é estranho.

```latte
{if odd($num)} ... {/if}
```


slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Extrai uma fatia de uma matriz ou um fio.

```latte
{=slice('hello', 1, 2)}           {* resultados 'el' *}
{=slice(['a', 'b', 'c'], 1, 2)}   {* resultados ['b', 'c'] *}
```

O filtro de fatias funciona como a função PHP `array_slice` para arrays e `mb_substr` para strings com um fallback para `iconv_substr` no modo UTF-8.

Se o início for não negativo, a seqüência começará nesse início na variável. Se o início for negativo, a seqüência começará tão longe do final da variável.

Se o comprimento for dado e for positivo, então a seqüência terá até muitos elementos nele. Se a variável for menor do que o comprimento, então somente os elementos variáveis disponíveis estarão presentes. Se o comprimento for dado e for negativo, então a seqüência interromperá que muitos elementos do final da variável. Se for omitido, então a seqüência terá tudo desde o offset até o final da variável.

O filtro reordenará e redefinirá as chaves da matriz inteira por padrão. Este comportamento pode ser alterado ajustando preserveKeys para true. As chaves de string são sempre preservadas, independentemente deste parâmetro.