Latte filtreleri
****************

.[perex]
Şablonlarda, veriyi son biçimine dönüştürmeye ya da yeniden biçimlendirmeye yardım eden fonksiyonlar kullanabiliriz. Onlara *filtre* diyoruz.

.[table-latte-filters]
|## Dönüştürme
| `batch`      | [doğrusal veriyi tablo halinde listeler |#batch]
| `breakLines` | [tüm satır sonlarının önüne HTML satır sonu ekler |#breakLines]
| `bytes`      | [boyutu bayt cinsinden biçimlendirir |#bytes]
| `clamp`      | [bir değeri verilen aralığa sıkıştırır |#clamp]
| `column`     | [bir diziden tek bir sütunu çıkarır |#column]
| `commas`     | [bir diziyi virgüllerle birleştirir |#commas]
| `limit`      | [bir dizinin, dizenin veya yineleyicinin uzunluğunu sınırlar |#limit]
| `dataStream` | [Data URI protokolüne dönüştürme |#dataStream]
| `date`       | [tarihi ve saati biçimlendirir |#date]
| `explode`    | [bir dizeyi ayırıcıya göre diziye böler |#explode]
| `filter`     | [yinelenebilir öğeleri bir yükleme göre süzer |#filter]
| `first`      | [bir dizinin ilk öğesini veya bir dizenin ilk karakterini döndürür |#first]
| `group`      | [veriyi çeşitli ölçütlere göre gruplar |#group]
| `implode`    | [bir diziyi dizeye birleştirir |#implode]
| `indent`     | [metni soldan verilen sayıda tabulatör kadar girintiler |#indent]
| `join`       | [bir diziyi dizeye birleştirir |#implode]
| `last`       | [bir dizinin son öğesini veya bir dizenin son karakterini döndürür |#last]
| `length`     | [bir dizenin veya dizinin uzunluğunu döndürür |#length]
| `localDate`  | [tarihi ve saati yerel ayara göre biçimlendirir |#localDate]
| `map`        | [her öğeye bir callback uygular |#map]
| `number`     | [bir sayıyı biçimlendirir |#number]
| `padLeft`    | [bir dizeyi soldan belirli bir uzunluğa doldurur |#padLeft]
| `padRight`   | [bir dizeyi sağdan belirli bir uzunluğa doldurur |#padRight]
| `random`     | [bir dizinin rastgele öğesini veya bir dizenin rastgele karakterini döndürür |#random]
| `repeat`     | [bir dizeyi yineler |#repeat]
| `replace`    | [arama dizesinin geçişlerini değiştirir |#replace]
| `replaceRE`  | [düzenli ifadeye göre geçişleri değiştirir |#replaceRE]
| `reverse`    | [bir UTF‑8 dizesini veya diziyi ters çevirir |#reverse]
| `slice`      | [bir dizinin veya dizenin bir dilimini çıkarır |#slice]
| `sort`       | [bir diziyi sıralar |#sort]
| `spaceless`  | [boşlukları kaldırır |#spaceless], [spaceless |tags] etiketine benzer
| `split`      | [bir dizeyi ayırıcıya göre diziye böler |#explode]
| `strip`      | [boşlukları kaldırır |#spaceless], `spaceless` için kullanımdan kaldırılmış takma ad
| `stripHtml`  | [HTML etiketlerini kaldırır ve HTML varlıklarını karaktere çevirir |#stripHtml]
| `substr`     | [bir dizenin bir bölümünü döndürür |#substr]
| `trim`       | [baştaki ve sondaki boşlukları veya başka karakterleri kırpar |#trim]
| `translate`  | [başka dillere çeviri |#translate]
| `truncate`   | [uzunluğu, tam sözcükleri koruyarak kısaltır |#truncate]
| `webalize`   | [bir UTF‑8 dizesini URL'lerde kullanılan biçime uyarlar |#webalize]

.[table-latte-filters]
|## Harf durumu
| `capitalize` | [küçük harf, her sözcüğün ilk harfi büyük |#capitalize]
| `firstLower` | [ilk harfi küçük harfe çevirir |#firstLower]
| `firstUpper` | [ilk harfi büyük harfe çevirir |#firstUpper]
| `lower`      | [küçük harfe çevirir |#lower]
| `upper`      | [büyük harfe çevirir |#upper]

.[table-latte-filters]
|## Yuvarlama
| `ceil`       | [bir sayıyı verilen duyarlıkta yukarı yuvarlar |#ceil]
| `floor`      | [bir sayıyı verilen duyarlıkta aşağı yuvarlar |#floor]
| `round`      | [bir sayıyı verilen duyarlıkta yuvarlar |#round]

.[table-latte-filters]
|## HTML nitelikleri
| `accept`     | [akıllı niteliklerin yeni davranışını kabul eder |#accept]
| `toggle`     | [bir HTML niteliğinin varlığını açıp kapatır |#toggle]

.[table-latte-filters]
|## Kaçış
| `escapeUrl`  | [bir URL'deki parametreyi kaçırır |#escapeUrl]
| `noescape`   | [bir değişkeni kaçırmadan yazdırır |#noescape]
| `query`      | [bir URL'de sorgu dizesi üretir |#query]

Ayrıca HTML (`escapeHtml` ve `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) ve iCalendar (`escapeICal`) için de kaçış filtreleri vardır; Latte, [bağlama duyarlı kaçış |safety-first#Bağlama duyarlı kaçış] sayesinde onları kendisi kullanır ve sizin yazmanıza gerek yoktur.

.[table-latte-filters]
|## Güvenlik
| `checkUrl`   | [bir URL adresini tehlikeli girdilerden arındırır |#checkUrl]
| `nocheck`    | [otomatik URL arındırmasını engeller |#nocheck]

Latte, `src` ve `href` niteliklerini [otomatik denetler |safety-first#Bağlantı denetimi], bu yüzden `checkUrl` filtresini kullanmanız neredeyse hiç gerekmez.


.[note]
Yerleşik tüm filtreler UTF‑8 kodlamalı dizeler için tasarlanmıştır.


Kullanım
========

Filtreler boru simgesinden sonra yazılır (önünde boşluğa izin verilir):

```latte
<h1>{$heading|upper}</h1>
```

Filtreler zincirlenebilir ve soldan sağa sırayla uygulanırlar:

```latte
<h1>{$heading|lower|capitalize}</h1>
```

Parametreler, filtre adından sonra iki nokta üst üste veya virgülle ayrılarak girilir:

```latte
<h1>{$heading|truncate:20,''}</h1>
```

Filtreler bir ifadeye de uygulanabilir:

```latte
{var $name = ($title|upper) . ($subtitle|lower)}
```

[Özel filtreler|custom-filters] şöyle kaydedilebilir:

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

Şablonda ise şöyle çağrılır:

```latte
<p>{$text|shortify}</p>
<p>{$text|shortify:100}</p>
```


Nullsafe filtreler .{data-version:3.1.0}
----------------------------------------

Herhangi bir filtre, `|` yerine `?|` kullanılarak nullsafe yapılabilir. Değer `null` ise filtre çalıştırılmaz ve `null` döndürülür. Zincirdeki sonraki filtreler de atlanır.

Bu, değer `null` ise atlanan HTML nitelikleriyle birlikte kullanışlıdır.

```latte
<div title={$title?|upper}>
{* $title null ise: <div> *}
{* $title 'hello' ise: <div title="HELLO"> *}
```


Filtreler
=========


accept .[filter]{data-version:3.1.0}
------------------------------------
Filtre, [Latte 3.0'dan geçiş|cookbook/migration-from-latte-30] sırasında, nitelik davranışı değişikliğini gözden geçirdiğinizi ve kabul ettiğinizi onaylamak için kullanılır. Değeri değiştirmez.

Bu geçici bir araçtır. Geçiş tamamlandığında ve geçiş uyarıları kapatıldığında bu filtreyi şablonlarınızdan kaldırmalısınız.


batch(int $length, mixed $rest=null): Generator .[filter]
---------------------------------------------------------
Doğrusal veriyi tablo biçiminde listelemeyi kolaylaştıran bir filtre. Belirtilen sayıda öğe içeren dizilerin bir generator'ını döndürür. İkinci bir parametre verirseniz, son satırdaki eksik öğeleri doldurmak için kullanılır.

```latte
{var $items = ['a', 'b', 'c', 'd', 'e']}
<table>
{foreach ($items|batch: 3, 'No item') as $row}
	<tr>
		{foreach $row as $column}
			<td>{$column}</td>
		{/foreach}
	</tr>
{/foreach}
</table>
```

Şunu üretir:

```latte
<table>
	<tr>
		<td>a</td>
		<td>b</td>
		<td>c</td>
	</tr>
	<tr>
		<td>d</td>
		<td>e</td>
		<td>No item</td>
	</tr>
</table>
```

Ayrıca bkz. [#group] ve [iterateWhile |tags#{iterateWhile}] etiketi.


breakLines .[filter]
--------------------
Her satır sonu karakterinin önüne bir HTML `<br>` etiketi ekler.

```latte
{var $s = "Text & with \n newline"}
{$s|breakLines}    {* "Text &amp; with <br>\n newline" yazdırır *}
```


bytes(int $precision=2) .[filter]
---------------------------------
Bayt cinsinden boyutu insanın okuyabileceği biçime çevirir. [Yerel ayar |develop#Yerel ayar] belirlenmişse, ona karşılık gelen ondalık ve binlik ayırıcılar kullanılır.

```latte
{$size|bytes}     {* 0 B, 1.25 GB, … *}
{$size|bytes:0}   {* 10 B, 1 GB, … *}
```


ceil(int $precision=0) .[filter]
--------------------------------
Bir sayıyı verilen duyarlıkta yukarı yuvarlar.

```latte
{=3.4|ceil}         {* 4 yazdırır      *}
{=135.22|ceil:1}    {* 135.3 yazdırır  *}
{=135.22|ceil:3}    {* 135.22 yazdırır *}
```

Ayrıca bkz. [#floor], [#round].


capitalize .[filter]
--------------------
Sözcükler büyük harfle başlar, kalan tüm karakterler küçük harf olur. PHP `mbstring` uzantısını gerektirir.

```latte
{='i like LATTE'|capitalize}  {* 'I Like Latte' yazdırır *}
```

Ayrıca bkz. [#firstLower], [#firstUpper], [#lower], [#upper].


checkUrl .[filter]
------------------
URL arındırmasını zorunlu kılar. URL'nin güvenli bir şema (`http`, `https`, `ftp`, `mailto`, `tel`, `sms`) kullanıp kullanmadığını ya da göreli bir bağlantı olup olmadığını denetler ve güvenlik riski oluşturabilecek `javascript:` gibi tehlikeli şemaları engeller.

```latte
{var $link = 'javascript:window.close()'}
<a data-href={$link|checkUrl}>checked</a>
<a data-href={$link}>unchecked</a>
```

Şunu üretir:

```latte
<a data-href="">checked</a>
<a data-href="javascript:window.close()">unchecked</a>
```

Ayrıca bkz. [#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Bir değeri, min ve max ile verilen kapsayıcı aralığa sıkıştırır.

```latte
{$level|clamp: 0, 255}
```

[Fonksiyon |functions#clamp()] olarak da vardır.


column(string|int|null $columnKey, string|int|null $indexKey=null) .[filter]{data-version:3.1.3}
------------------------------------------------------------------------------------------------
Çok boyutlu bir diziden tek bir `$columnKey` sütununun değerlerini yeni bir dizi olarak döndürür. Özellik değerlerini çıkarmak için nesne dizilerinde de kullanılabilir.

```latte
{var $users = [
	[id: 30, name: 'John', age: 30],
	[id: 32, name: 'Jane', age: 25],
	[id: 33, age: 35],
]}

{$users|column: 'name'}
{* ['John', 'Jane'] döndürür *}

{$users|column: 'name', 'id'}
{* [30 => 'John', 32 => 'Jane'] döndürür *}
```

Sütun anahtarı olarak `null` verirseniz, diziyi `$indexKey`'e göre yeniden indeksler.


commas(?string $lastGlue=null) .[filter]{data-version:3.1.3}
------------------------------------------------------------
Dizi öğelerini virgül ve boşlukla (`', '`) birleştirir. Öğeleri insanın okuyabileceği biçimde listelemek için kullanışlı bir kısayol.

```latte
{var $items = ['apples', 'oranges', 'bananas']}
{$items|commas}
{* 'apples, oranges, bananas' yazdırır *}
```

Son öğe çifti için kendi ayırıcınızı da verebilirsiniz:

```latte
{$items|commas: ' and '}
{* 'apples, oranges and bananas' yazdırır *}

{=['PHP', 'JavaScript', 'Python']|commas: ', or '}
{* 'PHP, JavaScript, or Python' yazdırır *}
```

Ayrıca bkz. [#implode].


dataStream(?string $type=null) .[filter]
----------------------------------------
İçeriği data URI şemasına dönüştürür. Bu, dış dosyalara bağlantı vermeye gerek kalmadan görselleri HTML'e veya CSS'e gömmeyi sağlar. `$type` `null` ise MIME tipi otomatik saptanır.

`$img = Image::fromFile('image.gif')` değişkeninde bir görselimiz olsun, o zaman

```latte
<img src={$img|dataStream}>
```

Örneğin şunu üretir:

```latte
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
9TXL0Y4OHwAAAABJRU5ErkJggg==">
```

.[caution]
PHP `fileinfo` uzantısını gerektirir.


date(string $format='j. n. Y') .[filter]
----------------------------------------
Bir tarihi ve saati, PHP [php:date] fonksiyonunun kullandığı maskeye göre biçimlendirir. Filtre, tarihi bir UNIX marka zamanı, bir dize, bir `DateTimeInterface` veya bir `DateInterval` nesnesi olarak kabul eder.

```latte
{$today|date:'j. n. Y'}
```

Ayrıca bkz. [#localDate].


escapeUrl .[filter]
-------------------
Bir değişkeni, bir URL'de parametre olarak kullanılmak üzere kaçırır.

```latte
<a href="http://example.com/{$name|escapeUrl}">{$name}</a>
```

Ayrıca bkz. [#query].


explode(string $separator='') .[filter]
---------------------------------------
Bir dizeyi ayırıcıya göre diziye böler. `split` için takma ad.

```latte
{='one,two,three'|explode:','}    {* ['one', 'two', 'three'] döndürür *}
```

Ayırıcı boş bir dizeyse (varsayılan değer), girdi tek tek karakterlere bölünür:

```latte
{='123'|explode}                  {* ['1', '2', '3'] döndürür *}
```

`split` takma adını da kullanabilirsiniz:

```latte
{='1,2,3'|split:','}              {* ['1', '2', '3'] döndürür *}
```

Ayrıca bkz. [#implode].


filter(callable $predicate): iterable .[filter]{data-version:3.0.20}
--------------------------------------------------------------------
Bir dizinin veya yineleyicinin öğelerini süzer ve yalnızca yüklemin `true` döndürdüğü öğeleri tutar. Anahtarlar korunur.

```latte
{foreach ($people|filter: fn($person) => $person->age >= 18) as $adult}
	<p>{$adult->name}</p>
{/foreach}
```


first .[filter]
---------------
Bir dizinin ilk öğesini veya bir dizenin ilk karakterini döndürür:

```latte
{=[1, 2, 3, 4]|first}    {* 1 yazdırır *}
{='abcd'|first}          {* 'a' yazdırır *}
```

Ayrıca bkz. [#last], [#random].


floor(int $precision=0) .[filter]
---------------------------------
Bir sayıyı verilen duyarlıkta aşağı yuvarlar.

```latte
{=3.5|floor}        {* 3 yazdırır      *}
{=135.79|floor:1}   {* 135.7 yazdırır  *}
{=135.79|floor:3}   {* 135.79 yazdırır *}
```

Ayrıca bkz. [#ceil], [#round].


firstLower .[filter]{data-version:3.0.22}
-----------------------------------------
İlk harfi küçük harfe çevirir. PHP `mbstring` uzantısını gerektirir.

```latte
{='The Latte'|firstLower}  {* 'the Latte' yazdırır *}
```

Ayrıca bkz. [#capitalize], [#firstUpper], [#lower], [#upper].


firstUpper .[filter]
--------------------
İlk harfi büyük harfe çevirir. PHP `mbstring` uzantısını gerektirir.

```latte
{='the latte'|firstUpper}  {* 'The latte' yazdırır *}
```

Ayrıca bkz. [#capitalize], [#firstLower], [#lower], [#upper].


group(string|int|\Closure $by): iterable .[filter]{data-version:3.0.16}
-----------------------------------------------------------------------
Filtre, veriyi çeşitli ölçütlere göre gruplar.

Bu örnekte tablodaki satırlar `categoryId` sütununa göre gruplanır. Çıktı, anahtarı `categoryId` sütunundaki değer olan, yinelenebilir bir gruplar yapısıdır. [Ayrıntılı kılavuzu okuyun|cookbook/grouping].

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

Ayrıca bkz. [#batch], [group |functions#group()] fonksiyonu ve [iterateWhile |tags#{iterateWhile}] etiketi.


implode(string $glue='') .[filter]
----------------------------------
Dizideki öğelerin birleştirilmesiyle oluşan bir dize döndürür. `join` için takma ad.

```latte
{=[1, 2, 3]|implode}      {* '123' yazdırır *}
{=[1, 2, 3]|implode:'|'}  {* '1|2|3' yazdırır *}
```

`join` takma adını da kullanabilirsiniz:

```latte
{=[1, 2, 3]|join}         {* '123' yazdırır *}
```

Ayrıca bkz. [#commas], [#explode].


indent(int $level=1, string $chars="\t") .[filter]
--------------------------------------------------
Metni soldan, verilen sayıda tabulatör veya ikinci argümanda belirtilen başka karakterler kadar girintiler. Boş satırlar girintilenmez.

```latte
<div>
{block |indent}
<p>Hello</p>
{/block}
</div>
```

Şunu üretir:

```latte
<div>
	<p>Hello</p>
</div>
```


last .[filter]
--------------
Bir dizinin son öğesini veya bir dizenin son karakterini döndürür:

```latte
{=[1, 2, 3, 4]|last}    {* 4 yazdırır *}
{='abcd'|last}          {* 'd' yazdırır *}
```

Ayrıca bkz. [#first], [#random].


length .[filter]
----------------
Bir dizenin veya dizinin uzunluğunu döndürür.

- dizelerde UTF‑8 karakter cinsinden uzunluğu döndürür
- dizilerde öğe sayısını döndürür
- Countable arayüzünü uygulayan nesnelerde `count()` metodunun dönüş değerini kullanır
- Traversable arayüzünü uygulayan nesnelerde `iterator_count()` fonksiyonunun dönüş değerini kullanır


```latte
{if ($users|length) > 10}
	...
{/if}
```


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Tarihi ve saati [yerel ayara |develop#Yerel ayar] göre biçimlendirir; böylece zaman verisi farklı diller ve bölgeler arasında tutarlı ve yerelleştirilmiş gösterilir. Filtre, tarihi bir UNIX marka zamanı, dize veya `DateTimeInterface` nesnesi olarak kabul eder.

```latte
{$date|localDate}                  {* 15. dubna 2024 *}
{$date|localDate: format: yM}      {* 4/2024 *}
{$date|localDate: date: medium}    {* 15. 4. 2024 *}
```

Filtreyi parametresiz kullanırsanız, tarihi `long` düzeyinde yazdırır, bkz. aşağısı.

**a) format kullanarak**

`format` parametresi, hangi zaman bileşenlerinin gösterileceğini anlatır. Harf kodları kullanır; yineleme sayısı çıktının genişliğini etkiler:

| Yıl | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Ay | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `Aug` / `August`
| Gün | `d` / `dd` / `E` / `EEEE` |  `1` / `01` / `Sun` / `Sunday`
| Saat | `j` /  `H` / `h` | yeğlenen / 24 saatlik / 12 saatlik
| Dakika | `m` / `mm` | `5` / `05` <small>(saniyeyle birleştiğinde 2 basamak)</small>
| Saniye | `s` / `ss` | `8` / `08` <small>(dakikayla birleştiğinde 2 basamak)</small>

Formattaki kodların sırası önemli değildir, çünkü bileşenlerin sırası yerel ayarın uzlaşımlarına göre gösterilir. Böylece format yerel ayardan bağımsızdır. Örneğin `yyyyMMMMd` formatı `en_US` yerel ayarında `April 15, 2024`, `cs_CZ` yerel ayarında ise `15. dubna 2024` üretir:

| yerel ayar: | cs_CZ | en_US
|---
| `format: 'dMy'` | 10. 8. 2024 | 8/10/2024
| `format: 'yM'` | 8/2024 | 8/2024
| `format: 'yyyyMMMM'` | srpen 2024 | August 2024
| `format: 'MMMM'` | srpen | August
| `format: 'jm'` | 17:22 | 5:22 PM
| `format: 'Hm'` | 17:22 | 17:22
| `format: 'hm'` | 5:22 odp. | 5:22 PM


**b) hazır stilleri kullanarak**

`date` ve `time` parametreleri, tarihin ve saatin ne kadar ayrıntılı gösterileceğini belirler. Birkaç düzey arasından seçebilirsiniz: `full`, `long`, `medium`, `short`. Yalnızca tarihi, yalnızca saati ya da ikisini birden göstermeyi seçebilirsiniz:

| yerel ayar: | cs_CZ | en_US
|---
| `date: short` | 23.01.78 | 1/23/78
| `date: medium` | 23. 1. 1978 | Jan 23, 1978
| `date: long` | 23. ledna 1978 | January 23, 1978
| `date: full` | pondělí 23. ledna 1978 | Monday, January 23, 1978
| `time: short` | 8:30 | 8:30 AM
| `time: medium` | 8:30:59 | 8:30:59 AM
| `time: long` | 8:30:59 SEČ | 8:30:59 AM GMT+1
| `date: short, time: short` | 23.01.78 8:30 | 1/23/78, 8:30 AM
| `date: medium, time: short` | 23. 1. 1978 8:30 | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 23. ledna 1978 v 8:30 | January 23, 1978 at 8:30 AM

Tarihte, bugüne yakın tarihlerde `yesterday`, `today` veya `tomorrow` gösteren, diğer durumlarda standart biçimde gösteren `relative-` ön ekini de kullanabilirsiniz (örneğin `relative-short`).

```latte
{$date|localDate: date: relative-short}    {* yesterday *}
```

Ayrıca bkz. [#date].


lower .[filter]
---------------
Bir dizeyi küçük harfe çevirir. PHP `mbstring` uzantısını gerektirir.

```latte
{='LATTE'|lower}   {* 'latte' yazdırır *}
```

Ayrıca bkz. [#capitalize], [#firstLower], [#firstUpper], [#upper].


map(callable $transformer): iterable .[filter]{data-version:3.1.6}
------------------------------------------------------------------
Bir dizinin veya yineleyicinin her öğesini bir callback ile dönüştürür ve yeni bir yineleyici döndürür. [#filter] filtresinin karşılığıdır. Anahtarlar korunur.

```latte
{=($users|map: fn($user) => $user->name)|implode: ', '}   {* John, Mary, Paul *}
```

Ayrıca bkz. [#filter].


nocheck .[filter]
-----------------
Otomatik URL arındırmasını engeller. Latte, bir URL'nin güvenli bir şema (`http`, `https`, `ftp`, `mailto`, `tel`, `sms` gibi) kullanıp kullanmadığını ya da göreli bir bağlantı olup olmadığını [otomatik denetler |safety-first#Bağlantı denetimi] ve olası tehlikeli olanları engeller.

Bağlantı `javascript:` veya `data:` gibi başka bir şema kullanıyorsa ve içeriğinden eminseniz, denetimi `|nocheck` ile kapatabilirsiniz.

```latte
{var $link = 'javascript:window.close()'}

<a href={$link}>checked</a>
<a href={$link|nocheck}>unchecked</a>
```

Şunu üretir:

```latte
<a href="">checked</a>
<a href="javascript:window.close()">unchecked</a>
```

Ayrıca bkz. [#checkUrl].


noescape .[filter]
------------------
Otomatik kaçışı kapatır.

```latte
{var $trustedHtmlString = '<b>hello</b>'}
Escaped: {$trustedHtmlString}
Unescaped: {$trustedHtmlString|noescape}
```

Şunu üretir:

```latte
Escaped: &lt;b&gt;hello&lt;/b&gt;
Unescaped: <b>hello</b>
```

.[warning]
`noescape` filtresinin yanlış kullanımı bir XSS güvenlik açığına yol açabilir! Ne yaptığınızdan ve yazdırdığınız dizenin güvenilir bir kaynaktan geldiğinden **kesinlikle emin** olmadıkça asla kullanmayın.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Bir sayıyı belirtilen sayıda ondalık basamağa biçimlendirir. [Yerel ayar |develop#Yerel ayar] belirlenmişse, ona karşılık gelen ondalık ve binlik ayırıcılar kullanılır.

```latte
{1234.20|number}              {* 1,234 *}
{1234.20|number:1}            {* 1,234.2 *}
{1234.20|number:2}            {* 1,234.20 *}
{1234.20|number:2, ',', ' '}  {* 1 234,20 *}
```


number(string $format) .[filter]
--------------------------------
`format` parametresi, sayıların görünümünü tam olarak ihtiyacınıza göre tanımlamanızı sağlar. Bunun için [yerel ayarın |develop#Yerel ayar] belirlenmiş olması gerekir. Format, tam açıklaması "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns dokümantasyonunda bulunabilecek birkaç özel karakterden oluşur:

- `0` zorunlu basamak, sıfır olsa bile her zaman gösterilir
- `#` isteğe bağlı basamak, yalnızca sayının o konumda gerçekten bir basamağı varsa gösterilir
- `@` anlamlı basamak, sayıyı belirli sayıda anlamlı basamakla göstermeye yardım eder
- `.` ondalık ayırıcının nerede olacağını belirtir (ülkeye göre nokta veya virgül)
- `,` basamak gruplarını, çoğunlukla binlikleri ayırmaya yarar
- `%` sayıyı 100 ile çarpar ve yüzde işaretini ekler

Birkaç örneğe bakalım. İlk örnekte iki ondalık basamak zorunlu, ikincisinde isteğe bağlıdır. Üçüncü örnek soldan ve sağdan sıfırla doldurmayı gösterir, dördüncüsü yalnızca var olan basamakları gösterir:

```latte
{1234.5|number: '#,##0.00'}     {* 1,234.50 *}
{1234.5|number: '#,##0.##'}     {* 1,234.5 *}
{1.23  |number: '000.000'}      {* 001.230 *}
{1.2   |number: '##.##'}        {* 1.2 *}
```

Anlamlı basamaklar, ondalık noktadan bağımsız olarak kaç basamağın gösterileceğini belirler ve gerekirse yuvarlar:

```latte
{1234|number: '@@'}             {* 1200 *}
{1234|number: '@@@'}            {* 1230 *}
{1234|number: '@@@#'}           {* 1234 *}
{1.2345|number: '@@@'}          {* 1.23 *}
{0.00123|number: '@@'}          {* 0.0012 *}
```

Bir sayıyı yüzde olarak göstermenin kolay yolu. Sayı 100 ile çarpılır ve `%` işareti eklenir:

```latte
{0.1234|number: '#.##%'}        {* 12.34% *}
```

Pozitif ve negatif sayılar için farklı bir format tanımlayabiliriz; `;` karakteriyle ayrılır. Böylece örneğin pozitif sayılar `+` işaretiyle gösterilebilir:

```latte
{42|number: '#.##;(#.##)'}      {* 42 *}
{-42|number: '#.##;(#.##)'}     {* (42) *}
{42|number: '+#.##;-#.##'}      {* +42 *}
{-42|number: '+#.##;-#.##'}     {* -42 *}
```

Sayıların gerçek görünümünün ülke ayarlarına göre değişebileceğini unutmayın. Örneğin bazı ülkelerde ondalık ayırıcı olarak nokta yerine virgül kullanılır. Bu filtre bunu otomatik hesaba katar, bu yüzden dert etmenize gerek yoktur.


padLeft(int $length, string $append=' ') .[filter]
--------------------------------------------------
Bir dizeyi veya sayıyı, soldan başka bir dizeyle belirli bir uzunluğa doldurur.

```latte
{='hello'|padLeft: 10, '123'}  {* '12312hello' yazdırır *}
{=123|padLeft: 5, '0'}         {* '00123' yazdırır *}
```


padRight(int $length, string $append=' ') .[filter]
---------------------------------------------------
Bir dizeyi veya sayıyı, sağdan başka bir dizeyle belirli bir uzunluğa doldurur.

```latte
{='hello'|padRight: 10, '123'}  {* 'hello12312' yazdırır *}
{=123|padRight: 5, '0'}         {* '12300' yazdırır *}
```


query .[filter]
---------------
Bir URL'de dinamik olarak sorgu dizesi üretir:

```latte
<a href="http://example.com/?{[name: 'John Doe', age: 43]|query}">click</a>
<a href="http://example.com/?search={$search|query}">search</a>
```

Şunu üretir:

```latte
<a href="http://example.com/?name=John+Doe&amp;age=43">click</a>
<a href="http://example.com/?search=Foo+Bar">search</a>
```

Değeri `null` olan anahtarlar atlanır.

Ayrıca bkz. [#escapeUrl].


random .[filter]
----------------
Bir dizinin rastgele bir öğesini veya bir dizenin rastgele bir karakterini döndürür:

```latte
{=[1, 2, 3, 4]|random}    {* örneğin şunu yazdırır: 3 *}
{='abcd'|random}          {* örneğin şunu yazdırır: 'b' *}
```

Ayrıca bkz. [#first], [#last].


repeat(int $count) .[filter]
----------------------------
Dizeyi x kez yineler.

```latte
{='hello'|repeat: 3}  {* 'hellohellohello' yazdırır *}
```


replace(string|array $search, string|array $replace='') .[filter]
-----------------------------------------------------------------
Arama dizesinin tüm geçişlerini değiştirme dizesiyle değiştirir.

```latte
{='hello world'|replace: 'world', 'friend'}  {* 'hello friend' yazdırır *}
```

Aynı anda birden fazla değiştirme yapılabilir:

```latte
{='hello world'|replace: [h => l, l => h]}  {* 'lehho worhd' yazdırır *}
```


replaceRE(string $pattern, string $replacement='') .[filter]
------------------------------------------------------------
Düzenli ifadeyle arama ve değiştirme yapar.

```latte
{='hello world'|replaceRE: '/l.*/', 'l'}  {* 'hel' yazdırır *}
```


reverse(bool $preserveKeys=false) .[filter]
-------------------------------------------
Verilen dizeyi veya diziyi ters çevirir.

```latte
{var $s = 'Nette'}
{$s|reverse}    {* 'etteN' yazdırır *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* ['e', 't', 't', 'e', 'N'] döndürür *}
```


round(int $precision=0) .[filter]
---------------------------------
Bir sayıyı verilen duyarlıkta yuvarlar.

```latte
{=3.4|round}        {* 3 yazdırır      *}
{=3.5|round}        {* 4 yazdırır      *}
{=135.79|round:1}   {* 135.8 yazdırır  *}
{=135.79|round:3}   {* 135.79 yazdırır *}
```

Ayrıca bkz. [#ceil], [#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Bir dizinin, dizenin veya yineleyicinin bir dilimini çıkarır.

```latte
{='hello'|slice: 1, 2}           {* 'el' yazdırır *}
{=['a', 'b', 'c']|slice: 1, 2}   {* ['b', 'c'] yazdırır *}
```

Filtre, diziler için PHP'nin `array_slice`, dizeler için `mb_substr` fonksiyonu gibi çalışır. Yineleyicilerde bir generator döndürür; öğeler kaynaktan tek tek tüketilir ve sınıra ulaşıldığında okuma durur. Yineleyicinin tamamı asla belleğe yüklenmez.

`start` negatif değilse, dizi dizinin/dizenin başından itibaren o kaydırmadan başlar. `start` negatifse, dizi sondan o kadar uzaktan başlar.

`length` verilmişse ve pozitifse, dizide en fazla o kadar öğe olur. Girdi `length`'ten kısaysa yalnızca var olan öğeler bulunur. `length` verilmişse ve negatifse, dizi girdinin sonundan o kadar öğe önce durur. Atlanırsa, dizi `start`'tan girdinin sonuna kadar her şeyi içerir.

Filtre varsayılan olarak tam sayı dizi anahtarlarını yeniden düzenler ve sıfırlar. Bu davranış, `preserveKeys` true yapılarak değiştirilebilir. Dize anahtarlar, bu parametreden bağımsız olarak her zaman korunur.

Ayrıca bkz. [#limit].


limit(int $length) .[filter]{data-version:3.1.3}
------------------------------------------------
Bir dizinin, dizenin veya yineleyicinin uzunluğunu sınırlar. Dizilerde ve yineleyicilerde anahtarlar korunur. Dizelerde UTF-8'e saygı gösterir.

```latte
{foreach ($items|limit: 5) as $item}
	...
{/foreach}

{$text|limit: 100}
```


sort(?Closure $comparison=null, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
-------------------------------------------------------------------------------------------------------------------
Filtre, bir dizinin veya yineleyicinin öğelerini sıralar ve ilişkisel anahtarlarını korur. Bir [yerel ayar |develop#Yerel ayar] belirlenmişse ve özel bir karşılaştırma fonksiyonu verilmemişse, sıralama onun kurallarını izler.

```latte
{foreach ($names|sort) as $name}
	...
{/foreach}
```

Ters sırada sıralanmış dizi:

```latte
{foreach ($names|sort|reverse) as $name}
	...
{/foreach}
```

Sıralama için kendi karşılaştırma fonksiyonunuzu belirtebilirsiniz (örnek, sıralamayı büyükten küçüğe nasıl ters çevireceğinizi gösterir):

```latte
{var $reverted = ($names|sort: fn($a, $b) => $b <=> $a)}
```

`|sort` filtresi öğeleri anahtarlara göre sıralamayı da sağlar:

```latte
{foreach ($names|sort: byKey: true) as $name}
	...
{/foreach}
```

Bir tabloyu belirli bir sütuna göre sıralamanız gerekirse `by` parametresini kullanabilirsiniz. Örnekteki `'name'` değeri, `$item`'ın dizi mi nesne mi olduğuna göre sıralamanın `$item->name` ya da `$item['name']` üzerinden yapılacağını belirtir:

```latte
{foreach ($items|sort: by: 'name') as $item}
	{$item->name}
{/foreach}
```

Sıralanacak değeri belirleyen bir callback fonksiyonu da tanımlayabilirsiniz:

```latte
{foreach ($items|sort: by: fn($item) => $item->category->name) as $item}
	{$item->name}
{/foreach}
```

`byKey` parametresi de aynı şekilde kullanılabilir.


spaceless .[filter]
-------------------
Çıktıdan gereksiz boşlukları kaldırır. Kullanımdan kaldırılmış `strip` takma adını da kullanabilirsiniz, ama `spaceless` yeğlenir.

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

Şunu üretir:

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


stripHtml .[filter]
-------------------
HTML'i düz metne dönüştürür. Yani HTML etiketlerini kaldırır ve HTML varlıklarını metin karakterlerine çevirir.

```latte
{='<p>one &lt; two</p>'|stripHtml}  {* 'one < two' yazdırır *}
```

Ortaya çıkan düz metin doğal olarak HTML etiketlerini temsil eden karakterler içerebilir; örneğin `'&lt;p&gt;'|stripHtml`, `<p>`'ye dönüşür. Ortaya çıkan metni asla `|noescape` ile yazdırmayın, bu bir güvenlik açığına yol açabilir.


substr(int $start, ?int $length=null) .[filter]
-----------------------------------------------
Bir dizenin bir bölümünü çıkarır. Bu filtrenin yerini [#slice] filtresi almıştır.

```latte
{$string|substr: 1, 2}
```


toggle .[filter]{data-version:3.1.0}
------------------------------------
`toggle` filtresi, bir niteliğin varlığını bir boole değerine göre denetler. Değer doğru değerliyse nitelik bulunur; yanlış değerliyse nitelik tamamen atlanır:

```latte
<div uk-grid={$isGrid|toggle}>
{* $isGrid doğru değerliyse: <div uk-grid> *}
{* $isGrid yanlış değerliyse: <div> *}
```

Bu filtre, HTML boole niteliklerine benzer biçimde varlık/yokluk denetimi gerektiren özel nitelikler veya JavaScript kütüphanesi nitelikleri için yararlıdır.

Filtre yalnızca HTML niteliklerinin içinde kullanılabilir.


translate(...$args) .[filter]
-----------------------------
İfadeleri başka dillere çevirir. Filtrenin erişilebilir olması için [çevirmeni kurmanız |develop#TranslatorExtension] gerekir. [Çeviri etiketlerini |tags#Çeviri] de kullanabilirsiniz.

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


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Bir dizenin başındaki ve sonundaki boşlukları (veya başka karakterleri) kırpar.

```latte
{='  I like Latte.  '|trim}    {* 'I like Latte.' yazdırır *}
{='  I like Latte.'|trim: '.'} {* '  I like Latte' yazdırır *}
```


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Bir dizeyi belirtilen en büyük uzunluğa kısaltırken tam sözcükleri korumaya çalışır. Dize kısaltılırsa sonuna üç nokta ekler (ikinci parametreyle değiştirilebilir).

```latte
{var $title = 'Hello, how are you?'}
{$title|truncate:5}  {* Hell…                *}
{$title|truncate:17} {* Hello, how are…      *}
{$title|truncate:30} {* Hello, how are you?  *}
```


upper .[filter]
---------------
Bir dizeyi büyük harfe çevirir. PHP `mbstring` uzantısını gerektirir.

```latte
{='latte'|upper}  {* 'LATTE' yazdırır *}
```

Ayrıca bkz. [#capitalize], [#firstLower], [#firstUpper], [#lower].


webalize .[filter]
------------------
Bir UTF‑8 dizesini URL'lerde kullanılan biçime uyarlar.

ASCII'ye çevirir. Boşlukları kısa çizgiye çevirir. Alfanümerik olmayan, alt çizgi veya kısa çizgi olmayan karakterleri kaldırır. Küçük harfe çevirir. Ayrıca baştaki ve sondaki boşlukları kırpar.

```latte
{var $s = 'Our 10th product'}
{$s|webalize}   {* 'our-10th-product' yazdırır *}
```

.[caution]
[nette/utils|utils:] kütüphanesini gerektirir.