-
-
Notifications
You must be signed in to change notification settings - Fork 277
Expand file tree
/
Copy pathfunctions.texy
More file actions
156 lines (106 loc) · 5.46 KB
/
functions.texy
File metadata and controls
156 lines (106 loc) · 5.46 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
Latte-Funktionen
****************
.[perex]
In Templates können wir neben den üblichen PHP-Funktionen auch diese zusätzlichen Funktionen verwenden.
.[table-latte-filters]
| `clamp` | [begrenzt einen Wert auf einen bestimmten Bereich |#clamp]
| `divisibleBy`| [prüft, ob eine Variable durch eine Zahl teilbar ist |#divisibleBy]
| `even` | [prüft, ob eine gegebene Zahl gerade ist |#even]
| `first` | [gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück |#first]
| `group` | [gruppiert Daten nach verschiedenen Kriterien |#group]
| `hasBlock` | [prüft die Existenz eines Blocks |#hasBlock]
| `last` | [gibt das letzte Element eines Arrays oder das letzte Zeichen einer Zeichenkette zurück |#last]
| `odd` | [prüft, ob eine gegebene Zahl ungerade ist |#odd]
| `slice` | [extrahiert einen Teil eines Arrays oder einer Zeichenkette |#slice]
Verwendung
==========
Funktionen werden genauso wie übliche PHP-Funktionen verwendet und können in allen Ausdrücken eingesetzt werden:
```latte
<p>{clamp($num, 1, 100)}</p>
{if odd($num)} ... {/if}
```
[Benutzerdefinierte Funktionen |custom-functions] können auf diese Weise registriert werden:
```php
$latte = new Latte\Engine;
$latte->addFunction('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len));
```
Im Template wird sie dann so aufgerufen:
```latte
<p>{shortify($text)}</p>
<p>{shortify($text, 100)}</p>
```
Funktionen
==========
clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Begrenzt einen Wert auf den angegebenen inklusiven Bereich von min und max.
```latte
{=clamp($level, 0, 255)}
```
Siehe auch der [Filter clamp |filters#clamp].
divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Prüft, ob eine Variable durch eine Zahl teilbar ist.
```latte
{if divisibleBy($num, 5)} ... {/if}
```
even(int $value): bool .[method]
--------------------------------
Prüft, ob eine gegebene Zahl gerade ist.
```latte
{if even($num)} ... {/if}
```
first(string|iterable $value): mixed .[method]
----------------------------------------------
Gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück:
```latte
{=first([1, 2, 3, 4])} {* gibt 1 aus *}
{=first('abcd')} {* gibt 'a' aus *}
```
Siehe auch [#last], [Filter first |filters#first].
group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Die Funktion gruppiert Daten nach verschiedenen Kriterien.
In diesem Beispiel werden die Zeilen in der Tabelle nach der Spalte `categoryId` gruppiert. Die Ausgabe ist ein Array von Arrays, wobei der Schlüssel der Wert in der Spalte `categoryId` ist. [Lesen Sie die detaillierte Anleitung |cookbook/grouping].
```latte
{foreach group($items, categoryId) as $categoryId => $categoryItems}
<ul>
{foreach $categoryItems as $item}
<li>{$item->name}</li>
{/foreach}
</ul>
{/foreach}
```
Siehe auch der Filter [group |filters#group].
hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Prüft, ob ein Block mit dem angegebenen Namen existiert:
```latte
{if hasBlock(header)} ... {/if}
```
Siehe auch [Überprüfung der Existenz von Blöcken |template-inheritance#Existenzprüfung von Blöcken].
last(string|array $value): mixed .[method]
------------------------------------------
Gibt das letzte Element eines Arrays oder das letzte Zeichen einer Zeichenkette zurück:
```latte
{=last([1, 2, 3, 4])} {* gibt 4 aus *}
{=last('abcd')} {* gibt 'd' aus *}
```
Siehe auch [#first], [Filter last |filters#last].
odd(int $value): bool .[method]
-------------------------------
Prüft, ob eine gegebene Zahl ungerade ist.
```latte
{if odd($num)} ... {/if}
```
slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Extrahiert einen Teil eines Arrays oder einer Zeichenkette.
```latte
{=slice('hallo', 1, 2)} {* gibt 'al' aus *}
{=slice(['a', 'b', 'c'], 1, 2)} {* gibt ['b', 'c'] aus *}
```
Die Funktion funktioniert wie die PHP-Funktion `array_slice` für Arrays oder `mb_substr` für Zeichenketten mit einem Fallback auf die Funktion `iconv_substr` im UTF-8-Modus.
Wenn `start` positiv ist, beginnt die Sequenz um diese Anzahl vom Anfang des Arrays/der Zeichenkette verschoben. Wenn es negativ ist, beginnt die Sequenz um so viel vom Ende verschoben.
Wenn der Parameter `length` angegeben ist und positiv ist, enthält die Sequenz so viele Elemente. Wenn dieser Funktion ein negativer Parameter `length` übergeben wird, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend bei der Position `start` und endend bei einer Position, die um `length` Elemente kleiner ist als das Ende des Arrays. Wenn Sie diesen Parameter nicht angeben, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend bei der Position `start`.
Standardmäßig ändert der Filter die Reihenfolge und setzt die Ganzzahl-Schlüssel des Arrays zurück. Dieses Verhalten kann durch Setzen von `preserveKeys` auf `true` geändert werden. Zeichenketten-Schlüssel bleiben immer erhalten, unabhängig von diesem Parameter.