From 846221e5b9eef271efdf3f2e89c9949f593e23cb Mon Sep 17 00:00:00 2001 From: David Grudl Date: Wed, 7 Aug 2024 18:21:52 +0200 Subject: [PATCH 01/23] nette/utils 4.0.5 --- utils/bg/@home.texy | 2 +- utils/bg/arrays.texy | 14 +++++++ utils/bg/iterables.texy | 83 +++++++++++++++++++++++++++++++-------- utils/bg/strings.texy | 14 ++++++- utils/cs/@home.texy | 4 +- utils/cs/arrays.texy | 14 +++++++ utils/cs/iterables.texy | 79 ++++++++++++++++++++++++++++++------- utils/cs/strings.texy | 14 ++++++- utils/de/@home.texy | 2 +- utils/de/arrays.texy | 14 +++++++ utils/de/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/de/strings.texy | 14 ++++++- utils/el/@home.texy | 2 +- utils/el/arrays.texy | 14 +++++++ utils/el/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/el/strings.texy | 14 ++++++- utils/en/@home.texy | 2 +- utils/en/arrays.texy | 14 +++++++ utils/en/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/en/strings.texy | 14 ++++++- utils/es/@home.texy | 2 +- utils/es/arrays.texy | 14 +++++++ utils/es/iterables.texy | 83 +++++++++++++++++++++++++++++++-------- utils/es/strings.texy | 14 ++++++- utils/fr/@home.texy | 2 +- utils/fr/arrays.texy | 14 +++++++ utils/fr/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/fr/strings.texy | 14 ++++++- utils/hu/@home.texy | 2 +- utils/hu/arrays.texy | 14 +++++++ utils/hu/iterables.texy | 83 +++++++++++++++++++++++++++++++-------- utils/hu/strings.texy | 14 ++++++- utils/it/@home.texy | 2 +- utils/it/arrays.texy | 14 +++++++ utils/it/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/it/strings.texy | 14 ++++++- utils/pl/@home.texy | 2 +- utils/pl/arrays.texy | 14 +++++++ utils/pl/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/pl/strings.texy | 14 ++++++- utils/pt/@home.texy | 2 +- utils/pt/arrays.texy | 14 +++++++ utils/pt/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/pt/strings.texy | 14 ++++++- utils/ro/@home.texy | 2 +- utils/ro/arrays.texy | 14 +++++++ utils/ro/iterables.texy | 87 ++++++++++++++++++++++++++++++++--------- utils/ro/strings.texy | 14 ++++++- utils/ru/@home.texy | 2 +- utils/ru/arrays.texy | 14 +++++++ utils/ru/iterables.texy | 83 +++++++++++++++++++++++++++++++-------- utils/ru/strings.texy | 14 ++++++- utils/sl/@home.texy | 2 +- utils/sl/arrays.texy | 14 +++++++ utils/sl/iterables.texy | 83 +++++++++++++++++++++++++++++++-------- utils/sl/strings.texy | 14 ++++++- utils/tr/@home.texy | 2 +- utils/tr/arrays.texy | 14 +++++++ utils/tr/iterables.texy | 81 +++++++++++++++++++++++++++++++------- utils/tr/strings.texy | 14 ++++++- utils/uk/@home.texy | 2 +- utils/uk/arrays.texy | 14 +++++++ utils/uk/iterables.texy | 83 +++++++++++++++++++++++++++++++-------- utils/uk/strings.texy | 14 ++++++- 64 files changed, 1497 insertions(+), 297 deletions(-) diff --git a/utils/bg/@home.texy b/utils/bg/@home.texy index bf120bdbac..34852da426 100644 --- a/utils/bg/@home.texy +++ b/utils/bg/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | PHP съвместима версия |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/bg/arrays.texy b/utils/bg/arrays.texy index f759d61f5c..c7ba13c152 100644 --- a/utils/bg/arrays.texy +++ b/utils/bg/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Създава нов масив, като трансформира стойностите и ключовете на оригиналния масив. Функцията `$transformer` има сигнатура `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Ако `$transformer` върне `null`, елементът се пропуска. За запазените елементи първият елемент от върнатия масив се използва като нов ключ, а вторият елемент - като нова стойност. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Този метод е полезен в ситуации, в които трябва да се промени структурата на масив (едновременно и ключове, и стойности) или да се филтрират елементите по време на преобразуването (чрез връщане на null за нежелани елементи). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/bg/iterables.texy b/utils/bg/iterables.texy index 8fcdc85e1d..a7fe192151 100644 --- a/utils/bg/iterables.texy +++ b/utils/bg/iterables.texy @@ -11,7 +11,7 @@ composer require nette/utils ``` -Всички примери предполагат създаването на псевдоним: +Всички примери предполагат, че е създаден следният псевдоним: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Тества за наличие на стойност в итератора. Използва стриктно сравнение (`===`). +Търси дадена стойност в итератор. Използва стриктно сравнение (`===`), за да провери за съвпадение. Връща `true`, ако стойността е намерена, в противен случай `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Този метод е полезен, когато трябва бързо да определите дали определена стойност присъства в итератора, без да преминавате ръчно през всички елементи. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Тества за наличие на ключ в итератора. Използва стриктно сравнение (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Търси даден ключ в итератор. Използва стриктно сравнение (`===`), за да провери за съвпадение. Връща `true`, ако ключът е намерен, в противен случай `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Проверява дали всички елементи на итератора са преминали тест, реализиран в `$predicate` със сигнатура `function ($value, $key, iterable $iterable): bool`. +Проверява дали всички елементи на итератора отговарят на условието, дефинирано в `$predicate`. Функцията `$predicate` има сигнатура `function ($value, $key, iterable $iterable): bool` и трябва да връща `true` за всеки елемент, за да може методът `every()` да връща `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Вижте [some( |#some()]). +Този метод е полезен за проверка дали всички елементи в дадена колекция отговарят на определено условие, например дали всички числа са под определена стойност. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Итератор, който филтрира елементите в съответствие с предикат. Предикатът има сигнатурата `function ($value, $key, iterable $iterable): bool`. Запазва оригиналните ключове. +Създава нов итератор, който съдържа само елементите от оригиналния итератор, които отговарят на условието, дефинирано в `$predicate`. Функцията `$predicate` има сигнатура `function ($value, $key, iterable $iterable): bool` и трябва да връща `true` за елементите, които трябва да бъдат запазени. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Методът използва генератор, което означава, че филтрирането се извършва инкрементално по време на итерацията. Това е ефективно по отношение на паметта и позволява работа с много големи колекции. Ако не итерирате през всички елементи на получения итератор, спестявате изчислителни усилия, тъй като не всички елементи на първоначалния итератор се обработват. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Връща първия елемент (отговарящ на предиката, ако е зададен). Ако няма такъв елемент, се връща резултатът от извикването на `$else` или null. -Параметърът `$predicate` има сигнатура `function ($value, $key, iterable $iterable): bool`. +Връща първия елемент на итератора. Ако е предоставен `$predicate`, се връща първият елемент, който отговаря на даденото условие. Функцията `$predicate` има сигнатура `function ($value, $key, iterable $iterable): bool`. Ако не бъде намерен съответстващ елемент, се извиква функцията `$else` (ако е предоставена) и се връща нейният резултат. Ако не е предоставена `$else`, се връща `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Този метод е полезен, когато трябва бързо да се извлече първият елемент от дадена колекция или първият елемент, който отговаря на определено условие, без да се налага ръчно да се итерира цялата колекция. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Връща ключа на първия елемент (отговарящ на предиката, ако е зададен). Ако няма такъв елемент, се връща резултатът от извикването на `$else` или null. Предикатът има сигнатура `function ($value, $key, iterable $iterable): bool`. +Връща ключа на първия елемент на итератора. Ако е зададен `$predicate`, връща ключа на първия елемент, който отговаря на даденото условие. Функцията `$predicate` има сигнатура `function ($value, $key, iterable $iterable): bool`. Ако не е намерен съответстващ елемент, се извиква функцията `$else` (ако е предоставена) и се връща нейният резултат. Ако не е предоставена `$else`, се връща `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Итератор, който трансформира стойностите чрез извикване на `$transformer`. Той има сигнатура `function ($value, $key, iterable $iterable): bool`. Запазва оригиналните ключове. +Създава нов итератор, като прилага функцията `$transformer` към всеки елемент на оригиналния итератор. Функцията `$transformer` има сигнатура `function ($value, $key, iterable $iterable): mixed` и нейната върната стойност се използва като нова стойност на елемента. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Методът използва генератор, което означава, че трансформацията се извършва инкрементално по време на итерацията. Това е ефективно по отношение на паметта и позволява работа с много големи колекции. Ако не итерирате през всички елементи на получения итератор, спестявате изчислителни усилия, тъй като не всички елементи на първоначалния итератор се обработват. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Създава нов итератор, като трансформира стойностите и ключовете на оригиналния итератор. Функцията `$transformer` има сигнатура `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Ако `$transformer` върне `null`, елементът се прескача. За запазените елементи първият елемент от върнатия масив се използва като нов ключ, а вторият елемент - като нова стойност. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Подобно на `map()`, този метод използва генератор за поетапна обработка и ефективност на паметта. Това позволява работа с големи колекции и спестяване на изчислителни усилия чрез обработване само на част от резултата. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Създава обвивка около итератор, която кешира ключовете и стойностите му по време на итерацията. Това позволява многократно итериране на данните, без да се налага да се обработва отново оригиналният източник на данни. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Този метод е полезен в ситуации, в които е необходимо да се итерира многократно един и същ набор от данни, но оригиналният итератор не поддържа многократна итерация или многократната итерация би била скъпа (например четене на данни от база данни или файл). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Проверява дали поне един елемент от итератора преминава тест, реализиран в `$predicate` със сигнатура `function ($value, $key, iterable $iterable): bool`. +Проверява дали поне един елемент от итератора отговаря на условието, дефинирано в `$predicate`. Функцията `$predicate` има сигнатура `function ($value, $key, iterable $iterable): bool` и трябва да върне `true` за поне един елемент, за да може методът `some()` да върне `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` -Вижте [every( |#every()]). +Този метод е полезен за бърза проверка дали в дадена колекция има поне един елемент, който отговаря на определено условие, например дали колекцията съдържа поне едно четно число. + +Вижте [every(). |#every()] + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Преобразува всеки обект с итерации (масив, Traversable) в итератор. Ако входният обект вече е Iterator, той се връща непроменен. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Този метод е полезен, когато трябва да се уверите, че имате Iterator, независимо от типа на входните данни. Това може да бъде полезно при създаване на функции, които работят с различни типове итерационни данни. diff --git a/utils/bg/strings.texy b/utils/bg/strings.texy index dde4e47a1e..2a4e3d6d98 100644 --- a/utils/bg/strings.texy +++ b/utils/bg/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Претърсва низ за всички срещания, съответстващи на регулярен израз, и връща масив, съдържащ намерения израз и всеки подизраз. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Ако `$lazy` е `true`, функцията връща `Generator` вместо масив, което осигурява значителни ползи за производителността при работа с големи низове. Генераторът позволява съвпаденията да се намират постепенно, вместо да се обработва целият низ наведнъж. Това позволява ефективна работа с изключително големи входни текстове. Освен това можете да прекъснете обработката по всяко време, ако откриете желаното съвпадение, което спестява изчислително време. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/cs/@home.texy b/utils/cs/@home.texy index 5dbdc24034..dc49180f14 100644 --- a/utils/cs/@home.texy +++ b/utils/cs/@home.texy @@ -35,8 +35,8 @@ composer require nette/utils | verze | kompatibilní s PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 -| Nette Utils 3.2 | PHP 7.2 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 +| Nette Utils 3.2 | PHP 7.2 – 8.4 | Nette Utils 3.0 – 3.1 | PHP 7.1 – 8.0 | Nette Utils 2.5 | PHP 5.6 – 8.0 diff --git a/utils/cs/arrays.texy b/utils/cs/arrays.texy index b97bf5a19b..65a19adc57 100644 --- a/utils/cs/arrays.texy +++ b/utils/cs/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Vytváří nové pole transformací hodnot a klíčů původního pole. Funkce `$transformer` má signaturu `function ($value, $key, array $array): ?array{$newKey, $newValue}`. Pokud `$transformer` vrátí `null`, prvek je přeskočen. Pro zachované prvky se první prvek vráceného pole použije jako nový klíč a druhý prvek jako nová hodnota. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Tato metoda je užitečná v situacích, kdy potřebujete změnit strukturu pole (klíče i hodnoty současně) nebo filtrovat prvky při transformaci (vracením null pro nežádoucí prvky). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/cs/iterables.texy b/utils/cs/iterables.texy index 9d1b474457..77af7696df 100644 --- a/utils/cs/iterables.texy +++ b/utils/cs/iterables.texy @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Testuje přítomnost hodnoty v iterátoru. Používá striktní porovnání (`===`). +Hledá zadanou hodnotu v iterátoru. Používá striktní porovnání (`===`) pro ověření shody. Vrací `true`, pokud je hodnota nalezena, jinak `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Tato metoda je užitečná, když potřebujete rychle zjistit, zda se konkrétní hodnota v iterátoru nachází, aniž byste museli procházet všechny prvky ručně. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Testuje přítomnost klíče v iterátoru. Používá striktní porovnání (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Hledá zadaný klíč v iterátoru. Používá striktní porovnání (`===`) pro ověření shody. Vrací `true`, pokud je klíč nalezen, jinak `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Testuje, zda všechny prvky iterátoru projdou testem implementovaným v `$predicate` se signaturou `function ($value, $key, iterable $iterable): bool`. +Ověřuje, zda všechny prvky iterátoru splňují podmínku definovanou v `$predicate`. Funkce `$predicate` má signaturu `function ($value, $key, iterable $iterable): bool` a musí vracet `true` pro každý prvek, aby metoda `every()` vrátila `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Viz [#some()]. +Tato metoda je užitečná pro ověření, zda všechny prvky v kolekci splňují určitou podmínku, například zda jsou všechna čísla menší než určitá hodnota. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterátor, který filtruje prvky dle predikátu. Ten má signaturu `function ($value, $key, iterable $iterable): bool`. Zachovává původní klíče. +Vytváří nový iterátor, který obsahuje pouze ty prvky z původního iterátoru, které splňují podmínku definovanou v `$predicate`. Funkce `$predicate` má signaturu `function ($value, $key, iterable $iterable): bool` a musí vracet `true` pro prvky, které mají být zachovány. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Metoda využívá generátor, což znamená, že filtrování probíhá postupně při procházení výsledku. To je efektivní z hlediska paměti a umožňuje zpracovávat i velmi velké kolekce. Pokud neprojdete všechny prvky výsledného iterátoru, ušetříte výpočetní výkon, protože se nezpracují všechny prvky původního iterátoru. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Vrátí první položku (odpovídající predikátu, je-li zadán). Pokud taková položka neexistuje, vrátí výsledek volání `$else` nebo null. -Parametr `$predicate` má signaturu `function ($value, $key, iterable $iterable): bool`. +Vrací první prvek iterátoru. Pokud je zadán `$predicate`, vrací první prvek, který splňuje danou podmínku. Funkce `$predicate` má signaturu `function ($value, $key, iterable $iterable): bool`. Pokud není nalezen žádný vyhovující prvek, volá se funkce `$else` (pokud je zadána) a vrací se její výsledek. Pokud `$else` není zadáno, vrací se `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Tato metoda je užitečná, když potřebujete rychle získat první prvek kolekce nebo první prvek splňující určitou podmínku, aniž byste museli procházet celou kolekci ručně. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Vrátí klíč první položky (odpovídající predikátu, je-li zadán). Pokud taková položka neexistuje, vrátí výsledek volání `$else` nebo null. Predikát má signaturu `function ($value, $key, iterable $iterable): bool`. +Vrací klíč prvního prvku iterátoru. Pokud je zadán `$predicate`, vrací klíč prvního prvku, který splňuje danou podmínku. Funkce `$predicate` má signaturu `function ($value, $key, iterable $iterable): bool`. Pokud není nalezen žádný vyhovující prvek, volá se funkce `$else` (pokud je zadána) a vrací se její výsledek. Pokud `$else` není zadáno, vrací se `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterátor, který transformuje hodnoty voláním `$transformer`. Ten má signaturu `function ($value, $key, iterable $iterable): bool`. Zachovává původní klíče. +Vytváří nový iterátor aplikováním funkce `$transformer` na každý prvek původního iterátoru. Funkce `$transformer` má signaturu `function ($value, $key, iterable $iterable): mixed` a její návratová hodnota se použije jako nová hodnota prvku. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Metoda využívá generátor, což znamená, že transformace probíhá postupně při procházení výsledku. To je efektivní z hlediska paměti a umožňuje zpracovávat i velmi velké kolekce. Pokud neprojdete všechny prvky výsledného iterátoru, ušetříte výpočetní výkon, protože se nezpracují všechny prvky původního iterátoru. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Vytváří nový iterátor transformací hodnot a klíčů původního iterátoru. Funkce `$transformer` má signaturu `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Pokud `$transformer` vrátí `null`, prvek je přeskočen. Pro zachované prvky se první prvek vráceného pole použije jako nový klíč a druhý prvek jako nová hodnota. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Stejně jako `map()`, tato metoda využívá generátor pro postupné zpracování a efektivní práci s pamětí. To umožňuje pracovat s velkými kolekcemi a šetřit výpočetní výkon při částečném průchodu výsledkem. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Vytváří obal kolem iterátoru, který během iterace ukládá do mezipaměti jeho klíče a hodnoty. To umožňuje opakovanou iteraci dat bez nutnosti znovu procházet původní zdroj dat. + +```php +$iterator = /* data, která nelze iterovat vícekrát */ +$memoized = Iterables::memoize($iterator); +// Nyní můžete iterovat $memoized vícekrát bez ztráty dat +``` + +Tato metoda je užitečná v situacích, kdy potřebujete vícekrát projít stejnou sadu dat, ale původní iterátor neumožňuje opakovanou iteraci nebo by opakované procházení bylo nákladné (např. při čtení dat z databáze nebo souboru). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Testuje, zda alespoň jeden prvek iterátoru projde testem implementovaným v `$predicate` se signaturou `function ($value, $key, iterable $iterable): bool`. +Ověřuje, zda alespoň jeden prvek iterátoru splňuje podmínku definovanou v `$predicate`. Funkce `$predicate` má signaturu `function ($value, $key, iterable $iterable): bool` a musí vracet `true` pro alespoň jeden prvek, aby metoda `some()` vrátila `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Tato metoda je užitečná pro rychlé ověření, zda v kolekci existuje alespoň jeden prvek splňující určitou podmínku, například zda kolekce obsahuje alespoň jedno sudé číslo. + Viz [#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Převádí jakýkoliv iterovatelný objekt (array, Traversable) na Iterator. Pokud je vstup již Iterator, vrátí ho beze změny. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Nyní máte Iterator místo pole +``` + +Tato metoda je užitečná, když potřebujete zajistit, že máte k dispozici Iterator, bez ohledu na typ vstupních dat. To může být užitečné při vytváření funkcí, které pracují s různými typy iterovatelných dat. diff --git a/utils/cs/strings.texy b/utils/cs/strings.texy index 18eb2fcd7b..c3a0a35a2c 100644 --- a/utils/cs/strings.texy +++ b/utils/cs/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Hledá v řetězci všechny výskyty odpovídající regulárnímu výrazu a vrátí pole polí s nalezeným výrazem a jednotlivými podvýrazy. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Pokud `$lazy` je `true`, funkce vrací `Generator` místo pole, což přináší významné výkonnostní výhody při práci s velkými řetězci. Generátor umožňuje vyhledávat shody postupně, místo celého řetězce najednou. To umožňuje efektivně pracovat i s extrémně velkými vstupními texty. Navíc můžete kdykoliv přerušit zpracování, pokud najdete hledanou shodu, což šetří výpočetní čas. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Nalezeno: $match[0]\n"; + // Zpracování může být kdykoli přerušeno +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/de/@home.texy b/utils/de/@home.texy index 16b27abe0b..ce02f3392e 100644 --- a/utils/de/@home.texy +++ b/utils/de/@home.texy @@ -36,7 +36,7 @@ composer require nette/utils | Version | kompatibel mit PHP |-----------|------------------- | Nette Utils 4.0 | PHP 8.0 – 8.3 -| Nette Utils 3.2 | PHP 7.2 – 8.3 +| Nette Utils 3.2 | PHP 7.2 – 8.4 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/de/arrays.texy b/utils/de/arrays.texy index 73f7372c02..1475a210ca 100644 --- a/utils/de/arrays.texy +++ b/utils/de/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Erzeugt ein neues Array durch Umwandlung der Werte und Schlüssel des ursprünglichen Arrays. Die Funktion `$transformer` hat die Signatur `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Wenn `$transformer` `null` zurückgibt, wird das Element übersprungen. Bei beibehaltenen Elementen wird das erste Element des zurückgegebenen Arrays als neuer Schlüssel und das zweite Element als neuer Wert verwendet. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Diese Methode ist in Situationen nützlich, in denen Sie die Struktur eines Arrays (Schlüssel und Werte gleichzeitig) ändern oder Elemente während der Transformation filtern müssen (indem Sie für unerwünschte Elemente null zurückgeben). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/de/iterables.texy b/utils/de/iterables.texy index cf64305f41..ca35b3e441 100644 --- a/utils/de/iterables.texy +++ b/utils/de/iterables.texy @@ -11,7 +11,7 @@ Installation: composer require nette/utils ``` -Alle Beispiele gehen von der Erstellung eines Alias aus: +Bei allen Beispielen wird davon ausgegangen, dass der folgende Alias erstellt wurde: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Prüft auf das Vorhandensein eines Wertes im Iterator. Er verwendet einen strengen Vergleich (`===`). +Sucht nach einem bestimmten Wert in einem Iterator. Verwendet einen strengen Vergleich (`===`), um nach einer Übereinstimmung zu suchen. Gibt `true` zurück, wenn der Wert gefunden wird, andernfalls `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Diese Methode ist nützlich, wenn Sie schnell feststellen müssen, ob ein bestimmter Wert in einem Iterator vorhanden ist, ohne manuell durch alle Elemente zu iterieren. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Prüft auf das Vorhandensein eines Schlüssels im Iterator. Er verwendet einen strengen Vergleich (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Sucht nach einem bestimmten Schlüssel in einem Iterator. Verwendet einen strikten Vergleich (`===`), um nach einer Übereinstimmung zu suchen. Gibt `true` zurück, wenn der Schlüssel gefunden wird, andernfalls `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Prüft, ob alle Elemente des Iterators einen in `$predicate` implementierten Test mit der Signatur `function ($value, $key, iterable $iterable): bool` bestehen. +Überprüft, ob alle Elemente des Iterators die in `$predicate` definierte Bedingung erfüllen. Die Funktion `$predicate` hat die Signatur `function ($value, $key, iterable $iterable): bool` und muss für jedes Element `true` zurückgeben, damit die Methode `every()` `true` zurückgibt. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Siehe [some() |#some()]. +Diese Methode ist nützlich, um zu überprüfen, ob alle Elemente in einer Sammlung eine bestimmte Bedingung erfüllen, z. B. ob alle Zahlen unter einem bestimmten Wert liegen. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterator, der Elemente nach einem Prädikat filtert. Das Prädikat hat die Signatur `function ($value, $key, iterable $iterable): bool`. Behält die ursprünglichen Schlüssel bei. +Erzeugt einen neuen Iterator, der nur die Elemente des ursprünglichen Iterators enthält, die die in `$predicate` definierte Bedingung erfüllen. Die Funktion `$predicate` hat die Signatur `function ($value, $key, iterable $iterable): bool` und muss für Elemente, die beibehalten werden sollen, `true` zurückgeben. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Die Methode verwendet einen Generator, was bedeutet, dass die Filterung während der Iteration inkrementell erfolgt. Dies ist speichereffizient und ermöglicht die Verarbeitung sehr großer Sammlungen. Wenn Sie nicht durch alle Elemente des resultierenden Iterators iterieren, sparen Sie Rechenaufwand, da nicht alle Elemente des ursprünglichen Iterators verarbeitet werden. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Gibt das erste Element zurück (das dem Prädikat entspricht, falls angegeben). Ist kein solches Element vorhanden, wird das Ergebnis des Aufrufs `$else` oder null zurückgegeben. -Der Parameter `$predicate` hat die Signatur `function ($value, $key, iterable $iterable): bool`. +Gibt das erste Element des Iterators zurück. Wenn `$predicate` angegeben ist, wird das erste Element zurückgegeben, das die angegebene Bedingung erfüllt. Die Funktion `$predicate` hat die Signatur `function ($value, $key, iterable $iterable): bool`. Wenn kein übereinstimmendes Element gefunden wird, wird die Funktion `$else` (falls angegeben) aufgerufen und ihr Ergebnis zurückgegeben. Wenn `$else` nicht angegeben ist, wird `null` zurückgegeben. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Diese Methode ist nützlich, wenn Sie schnell das erste Element einer Sammlung oder das erste Element, das eine bestimmte Bedingung erfüllt, abrufen möchten, ohne die gesamte Sammlung manuell durchlaufen zu müssen. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Gibt den Schlüssel des ersten Elements zurück (das dem Prädikat entspricht, falls angegeben). Ist kein solches Element vorhanden, wird das Ergebnis des Aufrufs `$else` oder null zurückgegeben. Das Prädikat hat die Signatur `function ($value, $key, iterable $iterable): bool`. +Gibt den Schlüssel des ersten Elements des Iterators zurück. Wenn `$predicate` angegeben ist, wird der Schlüssel des ersten Elements zurückgegeben, das die angegebene Bedingung erfüllt. Die Funktion `$predicate` hat die Signatur `function ($value, $key, iterable $iterable): bool`. Wird kein passendes Element gefunden, wird die Funktion `$else` (falls angegeben) aufgerufen und ihr Ergebnis zurückgegeben. Wenn `$else` nicht angegeben ist, wird `null` zurückgegeben. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterator, der Werte durch den Aufruf von `$transformer` umwandelt. Er hat die Signatur `function ($value, $key, iterable $iterable): bool`. Behält die ursprünglichen Schlüssel bei. +Erzeugt einen neuen Iterator durch Anwendung der Funktion `$transformer` auf jedes Element des ursprünglichen Iterators. Die Funktion `$transformer` hat die Signatur `function ($value, $key, iterable $iterable): mixed` und ihr Rückgabewert wird als neuer Wert des Elements verwendet. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Die Methode verwendet einen Generator, was bedeutet, dass die Umwandlung während der Iteration inkrementell erfolgt. Dies ist speichereffizient und ermöglicht den Umgang mit sehr großen Sammlungen. Wenn Sie nicht durch alle Elemente des resultierenden Iterators iterieren, sparen Sie Rechenaufwand, da nicht alle Elemente des ursprünglichen Iterators verarbeitet werden. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Erzeugt einen neuen Iterator durch Umwandlung der Werte und Schlüssel des ursprünglichen Iterators. Die Funktion `$transformer` hat die Signatur `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Wenn `$transformer` `null` zurückgibt, wird das Element übersprungen. Bei beibehaltenen Elementen wird das erste Element des zurückgegebenen Arrays als neuer Schlüssel und das zweite Element als neuer Wert verwendet. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Wie `map()` verwendet diese Methode einen Generator für inkrementelle Verarbeitung und Speichereffizienz. Dies ermöglicht die Arbeit mit großen Sammlungen und spart Rechenaufwand, indem nur ein Teil des Ergebnisses verarbeitet wird. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Erzeugt einen Wrapper um einen Iterator, der seine Schlüssel und Werte während der Iteration zwischenspeichert. Dies ermöglicht eine wiederholte Iteration über die Daten, ohne dass die ursprüngliche Datenquelle erneut verarbeitet werden muss. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Diese Methode ist in Situationen nützlich, in denen Sie denselben Datensatz mehrmals durchlaufen müssen, der ursprüngliche Iterator jedoch keine wiederholte Iteration unterstützt oder eine wiederholte Iteration zu kostspielig wäre (z. B. beim Lesen von Daten aus einer Datenbank oder Datei). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Prüft, ob mindestens ein Element des Iterators einen in `$predicate` implementierten Test mit der Signatur `function ($value, $key, iterable $iterable): bool` besteht. +Prüft, ob mindestens ein Element des Iterators die in `$predicate` definierte Bedingung erfüllt. Die Funktion `$predicate` hat die Signatur `function ($value, $key, iterable $iterable): bool` und muss für mindestens ein Element `true` zurückgeben, damit die Methode `some()` `true` zurückgibt. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Diese Methode ist nützlich, um schnell zu überprüfen, ob es mindestens ein Element in einer Sammlung gibt, das eine bestimmte Bedingung erfüllt, z. B. ob die Sammlung mindestens eine gerade Zahl enthält. + Siehe [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Konvertiert ein beliebiges iterierbares Objekt (Array, Traversable) in einen Iterator. Wenn die Eingabe bereits ein Iterator ist, wird er unverändert zurückgegeben. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Diese Methode ist nützlich, wenn Sie sicherstellen müssen, dass Sie einen Iterator haben, unabhängig vom Typ der Eingabedaten. Dies kann bei der Erstellung von Funktionen nützlich sein, die mit verschiedenen Typen von Iterationsdaten arbeiten. diff --git a/utils/de/strings.texy b/utils/de/strings.texy index f5d0d29c12..ed93c323ca 100644 --- a/utils/de/strings.texy +++ b/utils/de/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Durchsucht die Zeichenkette nach allen Vorkommen, die mit dem regulären Ausdruck übereinstimmen, und gibt ein Array von Arrays zurück, das den gefundenen Ausdruck und jeden Unterausdruck enthält. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Wenn `$lazy` `true` ist, gibt die Funktion ein `Generator` anstelle eines Arrays zurück, was bei der Arbeit mit großen Zeichenketten erhebliche Leistungsvorteile bietet. Der Generator ermöglicht es, dass Übereinstimmungen schrittweise gefunden werden, anstatt die gesamte Zeichenkette auf einmal zu verarbeiten. Dies ermöglicht einen effizienten Umgang mit extrem großen Eingabetexten. Außerdem können Sie die Verarbeitung jederzeit unterbrechen, wenn Sie die gewünschte Übereinstimmung gefunden haben, was Rechenzeit spart. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/el/@home.texy b/utils/el/@home.texy index a0678fe23b..1e5c416b70 100644 --- a/utils/el/@home.texy +++ b/utils/el/@home.texy @@ -36,7 +36,7 @@ composer require nette/utils | έκδοση | συμβατό με PHP |-----------|------------------- | Nette Utils 4.0 | PHP 8.0 – 8.3 -| Nette Utils 3.2 | PHP 7.2 – 8.3 +| Nette Utils 3.2 | PHP 7.2 – 8.4 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/el/arrays.texy b/utils/el/arrays.texy index 42a4978c65..be7098e40f 100644 --- a/utils/el/arrays.texy +++ b/utils/el/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Δημιουργεί έναν νέο πίνακα μετασχηματίζοντας τις τιμές και τα κλειδιά του αρχικού πίνακα. Η συνάρτηση `$transformer` έχει την υπογραφή `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Εάν η `$transformer` επιστρέφει `null`, το στοιχείο παραλείπεται. Για στοιχεία που διατηρούνται, το πρώτο στοιχείο του επιστρεφόμενου πίνακα χρησιμοποιείται ως το νέο κλειδί και το δεύτερο στοιχείο ως η νέα τιμή. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Αυτή η μέθοδος είναι χρήσιμη σε περιπτώσεις όπου πρέπει να αλλάξετε τη δομή ενός πίνακα (και τα κλειδιά και τις τιμές ταυτόχρονα) ή να φιλτράρετε στοιχεία κατά τη διάρκεια του μετασχηματισμού (επιστρέφοντας null για ανεπιθύμητα στοιχεία). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/el/iterables.texy b/utils/el/iterables.texy index 18b7eca582..1387184803 100644 --- a/utils/el/iterables.texy +++ b/utils/el/iterables.texy @@ -11,7 +11,7 @@ composer require nette/utils ``` -Όλα τα παραδείγματα προϋποθέτουν τη δημιουργία ενός ψευδώνυμου: +Όλα τα παραδείγματα υποθέτουν ότι έχει δημιουργηθεί το ακόλουθο ψευδώνυμο: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Ελέγχει την παρουσία μιας τιμής στον επαναλήπτη. Χρησιμοποιεί αυστηρή σύγκριση (`===`). +Αναζητά μια δεδομένη τιμή σε έναν επαναλήπτη. Χρησιμοποιεί αυστηρή σύγκριση (`===`) για να ελέγξει αν υπάρχει ταύτιση. Επιστρέφει `true` αν η τιμή βρέθηκε, διαφορετικά `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Αυτή η μέθοδος είναι χρήσιμη όταν πρέπει να προσδιορίσετε γρήγορα αν μια συγκεκριμένη τιμή υπάρχει σε έναν επαναλήπτη χωρίς να κάνετε χειροκίνητη επανάληψη σε όλα τα στοιχεία. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Ελέγχει την παρουσία ενός κλειδιού στον επαναλήπτη. Χρησιμοποιεί αυστηρή σύγκριση (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Ψάχνει για ένα δεδομένο κλειδί σε έναν επαναλήπτη. Χρησιμοποιεί αυστηρή σύγκριση (`===`) για να ελέγξει αν υπάρχει ταύτιση. Επιστρέφει `true` εάν το κλειδί βρέθηκε, διαφορετικά `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Ελέγχει αν όλα τα στοιχεία του επαναλήπτη περνούν ένα τεστ που υλοποιείται στο `$predicate` με την υπογραφή `function ($value, $key, iterable $iterable): bool`. +Ελέγχει αν όλα τα στοιχεία του επαναλήπτη ικανοποιούν τη συνθήκη που ορίζεται στο `$predicate`. Η συνάρτηση `$predicate` έχει την υπογραφή `function ($value, $key, iterable $iterable): bool` και πρέπει να επιστρέφει `true` για κάθε στοιχείο, ώστε η μέθοδος `every()` να επιστρέφει `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Βλέπε [some() |#some()]. +Αυτή η μέθοδος είναι χρήσιμη για τον έλεγχο ότι όλα τα στοιχεία μιας συλλογής πληρούν μια συγκεκριμένη συνθήκη, όπως για παράδειγμα αν όλοι οι αριθμοί είναι κάτω από μια συγκεκριμένη τιμή. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Επαναλήπτης που φιλτράρει τα στοιχεία σύμφωνα με ένα κατηγόρημα. Το κατηγόρημα έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. Διατηρεί τα αρχικά κλειδιά. +Δημιουργεί έναν νέο επαναλήπτη που περιέχει μόνο τα στοιχεία από τον αρχικό επαναλήπτη που ικανοποιούν τη συνθήκη που ορίζεται στο `$predicate`. Η συνάρτηση `$predicate` έχει την υπογραφή `function ($value, $key, iterable $iterable): bool` και πρέπει να επιστρέφει `true` για τα στοιχεία που πρέπει να διατηρηθούν. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Η μέθοδος χρησιμοποιεί γεννήτρια, πράγμα που σημαίνει ότι το φιλτράρισμα γίνεται σταδιακά κατά τη διάρκεια της επανάληψης. Αυτό είναι αποδοτικό στη μνήμη και επιτρέπει το χειρισμό πολύ μεγάλων συλλογών. Εάν δεν επαναλαμβάνετε όλα τα στοιχεία του επαναλήπτη που προκύπτει, εξοικονομείτε υπολογιστική προσπάθεια, καθώς δεν επεξεργάζονται όλα τα στοιχεία του αρχικού επαναλήπτη. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Επιστρέφει το πρώτο στοιχείο (που ταιριάζει με το κατηγόρημα, αν έχει καθοριστεί). Εάν δεν υπάρχει τέτοιο στοιχείο, επιστρέφει το αποτέλεσμα της κλήσης του `$else` ή null. -Η παράμετρος `$predicate` έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. +Επιστρέφει το πρώτο στοιχείο του επαναλήπτη. Εάν παρέχεται το `$predicate`, επιστρέφει το πρώτο στοιχείο που ικανοποιεί τη δεδομένη συνθήκη. Η συνάρτηση `$predicate` έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. Εάν δεν βρεθεί κανένα στοιχείο που να ταιριάζει, καλείται η συνάρτηση `$else` (εάν παρέχεται) και επιστρέφεται το αποτέλεσμά της. Εάν δεν παρέχεται η συνάρτηση `$else`, επιστρέφεται η συνάρτηση `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Αυτή η μέθοδος είναι χρήσιμη όταν πρέπει να ανακτήσετε γρήγορα το πρώτο στοιχείο μιας συλλογής ή το πρώτο στοιχείο που πληροί μια συγκεκριμένη συνθήκη χωρίς να επαναλάβετε χειροκίνητα ολόκληρη τη συλλογή. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Επιστρέφει το κλειδί του πρώτου στοιχείου (που ταιριάζει με το κατηγόρημα, αν έχει καθοριστεί). Εάν δεν υπάρχει τέτοιο στοιχείο, επιστρέφει το αποτέλεσμα της κλήσης του `$else` ή null. Το κατηγόρημα έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. +Επιστρέφει το κλειδί του πρώτου στοιχείου του επαναλήπτη. Εάν παρέχεται το `$predicate`, επιστρέφει το κλειδί του πρώτου στοιχείου που ικανοποιεί τη δεδομένη συνθήκη. Η συνάρτηση `$predicate` έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. Εάν δεν βρεθεί κανένα στοιχείο που να ταιριάζει, καλείται η συνάρτηση `$else` (εάν παρέχεται) και επιστρέφεται το αποτέλεσμά της. Εάν δεν παρέχεται η συνάρτηση `$else`, επιστρέφεται η συνάρτηση `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Επαναλήπτης που μετασχηματίζει τις τιμές καλώντας το `$transformer`. Έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. Διατηρεί τα αρχικά κλειδιά. +Δημιουργεί έναν νέο επαναλήπτη εφαρμόζοντας τη συνάρτηση `$transformer` σε κάθε στοιχείο του αρχικού επαναλήπτη. Η συνάρτηση `$transformer` έχει την υπογραφή `function ($value, $key, iterable $iterable): mixed` και η τιμή επιστροφής της χρησιμοποιείται ως η νέα τιμή του στοιχείου. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Η μέθοδος χρησιμοποιεί γεννήτρια, πράγμα που σημαίνει ότι ο μετασχηματισμός γίνεται σταδιακά κατά τη διάρκεια της επανάληψης. Αυτό είναι αποδοτικό στη μνήμη και επιτρέπει το χειρισμό πολύ μεγάλων συλλογών. Εάν δεν επαναλαμβάνετε όλα τα στοιχεία του επαναλήπτη που προκύπτει, εξοικονομείτε υπολογιστική προσπάθεια, καθώς δεν επεξεργάζονται όλα τα στοιχεία του αρχικού επαναλήπτη. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Δημιουργεί έναν νέο επαναλήπτη μετασχηματίζοντας τις τιμές και τα κλειδιά του αρχικού επαναλήπτη. Η συνάρτηση `$transformer` έχει την υπογραφή `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Εάν η `$transformer` επιστρέφει `null`, το στοιχείο παραλείπεται. Για στοιχεία που διατηρούνται, το πρώτο στοιχείο του επιστρεφόμενου πίνακα χρησιμοποιείται ως νέο κλειδί και το δεύτερο στοιχείο ως νέα τιμή. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Όπως και η `map()`, αυτή η μέθοδος χρησιμοποιεί μια γεννήτρια για σταδιακή επεξεργασία και αποδοτικότητα μνήμης. Αυτό επιτρέπει την εργασία με μεγάλες συλλογές και την εξοικονόμηση υπολογιστικής προσπάθειας με την επεξεργασία μόνο μέρους του αποτελέσματος. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Δημιουργεί ένα περιτύλιγμα γύρω από έναν επαναλήπτη που αποθηκεύει τα κλειδιά και τις τιμές του κατά τη διάρκεια της επανάληψης. Αυτό επιτρέπει την επαναλαμβανόμενη επανάληψη των δεδομένων χωρίς να απαιτείται εκ νέου επεξεργασία της αρχικής πηγής δεδομένων. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Αυτή η μέθοδος είναι χρήσιμη σε περιπτώσεις όπου πρέπει να επαναλάβετε το ίδιο σύνολο δεδομένων πολλές φορές, αλλά ο αρχικός επαναλήπτης δεν υποστηρίζει επαναλαμβανόμενη επανάληψη ή η επαναλαμβανόμενη επανάληψη θα ήταν δαπανηρή (π.χ. ανάγνωση δεδομένων από μια βάση δεδομένων ή ένα αρχείο). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Ελέγχει αν τουλάχιστον ένα στοιχείο του επαναλήπτη περνάει ένα τεστ που υλοποιείται στο `$predicate` με την υπογραφή `function ($value, $key, iterable $iterable): bool`. +Ελέγχει αν τουλάχιστον ένα στοιχείο του επαναλήπτη ικανοποιεί τη συνθήκη που ορίζεται στο `$predicate`. Η συνάρτηση `$predicate` έχει την υπογραφή `function ($value, $key, iterable $iterable): bool` και πρέπει να επιστρέφει `true` για τουλάχιστον ένα στοιχείο, ώστε η μέθοδος `some()` να επιστρέφει `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Αυτή η μέθοδος είναι χρήσιμη για να ελέγξετε γρήγορα αν υπάρχει τουλάχιστον ένα στοιχείο σε μια συλλογή που πληροί μια συγκεκριμένη συνθήκη, όπως για παράδειγμα αν η συλλογή περιέχει τουλάχιστον έναν ζυγό αριθμό. + Βλέπε [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Μετατρέπει οποιοδήποτε αντικείμενο επανάληψης (array, Traversable) σε Iterator. Εάν η είσοδος είναι ήδη ένας Iterator, επιστρέφεται αμετάβλητος. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Αυτή η μέθοδος είναι χρήσιμη όταν πρέπει να διασφαλίσετε ότι έχετε έναν Iterator, ανεξάρτητα από τον τύπο δεδομένων εισόδου. Αυτό μπορεί να είναι χρήσιμο κατά τη δημιουργία συναρτήσεων που λειτουργούν με διαφορετικούς τύπους επαναληπτικών δεδομένων. diff --git a/utils/el/strings.texy b/utils/el/strings.texy index f5afa11171..53e552ad15 100644 --- a/utils/el/strings.texy +++ b/utils/el/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Ψάχνει τη συμβολοσειρά για όλες τις εμφανίσεις που ταιριάζουν με την κανονική έκφραση και επιστρέφει έναν πίνακα πινάκων που περιέχει την έκφραση που βρέθηκε και κάθε υποέκφραση. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Εάν το `$lazy` είναι `true`, η συνάρτηση επιστρέφει ένα `Generator` αντί για έναν πίνακα, γεγονός που παρέχει σημαντικά οφέλη στην απόδοση όταν εργάζεστε με μεγάλες συμβολοσειρές. Η γεννήτρια επιτρέπει τη σταδιακή εύρεση αντιστοιχιών, αντί να επεξεργάζεται ολόκληρη τη συμβολοσειρά με τη μία. Αυτό επιτρέπει τον αποτελεσματικό χειρισμό εξαιρετικά μεγάλων κειμένων εισόδου. Επιπλέον, μπορείτε να διακόψετε την επεξεργασία ανά πάσα στιγμή εάν βρείτε την επιθυμητή αντιστοιχία, εξοικονομώντας υπολογιστικό χρόνο. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/en/@home.texy b/utils/en/@home.texy index 9e59fa504c..bbd39a8616 100644 --- a/utils/en/@home.texy +++ b/utils/en/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | version | compatible with PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 – 3.1 | PHP 7.1 – 8.0 | Nette Utils 2.5 | PHP 5.6 – 8.0 diff --git a/utils/en/arrays.texy b/utils/en/arrays.texy index a529286644..dfe202c550 100644 --- a/utils/en/arrays.texy +++ b/utils/en/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Creates a new array by transforming the values and keys of the original array. The function `$transformer` has the signature `function ($value, $key, array $array): ?array{$newValue, $newKey}`. If `$transformer` returns `null`, the element is skipped. For retained elements, the first element of the returned array is used as the new key and the second element as the new value. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +This method is useful in situations where you need to change the structure of an array (both keys and values simultaneously) or filter elements during transformation (by returning null for unwanted elements). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/en/iterables.texy b/utils/en/iterables.texy index b348fdf336..75378c2b87 100644 --- a/utils/en/iterables.texy +++ b/utils/en/iterables.texy @@ -11,7 +11,7 @@ Installation: composer require nette/utils ``` -All examples assume the creation of an alias: +All examples assume the following alias is created: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Tests for the presence of a value in the iterator. It uses strict comparison (`===`). +Searches for a given value in an iterator. Uses strict comparison (`===`) to check for a match. Returns `true` if the value is found, otherwise `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +This method is useful when you need to quickly determine if a specific value is present in an iterator without manually iterating through all elements. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Tests for the presence of a key in the iterator. It uses strict comparison (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Searches for a given key in an iterator. Uses strict comparison (`===`) to check for a match. Returns `true` if the key is found, otherwise `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Tests whether all elements of the iterator pass a test implemented in `$predicate` with the signature `function ($value, $key, iterable $iterable): bool`. +Checks if all elements of the iterator satisfy the condition defined in `$predicate`. The function `$predicate` has the signature `function ($value, $key, iterable $iterable): bool` and must return `true` for every element for the `every()` method to return `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -See [#some()]. +This method is useful for verifying that all elements in a collection meet a certain condition, such as whether all numbers are below a specific value. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterator that filters elements according to a predicate. The predicate has the signature `function ($value, $key, iterable $iterable): bool`. Maintains original keys. +Creates a new iterator that contains only the elements from the original iterator that satisfy the condition defined in `$predicate`. The function `$predicate` has the signature `function ($value, $key, iterable $iterable): bool` and must return `true` for elements that should be retained. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +The method uses a generator, meaning that filtering occurs incrementally during iteration. This is memory efficient and allows for handling very large collections. If you do not iterate through all elements of the resulting iterator, you save computational effort since not all elements of the original iterator are processed. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Returns the first item (matching the predicate, if specified). If no such item exists, returns the result of calling `$else` or null. -The `$predicate` parameter has the signature `function ($value, $key, iterable $iterable): bool`. +Returns the first element of the iterator. If `$predicate` is provided, it returns the first element that satisfies the given condition. The function `$predicate` has the signature `function ($value, $key, iterable $iterable): bool`. If no matching element is found, the `$else` function (if provided) is called and its result is returned. If `$else` is not provided, `null` is returned. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +This method is useful when you need to quickly retrieve the first element of a collection or the first element that meets a certain condition without manually iterating through the entire collection. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Returns the key of the first item (matching the predicate, if specified). If no such item exists, returns the result of calling `$else` or null. The predicate has the signature `function ($value, $key, iterable $iterable): bool`. +Returns the key of the first element of the iterator. If `$predicate` is provided, it returns the key of the first element that satisfies the given condition. The function `$predicate` has the signature `function ($value, $key, iterable $iterable): bool`. If no matching element is found, the `$else` function (if provided) is called and its result is returned. If `$else` is not provided, `null` is returned. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterator that transforms values by calling `$transformer`. It has the signature `function ($value, $key, iterable $iterable): bool`. Maintains original keys. +Creates a new iterator by applying the `$transformer` function to each element of the original iterator. The function `$transformer` has the signature `function ($value, $key, iterable $iterable): mixed` and its return value is used as the new value of the element. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +The method uses a generator, meaning that the transformation occurs incrementally during iteration. This is memory efficient and allows for handling very large collections. If you do not iterate through all elements of the resulting iterator, you save computational effort since not all elements of the original iterator are processed. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Creates a new iterator by transforming the values and keys of the original iterator. The function `$transformer` has the signature `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. If `$transformer` returns `null`, the element is skipped. For retained elements, the first element of the returned array is used as the new key and the second element as the new value. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Like `map()`, this method uses a generator for incremental processing and memory efficiency. This allows working with large collections and saving computational effort by processing only part of the result. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Creates a wrapper around an iterator that caches its keys and values during iteration. This allows for repeated iteration over the data without having to reprocess the original data source. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +This method is useful in situations where you need to iterate over the same set of data multiple times, but the original iterator does not support repeated iteration or repeated iteration would be costly (e.g., reading data from a database or file). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Tests whether at least one element of the iterator passes a test implemented in `$predicate` with the signature `function ($value, $key, iterable $iterable): bool`. +Checks if at least one element of the iterator satisfies the condition defined in `$predicate`. The function `$predicate` has the signature `function ($value, $key, iterable $iterable): bool` and must return `true` for at least one element for the `some()` method to return `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +This method is useful for quickly verifying if there is at least one element in a collection that meets a certain condition, such as whether the collection contains at least one even number. + See [#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Converts any iterable object (array, Traversable) to an Iterator. If the input is already an Iterator, it is returned unchanged. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +This method is useful when you need to ensure that you have an Iterator, regardless of the input data type. This can be useful when creating functions that work with different types of iterable data. diff --git a/utils/en/strings.texy b/utils/en/strings.texy index cea37f2e31..f8cc42ad66 100644 --- a/utils/en/strings.texy +++ b/utils/en/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Searches the string for all occurrences matching the regular expression and returns an array of arrays containing the found expression and each subexpression. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +If `$lazy` is `true`, the function returns a `Generator` instead of an array, which provides significant performance benefits when working with large strings. The generator allows for matches to be found incrementally, rather than processing the entire string at once. This enables efficient handling of extremely large input texts. Additionally, you can interrupt processing at any time if you find the desired match, saving computational time. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/es/@home.texy b/utils/es/@home.texy index 0bfdbb5347..13358a81fd 100644 --- a/utils/es/@home.texy +++ b/utils/es/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | versión | compatible con PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/es/arrays.texy b/utils/es/arrays.texy index 8f3956f59c..bc6bfa0127 100644 --- a/utils/es/arrays.texy +++ b/utils/es/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Crea un nuevo array transformando los valores y claves del array original. La función `$transformer` tiene la firma `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Si `$transformer` devuelve `null`, el elemento se omite. Para los elementos retenidos, el primer elemento de la matriz devuelta se utiliza como la nueva clave y el segundo elemento como el nuevo valor. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Este método es útil en situaciones en las que se necesita cambiar la estructura de una matriz (tanto claves como valores simultáneamente) o filtrar elementos durante la transformación (devolviendo null para los elementos no deseados). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/es/iterables.texy b/utils/es/iterables.texy index fd4aa9ef4f..8307fa4871 100644 --- a/utils/es/iterables.texy +++ b/utils/es/iterables.texy @@ -2,7 +2,7 @@ Funciones de iteración ********************** .[perex]{data-version:4.0.4} -[api:Nette\Utils\Iterables] es una clase estática con funciones para trabajar con iteradores. Su homólogo para arrays es [Nette\Utils\Arrays |arrays]. +[api:Nette\Utils\Iterables] es una clase estática con funciones para trabajar con iteradores. Su contrapartida para arrays es [Nette\Utils\Arrays |arrays]. Instalación: @@ -11,7 +11,7 @@ Instalación: composer require nette/utils ``` -Todos los ejemplos suponen la creación de un alias: +Todos los ejemplos suponen que se ha creado el siguiente alias: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Comprueba la presencia de un valor en el iterador. Utiliza la comparación estricta (`===`). +Busca un valor dado en un iterador. Utiliza la comparación estricta (`===`) para buscar una coincidencia. Devuelve `true` si se encuentra el valor, en caso contrario `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Este método es útil cuando se necesita determinar rápidamente si un valor específico está presente en un iterador sin iterar manualmente a través de todos los elementos. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Comprueba la presencia de una clave en el iterador. Utiliza la comparación estricta (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Busca una clave dada en un iterador. Utiliza la comparación estricta (`===`) para buscar una coincidencia. Devuelve `true` si se encuentra la clave, en caso contrario `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Comprueba si todos los elementos del iterador pasan una prueba implementada en `$predicate` con la firma `function ($value, $key, iterable $iterable): bool`. +Comprueba si todos los elementos del iterador cumplen la condición definida en `$predicate`. La función `$predicate` tiene la firma `function ($value, $key, iterable $iterable): bool` y debe devolver `true` para cada elemento para que el método `every()` devuelva `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Véase [some() |#some()]. +Este método es útil para verificar que todos los elementos de una colección cumplen una determinada condición, como por ejemplo si todos los números están por debajo de un valor específico. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterador que filtra elementos según un predicado. El predicado tiene la firma `function ($value, $key, iterable $iterable): bool`. Mantiene las claves originales. +Crea un nuevo iterador que contiene sólo los elementos del iterador original que satisfacen la condición definida en `$predicate`. La función `$predicate` tiene la firma `function ($value, $key, iterable $iterable): bool` y debe devolver `true` para los elementos que deben conservarse. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +El método utiliza un generador, lo que significa que el filtrado se produce de forma incremental durante la iteración. Esto es eficiente en memoria y permite manejar colecciones muy grandes. Si no se itera por todos los elementos del iterador resultante, se ahorra esfuerzo computacional, ya que no se procesan todos los elementos del iterador original. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Devuelve el primer elemento (que coincida con el predicado, si se especifica). Si no existe tal elemento, devuelve el resultado de llamar a `$else` o null. -El parámetro `$predicate` tiene la firma `function ($value, $key, iterable $iterable): bool`. +Devuelve el primer elemento del iterador. Si se proporciona `$predicate`, devuelve el primer elemento que satisface la condición dada. La función `$predicate` tiene la firma `function ($value, $key, iterable $iterable): bool`. Si no se encuentra ningún elemento coincidente, se llama a la función `$else` (si se proporciona) y se devuelve su resultado. Si no se proporciona `$else`, se devuelve `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Este método es útil cuando se necesita recuperar rápidamente el primer elemento de una colección o el primer elemento que cumple una determinada condición sin iterar manualmente por toda la colección. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Devuelve la clave del primer elemento (que coincida con el predicado, si se especifica). Si no existe tal elemento, devuelve el resultado de llamar a `$else` o null. El predicado tiene la firma `function ($value, $key, iterable $iterable): bool`. +Devuelve la clave del primer elemento del iterador. Si se proporciona `$predicate`, devuelve la clave del primer elemento que satisface la condición dada. La función `$predicate` tiene la firma `function ($value, $key, iterable $iterable): bool`. Si no se encuentra ningún elemento coincidente, se llama a la función `$else` (si se proporciona) y se devuelve su resultado. Si no se proporciona `$else`, se devuelve `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterador que transforma valores llamando a `$transformer`. Tiene la firma `function ($value, $key, iterable $iterable): bool`. Mantiene las claves originales. +Crea un nuevo iterador aplicando la función `$transformer` a cada elemento del iterador original. La función `$transformer` tiene la firma `function ($value, $key, iterable $iterable): mixed` y su valor de retorno se utiliza como el nuevo valor del elemento. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +El método utiliza un generador, lo que significa que la transformación se produce de forma incremental durante la iteración. Esto es eficiente en memoria y permite manejar colecciones muy grandes. Si no se itera por todos los elementos del iterador resultante, se ahorra esfuerzo computacional, ya que no se procesan todos los elementos del iterador original. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Crea un nuevo iterador transformando los valores y claves del iterador original. La función `$transformer` tiene la firma `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Si `$transformer` devuelve `null`, el elemento se omite. Para los elementos retenidos, el primer elemento del array devuelto se utiliza como la nueva clave y el segundo elemento como el nuevo valor. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Al igual que `map()`, este método utiliza un generador para el procesamiento incremental y la eficiencia de memoria. Esto permite trabajar con grandes colecciones y ahorrar esfuerzo computacional procesando sólo una parte del resultado. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Crea una envoltura alrededor de un iterador que almacena en caché sus claves y valores durante la iteración. Esto permite repetir la iteración sobre los datos sin tener que reprocesar la fuente de datos original. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Este método es útil en situaciones en las que se necesita iterar sobre el mismo conjunto de datos varias veces, pero el iterador original no soporta la iteración repetida o la iteración repetida sería costosa (por ejemplo, la lectura de datos de una base de datos o archivo). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Comprueba si al menos un elemento del iterador pasa una prueba implementada en `$predicate` con la firma `function ($value, $key, iterable $iterable): bool`. +Comprueba si al menos un elemento del iterador cumple la condición definida en `$predicate`. La función `$predicate` tiene la firma `function ($value, $key, iterable $iterable): bool` y debe devolver `true` para al menos un elemento para que el método `some()` devuelva `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Este método es útil para verificar rápidamente si hay al menos un elemento en una colección que cumpla una determinada condición, como por ejemplo si la colección contiene al menos un número par. + Véase [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Convierte cualquier objeto iterable (array, Traversable) en un Iterator. Si la entrada ya es un Iterador, se devuelve sin cambios. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Este método es útil cuando necesitas asegurarte de que tienes un Iterator, independientemente del tipo de datos de entrada. Esto puede ser útil cuando se crean funciones que trabajan con diferentes tipos de datos iterables. diff --git a/utils/es/strings.texy b/utils/es/strings.texy index 97a3af980b..c8c22a59a9 100644 --- a/utils/es/strings.texy +++ b/utils/es/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Busca en la cadena todas las ocurrencias que coincidan con la expresión regular y devuelve una matriz de matrices que contiene la expresión encontrada y cada subexpresión. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Si `$lazy` es `true`, la función devuelve un `Generator` en lugar de una matriz, lo que proporciona importantes ventajas de rendimiento cuando se trabaja con cadenas de gran tamaño. El generador permite encontrar coincidencias de forma incremental, en lugar de procesar toda la cadena a la vez. Esto permite trabajar con textos de entrada de gran tamaño. Además, puede interrumpir el procesamiento en cualquier momento si encuentra la coincidencia deseada, lo que ahorra tiempo de cálculo. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/fr/@home.texy b/utils/fr/@home.texy index 174f8aadf2..7d16be9d5d 100644 --- a/utils/fr/@home.texy +++ b/utils/fr/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | version | compatible avec PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/fr/arrays.texy b/utils/fr/arrays.texy index bf9ad09adf..53ac7c466e 100644 --- a/utils/fr/arrays.texy +++ b/utils/fr/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Crée un nouveau tableau en transformant les valeurs et les clés du tableau original. La fonction `$transformer` a pour signature `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Si `$transformer` renvoie `null`, l'élément est ignoré. Pour les éléments conservés, le premier élément du tableau retourné est utilisé comme nouvelle clé et le deuxième élément comme nouvelle valeur. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Cette méthode est utile dans les situations où vous devez modifier la structure d'un tableau (à la fois les clés et les valeurs) ou filtrer les éléments au cours de la transformation (en renvoyant null pour les éléments non souhaités). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/fr/iterables.texy b/utils/fr/iterables.texy index cc63f3c5c7..ece43bc2db 100644 --- a/utils/fr/iterables.texy +++ b/utils/fr/iterables.texy @@ -11,7 +11,7 @@ L'installation : composer require nette/utils ``` -Tous les exemples supposent la création d'un alias : +Tous les exemples supposent que l'alias suivant a été créé : ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Teste la présence d'une valeur dans l'itérateur. Il utilise une comparaison stricte (`===`). +Recherche une valeur donnée dans un itérateur. Utilise une comparaison stricte (`===`) pour vérifier la correspondance. Retourne `true` si la valeur est trouvée, sinon `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Cette méthode est utile pour déterminer rapidement si une valeur spécifique est présente dans un itérateur sans avoir à parcourir manuellement tous les éléments. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Teste la présence d'une clé dans l'itérateur. Il utilise la comparaison stricte (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Recherche une clé donnée dans un itérateur. Utilise une comparaison stricte (`===`) pour vérifier s'il y a une correspondance. Retourne `true` si la clé est trouvée, sinon `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Teste si tous les éléments de l'itérateur passent un test implémenté dans `$predicate` avec la signature `function ($value, $key, iterable $iterable): bool`. +Vérifie si tous les éléments de l'itérateur satisfont à la condition définie dans `$predicate`. La fonction `$predicate` a pour signature `function ($value, $key, iterable $iterable): bool` et doit renvoyer `true` pour chaque élément pour que la méthode `every()` renvoie `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Voir [some() |#some()]. +Cette méthode est utile pour vérifier que tous les éléments d'une collection remplissent une certaine condition, par exemple si tous les nombres sont inférieurs à une valeur spécifique. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Itérateur qui filtre les éléments en fonction d'un prédicat. Le prédicat a la signature `function ($value, $key, iterable $iterable): bool`. Maintient les clés d'origine. +Crée un nouvel itérateur qui ne contient que les éléments de l'itérateur original qui satisfont à la condition définie dans `$predicate`. La fonction `$predicate` a pour signature `function ($value, $key, iterable $iterable): bool` et doit renvoyer `true` pour les éléments qui doivent être conservés. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +La méthode utilise un générateur, ce qui signifie que le filtrage s'effectue de manière incrémentielle au cours de l'itération. Cette méthode est économe en mémoire et permet de traiter de très grandes collections. Si vous n'itérez pas sur tous les éléments de l'itérateur résultant, vous économisez des efforts de calcul puisque tous les éléments de l'itérateur d'origine ne sont pas traités. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Renvoie le premier élément (correspondant au prédicat, s'il est spécifié). Si aucun élément de ce type n'existe, il renvoie le résultat de l'appel à `$else` ou null. -Le paramètre `$predicate` a la signature `function ($value, $key, iterable $iterable): bool`. +Renvoie le premier élément de l'itérateur. Si `$predicate` est fourni, il renvoie le premier élément qui satisfait à la condition donnée. La fonction `$predicate` a pour signature `function ($value, $key, iterable $iterable): bool`. Si aucun élément correspondant n'est trouvé, la fonction `$else` (si elle est fournie) est appelée et son résultat est renvoyé. Si `$else` n'est pas fourni, `null` est renvoyé. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Cette méthode est utile pour récupérer rapidement le premier élément d'une collection ou le premier élément qui répond à une certaine condition sans avoir à parcourir manuellement l'ensemble de la collection. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Renvoie la clé du premier élément (correspondant au prédicat, s'il est spécifié). Si aucun élément de ce type n'existe, il renvoie le résultat de l'appel à `$else` ou null. Le prédicat a la signature `function ($value, $key, iterable $iterable): bool`. +Renvoie la clé du premier élément de l'itérateur. Si `$predicate` est fourni, il renvoie la clé du premier élément qui satisfait à la condition donnée. La fonction `$predicate` a pour signature `function ($value, $key, iterable $iterable): bool`. Si aucun élément correspondant n'est trouvé, la fonction `$else` (si elle est fournie) est appelée et son résultat est renvoyé. Si `$else` n'est pas fourni, `null` est renvoyé. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Itérateur qui transforme les valeurs en appelant `$transformer`. Il porte la signature `function ($value, $key, iterable $iterable): bool`. Il conserve les clés d'origine. +Crée un nouvel itérateur en appliquant la fonction `$transformer` à chaque élément de l'itérateur original. La fonction `$transformer` a pour signature `function ($value, $key, iterable $iterable): mixed` et sa valeur de retour est utilisée comme nouvelle valeur de l'élément. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +La méthode utilise un générateur, ce qui signifie que la transformation se produit de manière incrémentielle au cours de l'itération. Cela permet d'économiser de la mémoire et de traiter de très grandes collections. Si vous n'itérez pas sur tous les éléments de l'itérateur résultant, vous économisez des efforts de calcul puisque tous les éléments de l'itérateur d'origine ne sont pas traités. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Crée un nouvel itérateur en transformant les valeurs et les clés de l'itérateur original. La fonction `$transformer` a pour signature `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Si `$transformer` renvoie `null`, l'élément est ignoré. Pour les éléments conservés, le premier élément du tableau retourné est utilisé comme nouvelle clé et le deuxième élément comme nouvelle valeur. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Comme `map()`, cette méthode utilise un générateur pour le traitement incrémental et l'efficacité de la mémoire. Cela permet de travailler avec de grandes collections et d'économiser l'effort de calcul en ne traitant qu'une partie du résultat. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Crée une enveloppe autour d'un itérateur qui met en cache ses clés et ses valeurs pendant l'itération. Cela permet de répéter l'itération sur les données sans avoir à retraiter la source de données d'origine. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Cette méthode est utile dans les situations où vous devez itérer plusieurs fois sur le même ensemble de données, mais où l'itérateur original ne supporte pas l'itération répétée ou l'itération répétée serait coûteuse (par exemple, la lecture de données à partir d'une base de données ou d'un fichier). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Teste si au moins un élément de l'itérateur passe un test implémenté dans `$predicate` avec la signature `function ($value, $key, iterable $iterable): bool`. +Vérifie si au moins un élément de l'itérateur satisfait à la condition définie dans `$predicate`. La fonction `$predicate` a pour signature `function ($value, $key, iterable $iterable): bool` et doit retourner `true` pour au moins un élément pour que la méthode `some()` retourne `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Cette méthode est utile pour vérifier rapidement si au moins un élément d'une collection remplit une certaine condition, par exemple si la collection contient au moins un nombre pair. + Voir [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Convertit n'importe quel objet itérable (tableau, Traversable) en un Iterator. Si l'entrée est déjà un Iterator, elle est retournée inchangée. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Cette méthode est utile lorsque vous devez vous assurer que vous disposez d'un itérateur, quel que soit le type de données en entrée. Cela peut être utile lors de la création de fonctions qui fonctionnent avec différents types de données itérables. diff --git a/utils/fr/strings.texy b/utils/fr/strings.texy index 57fb7eaf41..0e389311fa 100644 --- a/utils/fr/strings.texy +++ b/utils/fr/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Recherche dans la chaîne toutes les occurrences correspondant à l'expression régulière et renvoie un tableau de tableaux contenant l'expression trouvée et chaque sous-expression. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Si `$lazy` est `true`, la fonction renvoie un `Generator` au lieu d'un tableau, ce qui offre des avantages considérables en termes de performances lorsque l'on travaille avec des chaînes de grande taille. Le générateur permet de trouver les correspondances de manière incrémentielle, plutôt que de traiter l'ensemble de la chaîne en une seule fois. Cela permet de traiter efficacement des textes d'entrée extrêmement volumineux. En outre, vous pouvez interrompre le traitement à tout moment si vous trouvez la correspondance souhaitée, ce qui permet d'économiser du temps de calcul. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/hu/@home.texy b/utils/hu/@home.texy index 9597ed506f..739b6393f4 100644 --- a/utils/hu/@home.texy +++ b/utils/hu/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | verzió | kompatibilis a PHP-vel |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/hu/arrays.texy b/utils/hu/arrays.texy index 178927eb84..92177a341a 100644 --- a/utils/hu/arrays.texy +++ b/utils/hu/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Új tömböt hoz létre az eredeti tömb értékeinek és kulcsainak átalakításával. A `$transformer` függvény aláírása: `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Ha a `$transformer` visszatér `null`, az elemet kihagyja. A megtartott elemek esetében a visszaadott tömb első eleme az új kulcs, a második elem pedig az új érték. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Ez a módszer olyan helyzetekben hasznos, amikor egy tömb szerkezetét kell megváltoztatni (egyszerre a kulcsokat és az értékeket), vagy az elemeket kell szűrni az átalakítás során (a nem kívánt elemek nullának visszaadásával). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/hu/iterables.texy b/utils/hu/iterables.texy index 8abc933d62..6133ff8ff2 100644 --- a/utils/hu/iterables.texy +++ b/utils/hu/iterables.texy @@ -2,7 +2,7 @@ Iterátor funkciók ***************** .[perex]{data-version:4.0.4} -[api:Nette\Utils\Iterables] egy statikus osztály, amely az iterátorokkal való munkához szükséges függvényeket tartalmazza. A tömbökre vonatkozó megfelelője a [Nette\Utils\Arrays |arrays]. +[api:Nette\Utils\Iterables] egy statikus osztály az iterátorokkal való munkához szükséges függvényekkel. A tömbökre vonatkozó megfelelője a [Nette\Utils\Arrays |arrays]. Telepítés: @@ -11,7 +11,7 @@ Telepítés: composer require nette/utils ``` -Minden példa feltételezi egy alias létrehozását: +Minden példa feltételezi a következő alias létrehozását: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Az iterátorban lévő érték jelenlétének vizsgálata. Szigorú összehasonlítást használ (`===`). +Egy adott értéket keres egy iterátorban. Szigorú összehasonlítást (`===`) használ az egyezés ellenőrzésére. Visszaadja a `true` értéket, ha az értéket megtalálta, egyébként `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Ez a módszer akkor hasznos, ha gyorsan meg kell állapítani, hogy egy adott érték jelen van-e egy iterátorban anélkül, hogy manuálisan végig kellene iterálni az összes elemet. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Az iterátorban lévő kulcs jelenlétét vizsgálja. Szigorú összehasonlítást használ (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Egy adott kulcs keresése egy iterátorban. Szigorú összehasonlítást (`===`) használ az egyezés keresésére. Visszaadja `true` ha a kulcsot megtalálta, egyébként `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Azt vizsgálja, hogy az iterátor minden eleme megfelel-e a `$predicate` -ban megvalósított, `function ($value, $key, iterable $iterable): bool` aláírással ellátott tesztnek. +Ellenőrzi, hogy az iterátor minden eleme megfelel-e a `$predicate` pontban meghatározott feltételnek. A `$predicate` függvénynek a `function ($value, $key, iterable $iterable): bool` aláírása van, és minden elemre vissza kell adnia a `true` értéket ahhoz, hogy a `every()` módszer a `true` értéket adja vissza. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Lásd [some() |#some()]. +Ez a módszer hasznos annak ellenőrzésére, hogy egy gyűjtemény minden eleme megfelel-e egy bizonyos feltételnek, például annak, hogy az összes szám egy adott érték alatt van-e. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterátor, amely az elemeket egy predikátum alapján szűri. A predikátum aláírása `function ($value, $key, iterable $iterable): bool`. Fenntartja az eredeti kulcsokat. +Létrehoz egy új iterátort, amely csak azokat az elemeket tartalmazza az eredeti iterátorból, amelyek megfelelnek a `$predicate` pontban meghatározott feltételnek. A `$predicate` függvény aláírása `function ($value, $key, iterable $iterable): bool`, és a megtartandó elemek esetében a `true` függvényt kell visszaadnia. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +A módszer generátort használ, ami azt jelenti, hogy a szűrés az iteráció során inkrementálisan történik. Ez memóriahatékony és lehetővé teszi a nagyon nagy gyűjtemények kezelését. Ha nem iteráljuk végig az eredményül kapott iterátor minden elemét, akkor számítási energiát takarítunk meg, mivel az eredeti iterátor nem minden elemét dolgozzuk fel. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Visszaadja az első elemet (amely megfelel a predikátumnak, ha meg van adva). Ha ilyen elem nem létezik, a `$else` hívásának eredményét vagy nullát adja vissza. -A `$predicate` paraméter aláírása `function ($value, $key, iterable $iterable): bool`. +Visszaadja az iterátor első elemét. Ha a `$predicate` megadva van, akkor az első olyan elemet adja vissza, amely megfelel a megadott feltételnek. A `$predicate` függvény aláírása `function ($value, $key, iterable $iterable): bool`. Ha nem talál megfelelő elemet, akkor a `$else` függvényt (ha megadva van) hívja meg, és annak eredményét adja vissza. Ha a `$else` nincs megadva, akkor a `null` függvényt adja vissza. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Ez a módszer akkor hasznos, ha gyorsan ki kell kérni egy gyűjtemény első elemét vagy az első olyan elemet, amely megfelel egy bizonyos feltételnek, anélkül, hogy manuálisan végig kellene iterálni a teljes gyűjteményt. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Visszaadja az első elem kulcsát (amely megfelel a predikátumnak, ha meg van adva). Ha ilyen elem nem létezik, a `$else` hívásának eredményét vagy nullát adja vissza. A predikátum aláírása `function ($value, $key, iterable $iterable): bool`. +Visszaadja az iterátor első elemének kulcsát. Ha `$predicate` van megadva, akkor a megadott feltételnek megfelelő első elem kulcsát adja vissza. A `$predicate` függvény aláírása `function ($value, $key, iterable $iterable): bool`. Ha nem találunk megfelelő elemet, akkor a `$else` függvényt (ha megadva van) hívja meg, és annak eredményét adja vissza. Ha a `$else` nincs megadva, akkor a `null` függvényt adja vissza. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterátor, amely az értékeket a `$transformer` meghívásával alakítja át. Aláírása: `function ($value, $key, iterable $iterable): bool`. Fenntartja az eredeti kulcsokat. +Új iterátort hoz létre a `$transformer` függvénynek az eredeti iterátor minden elemére történő alkalmazásával. A `$transformer` függvény aláírása `function ($value, $key, iterable $iterable): mixed`, és visszatérési értéke az elem új értékeként kerül felhasználásra. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +A módszer generátort használ, ami azt jelenti, hogy az átalakítás az iteráció során inkrementálisan történik. Ez memóriahatékony és lehetővé teszi a nagyon nagy gyűjtemények kezelését. Ha nem iteráljuk végig az eredményül kapott iterátor minden elemét, akkor számítási erőfeszítést takarítunk meg, mivel az eredeti iterátor nem minden elemét dolgozzuk fel. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Új iterátort hoz létre az eredeti iterátor értékeinek és kulcsainak átalakításával. A `$transformer` függvény aláírása: `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Ha a `$transformer` visszatér `null`, akkor az elemet kihagyja. A megtartott elemek esetében a visszaadott tömb első elemét használja új kulcsként, a második elemet pedig új értékként. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +A `map()` módszerhez hasonlóan ez a módszer is generátort használ a növekményes feldolgozás és a memóriahatékonyság érdekében. Ez lehetővé teszi a nagy gyűjteményekkel való munkát és a számítási erőfeszítés megtakarítását azáltal, hogy az eredménynek csak egy részét dolgozza fel. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Létrehoz egy burkolatot egy iterátor körül, amely az iteráció során a kulcsokat és az értékeket gyorsítótárba helyezi. Ez lehetővé teszi az adatok ismételt iterálását anélkül, hogy az eredeti adatforrást újra fel kellene dolgozni. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Ez a módszer olyan helyzetekben hasznos, amikor többször kell ugyanazon az adathalmazon iterálni, de az eredeti iterátor nem támogatja az ismételt iterációt, vagy az ismételt iteráció költséges lenne (pl. adatok olvasása adatbázisból vagy fájlból). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Azt vizsgálja, hogy az iterátor legalább egy eleme megfelel-e a `$predicate` nyelven megvalósított, `function ($value, $key, iterable $iterable): bool` aláírással ellátott tesztnek. +Ellenőrzi, hogy az iterátor legalább egy eleme megfelel-e a `$predicate` pontban meghatározott feltételnek. A `$predicate` függvénynek a `function ($value, $key, iterable $iterable): bool` aláírása van, és legalább egy elemre vonatkozóan vissza kell adnia a `true` értéket, hogy a `some()` módszer a `true` értéket adja vissza. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Ez a módszer hasznos annak gyors ellenőrzésére, hogy van-e legalább egy olyan elem egy gyűjteményben, amely megfelel egy bizonyos feltételnek, például, hogy a gyűjtemény tartalmaz-e legalább egy páros számot. + Lásd [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Bármilyen iterálható objektumot (tömb, Traversable) Iterátorrá alakít. Ha a bemenet már egy Iterator, akkor azt változatlanul adja vissza. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Ez a metódus akkor hasznos, ha a bemeneti adattípustól függetlenül biztosítani kell, hogy egy Iterátorral rendelkezzünk. Ez hasznos lehet olyan függvények létrehozásakor, amelyek különböző típusú iterálható adatokkal dolgoznak. diff --git a/utils/hu/strings.texy b/utils/hu/strings.texy index e81a276a8b..2cd9b3eae9 100644 --- a/utils/hu/strings.texy +++ b/utils/hu/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Megkeresi a karakterlánc minden olyan előfordulását, amely megfelel a reguláris kifejezésnek, és egy olyan tömböt ad vissza, amely tartalmazza a talált kifejezést és az egyes részkifejezéseket. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Ha a `$lazy` értéke `true`, a függvény egy tömb helyett egy `Generator` értéket ad vissza, ami jelentős teljesítményelőnyt jelent a nagy karakterláncokkal való munka során. A generátor lehetővé teszi, hogy az egyezéseket fokozatosan találjuk meg, ahelyett, hogy a teljes karakterláncot egyszerre feldolgoznánk. Ez lehetővé teszi a rendkívül nagy bemeneti szövegek hatékony kezelését. Ezenkívül bármikor megszakíthatja a feldolgozást, ha megtalálja a kívánt egyezést, így számítási időt takaríthat meg. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/it/@home.texy b/utils/it/@home.texy index f1d7290a66..43e6e34c48 100644 --- a/utils/it/@home.texy +++ b/utils/it/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | versione | compatibile con PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/it/arrays.texy b/utils/it/arrays.texy index cf43f008ad..b9bf4654db 100644 --- a/utils/it/arrays.texy +++ b/utils/it/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Crea un nuovo array trasformando i valori e le chiavi dell'array originale. La funzione `$transformer` ha la firma `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Se `$transformer` restituisce `null`, l'elemento viene saltato. Per gli elementi mantenuti, il primo elemento dell'array restituito viene utilizzato come nuova chiave e il secondo elemento come nuovo valore. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Questo metodo è utile nelle situazioni in cui è necessario modificare la struttura di un array (sia le chiavi che i valori contemporaneamente) o filtrare gli elementi durante la trasformazione (restituendo null per gli elementi indesiderati). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/it/iterables.texy b/utils/it/iterables.texy index c0b5462503..5d98ac0ca9 100644 --- a/utils/it/iterables.texy +++ b/utils/it/iterables.texy @@ -11,7 +11,7 @@ Installazione: composer require nette/utils ``` -Tutti gli esempi presuppongono la creazione di un alias: +Tutti gli esempi presuppongono la creazione del seguente alias: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Verifica la presenza di un valore nell'iteratore. Utilizza un confronto rigoroso (`===`). +Cerca un valore dato in un iteratore. Utilizza un confronto rigoroso (`===`) per verificare la corrispondenza. Restituisce `true` se il valore viene trovato, altrimenti `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Questo metodo è utile quando è necessario determinare rapidamente se un valore specifico è presente in un iteratore, senza iterare manualmente tutti gli elementi. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Verifica la presenza di una chiave nell'iteratore. Utilizza un confronto rigoroso (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Cerca una determinata chiave in un iteratore. Utilizza un confronto rigoroso (`===`) per verificare la corrispondenza. Restituisce `true` se la chiave viene trovata, altrimenti `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Verifica se tutti gli elementi dell'iteratore superano un test implementato in `$predicate` con la firma `function ($value, $key, iterable $iterable): bool`. +Verifica se tutti gli elementi dell'iteratore soddisfano la condizione definita in `$predicate`. La funzione `$predicate` ha la firma `function ($value, $key, iterable $iterable): bool` e deve restituire `true` per ogni elemento affinché il metodo `every()` restituisca `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Vedere [some() |#some()]. +Questo metodo è utile per verificare che tutti gli elementi di un insieme soddisfino una certa condizione, ad esempio se tutti i numeri sono inferiori a un valore specifico. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iteratore che filtra gli elementi in base a un predicato. Il predicato ha la firma `function ($value, $key, iterable $iterable): bool`. Mantiene le chiavi originali. +Crea un nuovo iteratore che contiene solo gli elementi dell'iteratore originale che soddisfano la condizione definita in `$predicate`. La funzione `$predicate` ha la firma `function ($value, $key, iterable $iterable): bool` e deve restituire `true` per gli elementi che devono essere mantenuti. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Il metodo utilizza un generatore, il che significa che il filtraggio avviene in modo incrementale durante l'iterazione. Questo metodo è efficiente dal punto di vista della memoria e consente di gestire raccolte molto grandi. Se non si iterano tutti gli elementi dell'iteratore risultante, si risparmia in termini di calcolo, poiché non vengono elaborati tutti gli elementi dell'iteratore originale. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Restituisce il primo elemento (che corrisponde al predicato, se specificato). Se non esiste alcun elemento, restituisce il risultato della chiamata a `$else` o null. -Il parametro `$predicate` ha la firma `function ($value, $key, iterable $iterable): bool`. +Restituisce il primo elemento dell'iteratore. Se viene fornito `$predicate`, restituisce il primo elemento che soddisfa la condizione data. La funzione `$predicate` ha la firma `function ($value, $key, iterable $iterable): bool`. Se non viene trovato alcun elemento corrispondente, viene richiamata la funzione `$else` (se fornita) e viene restituito il suo risultato. Se `$else` non è fornito, viene restituito `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Questo metodo è utile quando è necessario recuperare rapidamente il primo elemento di un insieme o il primo elemento che soddisfa una determinata condizione, senza dover iterare manualmente l'intero insieme. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Restituisce la chiave del primo elemento (che corrisponde al predicato, se specificato). Se non esiste un elemento, restituisce il risultato della chiamata a `$else` o null. Il predicato ha la firma `function ($value, $key, iterable $iterable): bool`. +Restituisce la chiave del primo elemento dell'iteratore. Se viene fornito `$predicate`, restituisce la chiave del primo elemento che soddisfa la condizione data. La funzione `$predicate` ha la firma `function ($value, $key, iterable $iterable): bool`. Se non viene trovato alcun elemento corrispondente, viene richiamata la funzione `$else` (se fornita) e viene restituito il suo risultato. Se `$else` non viene fornito, viene restituito `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iteratore che trasforma i valori richiamando `$transformer`. Ha la firma `function ($value, $key, iterable $iterable): bool`. Mantiene le chiavi originali. +Crea un nuovo iteratore applicando la funzione `$transformer` a ogni elemento dell'iteratore originale. La funzione `$transformer` ha la firma `function ($value, $key, iterable $iterable): mixed` e il suo valore di ritorno viene utilizzato come nuovo valore dell'elemento. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Il metodo utilizza un generatore, il che significa che la trasformazione avviene in modo incrementale durante l'iterazione. Questo metodo è efficiente dal punto di vista della memoria e consente di gestire collezioni molto grandi. Se non si iterano tutti gli elementi dell'iteratore risultante, si risparmia in termini di calcolo, poiché non vengono elaborati tutti gli elementi dell'iteratore originale. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Crea un nuovo iteratore trasformando i valori e le chiavi dell'iteratore originale. La funzione `$transformer` ha la firma `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Se `$transformer` restituisce `null`, l'elemento viene saltato. Per gli elementi mantenuti, il primo elemento dell'array restituito viene utilizzato come nuova chiave e il secondo elemento come nuovo valore. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Come `map()`, questo metodo utilizza un generatore per l'elaborazione incrementale e l'efficienza della memoria. In questo modo è possibile lavorare con collezioni di grandi dimensioni e risparmiare sullo sforzo computazionale elaborando solo una parte del risultato. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Crea un wrapper attorno a un iteratore che memorizza nella cache le chiavi e i valori durante l'iterazione. Ciò consente di ripetere l'iterazione dei dati senza dover rielaborare la fonte di dati originale. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Questo metodo è utile nelle situazioni in cui è necessario iterare più volte sullo stesso insieme di dati, ma l'iteratore originale non supporta l'iterazione ripetuta o l'iterazione ripetuta sarebbe costosa (ad esempio, la lettura di dati da un database o da un file). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Verifica se almeno un elemento dell'iteratore supera un test implementato in `$predicate` con la firma `function ($value, $key, iterable $iterable): bool`. +Verifica se almeno un elemento dell'iteratore soddisfa la condizione definita in `$predicate`. La funzione `$predicate` ha la firma `function ($value, $key, iterable $iterable): bool` e deve restituire `true` per almeno un elemento affinché il metodo `some()` restituisca `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Questo metodo è utile per verificare rapidamente se in un insieme c'è almeno un elemento che soddisfa una certa condizione, ad esempio se l'insieme contiene almeno un numero pari. + Vedere [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Converte qualsiasi oggetto iterabile (array, Traversable) in un iteratore. Se l'input è già un iteratore, viene restituito invariato. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Questo metodo è utile quando è necessario assicurarsi di avere un Iteratore, indipendentemente dal tipo di dati in ingresso. Può essere utile quando si creano funzioni che lavorano con diversi tipi di dati iterabili. diff --git a/utils/it/strings.texy b/utils/it/strings.texy index f3c27865d7..ee00908453 100644 --- a/utils/it/strings.texy +++ b/utils/it/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Cerca nella stringa tutte le occorrenze che corrispondono all'espressione regolare e restituisce un array di array contenenti l'espressione trovata e ogni sottoespressione. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Se `$lazy` è `true`, la funzione restituisce un `Generator` invece di un array, con notevoli vantaggi in termini di prestazioni quando si lavora con stringhe di grandi dimensioni. Il generatore consente di trovare le corrispondenze in modo incrementale, anziché elaborare l'intera stringa in una sola volta. Ciò consente di gestire in modo efficiente testi di input molto grandi. Inoltre, è possibile interrompere l'elaborazione in qualsiasi momento se si trova la corrispondenza desiderata, risparmiando tempo di calcolo. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/pl/@home.texy b/utils/pl/@home.texy index a62dd5dc22..7e11a511f6 100644 --- a/utils/pl/@home.texy +++ b/utils/pl/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | wersja zgodna z PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/pl/arrays.texy b/utils/pl/arrays.texy index 23f50f2380..4d6ac34ab4 100644 --- a/utils/pl/arrays.texy +++ b/utils/pl/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Tworzy nową tablicę, przekształcając wartości i klucze oryginalnej tablicy. Funkcja `$transformer` ma sygnaturę `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Jeśli `$transformer` zwróci `null`, element jest pomijany. W przypadku zachowanych elementów, pierwszy element zwróconej tablicy jest używany jako nowy klucz, a drugi element jako nowa wartość. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Metoda ta jest przydatna w sytuacjach, gdy trzeba zmienić strukturę tablicy (zarówno klucze, jak i wartości jednocześnie) lub filtrować elementy podczas transformacji (zwracając wartość null dla niechcianych elementów). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/pl/iterables.texy b/utils/pl/iterables.texy index 6b9b3718ff..6bf8fb8a34 100644 --- a/utils/pl/iterables.texy +++ b/utils/pl/iterables.texy @@ -11,7 +11,7 @@ Instalacja: composer require nette/utils ``` -Wszystkie przykłady zakładają utworzenie aliasu: +Wszystkie przykłady zakładają utworzenie następującego aliasu: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Sprawdza obecność wartości w iteratorze. Używa ścisłego porównania (`===`). +Wyszukuje daną wartość w iteratorze. Używa ścisłego porównania (`===`), aby sprawdzić dopasowanie. Zwraca `true` jeśli wartość zostanie znaleziona, w przeciwnym razie `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Ta metoda jest przydatna, gdy trzeba szybko określić, czy określona wartość jest obecna w iteratorze bez ręcznego iterowania przez wszystkie elementy. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Sprawdza obecność klucza w iteratorze. Używa ścisłego porównania (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Wyszukuje dany klucz w iteratorze. Używa ścisłego porównania (`===`) do sprawdzenia dopasowania. Zwraca `true` jeśli klucz został znaleziony, w przeciwnym razie `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Sprawdza, czy wszystkie elementy iteratora przechodzą test zaimplementowany w `$predicate` z podpisem `function ($value, $key, iterable $iterable): bool`. +Sprawdza, czy wszystkie elementy iteratora spełniają warunek zdefiniowany w `$predicate`. Funkcja `$predicate` ma sygnaturę `function ($value, $key, iterable $iterable): bool` i musi zwrócić `true` dla każdego elementu, aby metoda `every()` zwróciła `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Zobacz [some() |#some()]. +Metoda ta jest przydatna do sprawdzania, czy wszystkie elementy w kolekcji spełniają określony warunek, np. czy wszystkie liczby są poniżej określonej wartości. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterator filtrujący elementy zgodnie z predykatem. Predykat ma sygnaturę `function ($value, $key, iterable $iterable): bool`. Zachowuje oryginalne klucze. +Tworzy nowy iterator, który zawiera tylko te elementy z oryginalnego iteratora, które spełniają warunek zdefiniowany w `$predicate`. Funkcja `$predicate` ma sygnaturę `function ($value, $key, iterable $iterable): bool` i musi zwracać `true` dla elementów, które powinny zostać zachowane. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Metoda wykorzystuje generator, co oznacza, że filtrowanie odbywa się przyrostowo podczas iteracji. Jest to wydajne pod względem pamięci i pozwala na obsługę bardzo dużych kolekcji. Jeśli nie iterujesz przez wszystkie elementy wynikowego iteratora, oszczędzasz wysiłek obliczeniowy, ponieważ nie wszystkie elementy oryginalnego iteratora są przetwarzane. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Zwraca pierwszy element (pasujący do predykatu, jeśli został określony). Jeśli taki element nie istnieje, zwraca wynik wywołania `$else` lub null. -Parametr `$predicate` ma sygnaturę `function ($value, $key, iterable $iterable): bool`. +Zwraca pierwszy element iteratora. Jeśli podano `$predicate`, zwraca pierwszy element, który spełnia podany warunek. Funkcja `$predicate` ma sygnaturę `function ($value, $key, iterable $iterable): bool`. Jeśli nie zostanie znaleziony żaden pasujący element, wywoływana jest funkcja `$else` (jeśli została podana) i zwracany jest jej wynik. Jeśli nie podano `$else`, zwracana jest `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Ta metoda jest przydatna, gdy trzeba szybko pobrać pierwszy element kolekcji lub pierwszy element spełniający określony warunek bez ręcznego iterowania przez całą kolekcję. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Zwraca klucz pierwszego elementu (pasującego do predykatu, jeśli został określony). Jeśli taki element nie istnieje, zwraca wynik wywołania `$else` lub wartość null. Predykat ma sygnaturę `function ($value, $key, iterable $iterable): bool`. +Zwraca klucz pierwszego elementu iteratora. Jeśli podano `$predicate`, zwraca klucz pierwszego elementu, który spełnia podany warunek. Funkcja `$predicate` ma sygnaturę `function ($value, $key, iterable $iterable): bool`. Jeśli nie zostanie znaleziony żaden pasujący element, wywoływana jest funkcja `$else` (jeśli została podana) i zwracany jest jej wynik. Jeśli nie podano `$else`, zwracana jest `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterator, który przekształca wartości poprzez wywołanie `$transformer`. Ma sygnaturę `function ($value, $key, iterable $iterable): bool`. Zachowuje oryginalne klucze. +Tworzy nowy iterator poprzez zastosowanie funkcji `$transformer` do każdego elementu oryginalnego iteratora. Funkcja `$transformer` ma sygnaturę `function ($value, $key, iterable $iterable): mixed`, a jej wartość zwracana jest używana jako nowa wartość elementu. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Metoda ta wykorzystuje generator, co oznacza, że transformacja odbywa się przyrostowo podczas iteracji. Jest to wydajne pod względem pamięci i pozwala na obsługę bardzo dużych kolekcji. Jeśli nie iterujesz przez wszystkie elementy wynikowego iteratora, oszczędzasz wysiłek obliczeniowy, ponieważ nie wszystkie elementy oryginalnego iteratora są przetwarzane. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Tworzy nowy iterator poprzez przekształcenie wartości i kluczy oryginalnego iteratora. Funkcja `$transformer` ma sygnaturę `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Jeśli `$transformer` zwróci `null`, element jest pomijany. Dla zachowanych elementów, pierwszy element zwróconej tablicy jest używany jako nowy klucz, a drugi element jako nowa wartość. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Podobnie jak `map()`, metoda ta wykorzystuje generator do przetwarzania przyrostowego i wydajności pamięci. Pozwala to na pracę z dużymi kolekcjami i oszczędność wysiłku obliczeniowego poprzez przetwarzanie tylko części wyniku. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Tworzy opakowanie wokół iteratora, które buforuje jego klucze i wartości podczas iteracji. Pozwala to na wielokrotną iterację danych bez konieczności ponownego przetwarzania oryginalnego źródła danych. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Metoda ta jest przydatna w sytuacjach, gdy trzeba wielokrotnie iterować po tym samym zestawie danych, ale oryginalny iterator nie obsługuje wielokrotnej iteracji lub wielokrotna iteracja byłaby kosztowna (np. odczytywanie danych z bazy danych lub pliku). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Sprawdza, czy co najmniej jeden element iteratora przechodzi test zaimplementowany w `$predicate` z podpisem `function ($value, $key, iterable $iterable): bool`. +Sprawdza, czy co najmniej jeden element iteratora spełnia warunek zdefiniowany w `$predicate`. Funkcja `$predicate` ma sygnaturę `function ($value, $key, iterable $iterable): bool` i musi zwrócić `true` dla co najmniej jednego elementu, aby metoda `some()` zwróciła `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Metoda ta jest przydatna do szybkiego sprawdzenia, czy w kolekcji znajduje się co najmniej jeden element spełniający określony warunek, np. czy kolekcja zawiera co najmniej jedną liczbę parzystą. + Zobacz [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Konwertuje dowolny obiekt iterowalny (tablicę, Traversable) na Iterator. Jeśli dane wejściowe są już Iteratorem, są zwracane bez zmian. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Ta metoda jest przydatna, gdy trzeba upewnić się, że mamy Iterator, niezależnie od typu danych wejściowych. Może to być przydatne podczas tworzenia funkcji, które działają z różnymi typami danych iterowalnych. diff --git a/utils/pl/strings.texy b/utils/pl/strings.texy index 0b9b0abd1d..654b8339c2 100644 --- a/utils/pl/strings.texy +++ b/utils/pl/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Przeszukuje łańcuch w poszukiwaniu wszystkich wystąpień pasujących do wyrażenia regularnego i zwraca tablicę tablic zawierających dopasowane wyrażenie i każde podwyrażenie. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Jeśli `$lazy` to `true`, funkcja zwraca `Generator` zamiast tablicy, co zapewnia znaczne korzyści w zakresie wydajności podczas pracy z dużymi ciągami znaków. Generator pozwala na znajdowanie dopasowań przyrostowo, zamiast przetwarzania całego ciągu na raz. Umożliwia to wydajną obsługę bardzo dużych tekstów wejściowych. Dodatkowo, można przerwać przetwarzanie w dowolnym momencie, jeśli zostanie znalezione pożądane dopasowanie, oszczędzając czas obliczeniowy. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/pt/@home.texy b/utils/pt/@home.texy index 984915289e..51fbe85711 100644 --- a/utils/pt/@home.texy +++ b/utils/pt/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | versão | compatível com PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/pt/arrays.texy b/utils/pt/arrays.texy index 142ccc6ee3..c345602578 100644 --- a/utils/pt/arrays.texy +++ b/utils/pt/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Cria uma nova matriz transformando os valores e as chaves da matriz original. A função `$transformer` tem a assinatura `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Se `$transformer` retornar `null`, o elemento será ignorado. Para elementos retidos, o primeiro elemento da matriz retornada é usado como a nova chave e o segundo elemento como o novo valor. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Esse método é útil em situações em que você precisa alterar a estrutura de uma matriz (chaves e valores simultaneamente) ou filtrar elementos durante a transformação (retornando null para elementos indesejados). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/pt/iterables.texy b/utils/pt/iterables.texy index 30bea5ca1f..ac88f76b08 100644 --- a/utils/pt/iterables.texy +++ b/utils/pt/iterables.texy @@ -11,7 +11,7 @@ Instalação: composer require nette/utils ``` -Todos os exemplos pressupõem a criação de um alias: +Todos os exemplos pressupõem que o alias a seguir foi criado: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Testa a presença de um valor no iterador. Usa comparação rigorosa (`===`). +Procura por um determinado valor em um iterador. Usa comparação rigorosa (`===`) para verificar se há correspondência. Retorna `true` se o valor for encontrado, caso contrário, `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Esse método é útil quando você precisa determinar rapidamente se um valor específico está presente em um iterador sem iterar manualmente por todos os elementos. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Testa a presença de uma chave no iterador. Usa comparação rigorosa (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Procura por uma determinada chave em um iterador. Usa comparação rigorosa (`===`) para verificar se há correspondência. Retorna `true` se a chave for encontrada, caso contrário, `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Testa se todos os elementos do iterador passam em um teste implementado em `$predicate` com a assinatura `function ($value, $key, iterable $iterable): bool`. +Verifica se todos os elementos do iterador satisfazem a condição definida em `$predicate`. A função `$predicate` tem a assinatura `function ($value, $key, iterable $iterable): bool` e deve retornar `true` para cada elemento para que o método `every()` retorne `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Consulte [some() |#some()]. +Esse método é útil para verificar se todos os elementos de uma coleção atendem a uma determinada condição, como, por exemplo, se todos os números estão abaixo de um valor específico. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterador que filtra elementos de acordo com um predicado. O predicado tem a assinatura `function ($value, $key, iterable $iterable): bool`. Mantém as chaves originais. +Cria um novo iterador que contém somente os elementos do iterador original que satisfazem a condição definida em `$predicate`. A função `$predicate` tem a assinatura `function ($value, $key, iterable $iterable): bool` e deve retornar `true` para os elementos que devem ser mantidos. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +O método usa um gerador, o que significa que a filtragem ocorre de forma incremental durante a iteração. Isso é eficiente em termos de memória e permite lidar com coleções muito grandes. Se você não iterar por todos os elementos do iterador resultante, economizará esforço computacional, pois nem todos os elementos do iterador original serão processados. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Retorna o primeiro item (que corresponde ao predicado, se especificado). Se esse item não existir, retorna o resultado da chamada para `$else` ou nulo. -O parâmetro `$predicate` tem a assinatura `function ($value, $key, iterable $iterable): bool`. +Retorna o primeiro elemento do iterador. Se `$predicate` for fornecido, ele retornará o primeiro elemento que satisfaz a condição fornecida. A função `$predicate` tem a assinatura `function ($value, $key, iterable $iterable): bool`. Se nenhum elemento correspondente for encontrado, a função `$else` (se fornecida) será chamada e seu resultado será retornado. Se `$else` não for fornecido, `null` será retornado. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Esse método é útil quando você precisa recuperar rapidamente o primeiro elemento de uma coleção ou o primeiro elemento que atende a uma determinada condição sem iterar manualmente por toda a coleção. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Retorna a chave do primeiro item (que corresponde ao predicado, se especificado). Se esse item não existir, retorna o resultado da chamada para `$else` ou nulo. O predicado tem a assinatura `function ($value, $key, iterable $iterable): bool`. +Retorna a chave do primeiro elemento do iterador. Se `$predicate` for fornecido, ele retornará a chave do primeiro elemento que satisfaz a condição fornecida. A função `$predicate` tem a assinatura `function ($value, $key, iterable $iterable): bool`. Se nenhum elemento correspondente for encontrado, a função `$else` (se fornecida) será chamada e seu resultado será retornado. Se `$else` não for fornecido, `null` será retornado. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterador que transforma valores chamando `$transformer`. Ele tem a assinatura `function ($value, $key, iterable $iterable): bool`. Mantém as chaves originais. +Cria um novo iterador aplicando a função `$transformer` a cada elemento do iterador original. A função `$transformer` tem a assinatura `function ($value, $key, iterable $iterable): mixed` e seu valor de retorno é usado como o novo valor do elemento. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +O método usa um gerador, o que significa que a transformação ocorre de forma incremental durante a iteração. Isso é eficiente em termos de memória e permite lidar com coleções muito grandes. Se você não iterar por todos os elementos do iterador resultante, economizará esforço computacional, pois nem todos os elementos do iterador original serão processados. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Cria um novo iterador transformando os valores e as chaves do iterador original. A função `$transformer` tem a assinatura `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Se `$transformer` retornar `null`, o elemento será ignorado. Para elementos retidos, o primeiro elemento da matriz retornada é usado como a nova chave e o segundo elemento como o novo valor. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Assim como o `map()`, esse método usa um gerador para processamento incremental e eficiência de memória. Isso permite trabalhar com grandes coleções e economizar esforço computacional ao processar apenas parte do resultado. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Cria um invólucro em torno de um iterador que armazena em cache suas chaves e valores durante a iteração. Isso permite a iteração repetida dos dados sem a necessidade de reprocessar a fonte de dados original. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Esse método é útil em situações em que você precisa iterar sobre o mesmo conjunto de dados várias vezes, mas o iterador original não oferece suporte à iteração repetida ou a iteração repetida seria dispendiosa (por exemplo, ler dados de um banco de dados ou arquivo). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Testa se pelo menos um elemento do iterador passa em um teste implementado em `$predicate` com a assinatura `function ($value, $key, iterable $iterable): bool`. +Verifica se pelo menos um elemento do iterador satisfaz a condição definida em `$predicate`. A função `$predicate` tem a assinatura `function ($value, $key, iterable $iterable): bool` e deve retornar `true` para pelo menos um elemento para que o método `some()` retorne `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Esse método é útil para verificar rapidamente se há pelo menos um elemento em uma coleção que atenda a uma determinada condição, como, por exemplo, se a coleção contém pelo menos um número par. + Consulte [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Converte qualquer objeto iterável (matriz, Traversable) em um Iterator. Se a entrada já for um Iterator, ela será retornada inalterada. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Esse método é útil quando você precisa garantir que tem um Iterator, independentemente do tipo de dados de entrada. Isso pode ser útil ao criar funções que funcionam com diferentes tipos de dados iteráveis. diff --git a/utils/pt/strings.texy b/utils/pt/strings.texy index 0c771b5c15..9dc987f2a9 100644 --- a/utils/pt/strings.texy +++ b/utils/pt/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Procura na cadeia todas as ocorrências que correspondem à expressão regular e retorna uma matriz de matrizes contendo a expressão encontrada e cada subexpressão. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Se `$lazy` for `true`, a função retornará um `Generator` em vez de uma matriz, o que proporciona benefícios significativos de desempenho ao trabalhar com cadeias de caracteres grandes. O gerador permite que as correspondências sejam encontradas de forma incremental, em vez de processar a cadeia inteira de uma só vez. Isso permite o manuseio eficiente de textos de entrada extremamente grandes. Além disso, você pode interromper o processamento a qualquer momento se encontrar a correspondência desejada, economizando tempo computacional. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/ro/@home.texy b/utils/ro/@home.texy index 98e5316be5..841a61083f 100644 --- a/utils/ro/@home.texy +++ b/utils/ro/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | versiune | compatibil cu PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/ro/arrays.texy b/utils/ro/arrays.texy index 82a2e3770e..91406036b6 100644 --- a/utils/ro/arrays.texy +++ b/utils/ro/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Creează un nou array prin transformarea valorilor și a cheilor array-ului original. Funcția `$transformer` are semnătura `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Dacă `$transformer` returnează `null`, elementul este ignorat. Pentru elementele păstrate, primul element al matricei returnate este utilizat ca nouă cheie, iar al doilea element ca nouă valoare. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Această metodă este utilă în situațiile în care trebuie să modificați structura unui array (atât cheile, cât și valorile simultan) sau să filtrați elementele în timpul transformării (returnând null pentru elementele nedorite). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/ro/iterables.texy b/utils/ro/iterables.texy index 413b1f6ec2..1b23305ee5 100644 --- a/utils/ro/iterables.texy +++ b/utils/ro/iterables.texy @@ -1,5 +1,5 @@ -Funcții de iterator -******************* +Funcții Iterator +**************** .[perex]{data-version:4.0.4} [api:Nette\Utils\Iterables] este o clasă statică cu funcții pentru lucrul cu iteratori. Omologul său pentru array-uri este [Nette\Utils\Arrays |arrays]. @@ -11,7 +11,7 @@ Instalare: composer require nette/utils ``` -Toate exemplele presupun crearea unui alias: +Toate exemplele presupun că este creat următorul alias: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Testează prezența unei valori în iterator. Utilizează o comparație strictă (`===`). +Caută o valoare dată într-un iterator. Utilizează comparația strictă (`===`) pentru a verifica dacă există o potrivire. Returnează `true` dacă valoarea este găsită, altfel `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Această metodă este utilă atunci când trebuie să determinați rapid dacă o anumită valoare este prezentă într-un iterator fără a itera manual prin toate elementele. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Testează prezența unei chei în iterator. Utilizează o comparație strictă (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Caută o cheie dată într-un iterator. Utilizează comparația strictă (`===`) pentru a verifica dacă există o potrivire. Returnează `true` dacă cheia este găsită, altfel `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Testează dacă toate elementele iteratorului trec un test implementat în `$predicate` cu semnătura `function ($value, $key, iterable $iterable): bool`. +Verifică dacă toate elementele iteratorului îndeplinesc condiția definită în `$predicate`. Funcția `$predicate` are semnătura `function ($value, $key, iterable $iterable): bool` și trebuie să returneze `true` pentru fiecare element pentru ca metoda `every()` să returneze `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -A se vedea [some() |#some()]. +Această metodă este utilă pentru a verifica dacă toate elementele unei colecții îndeplinesc o anumită condiție, cum ar fi dacă toate numerele sunt sub o anumită valoare. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterator care filtrează elementele în funcție de un predicat. Predicatul are semnătura `function ($value, $key, iterable $iterable): bool`. Păstrează cheile originale. +Creează un nou iterator care conține numai elementele din iteratorul inițial care îndeplinesc condiția definită la `$predicate`. Funcția `$predicate` are semnătura `function ($value, $key, iterable $iterable): bool` și trebuie să returneze `true` pentru elementele care trebuie păstrate. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Metoda utilizează un generator, ceea ce înseamnă că filtrarea are loc în mod incremental în timpul iterației. Acest lucru este eficient din punct de vedere al memoriei și permite gestionarea colecțiilor foarte mari. Dacă nu iterați prin toate elementele iteratorului rezultat, economisiți efort de calcul, deoarece nu sunt procesate toate elementele iteratorului original. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Returnează primul element (care corespunde predicatului, dacă este specificat). Dacă nu există un astfel de element, se returnează rezultatul apelării `$else` sau null. -Parametrul `$predicate` are semnătura `function ($value, $key, iterable $iterable): bool`. +Returnează primul element al iteratorului. Dacă se furnizează `$predicate`, aceasta returnează primul element care îndeplinește condiția dată. Funcția `$predicate` are semnătura `function ($value, $key, iterable $iterable): bool`. Dacă nu se găsește niciun element corespunzător, funcția `$else` (dacă este furnizată) este apelată și rezultatul său este returnat. Dacă `$else` nu este furnizat, se returnează `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Această metodă este utilă atunci când trebuie să recuperați rapid primul element al unei colecții sau primul element care îndeplinește o anumită condiție fără a parcurge manual întreaga colecție. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Returnează cheia primului element (care corespunde predicatului, dacă este specificat). Dacă nu există un astfel de element, se returnează rezultatul apelării `$else` sau null. Predicatul are semnătura `function ($value, $key, iterable $iterable): bool`. +Returnează cheia primului element al iteratorului. Dacă se furnizează `$predicate`, aceasta returnează cheia primului element care îndeplinește condiția dată. Funcția `$predicate` are semnătura `function ($value, $key, iterable $iterable): bool`. Dacă nu se găsește niciun element corespunzător, funcția `$else` (dacă este furnizată) este apelată și rezultatul său este returnat. Dacă `$else` nu este furnizat, se returnează `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterator care transformă valorile prin apelarea `$transformer`. Are semnătura `function ($value, $key, iterable $iterable): bool`. Păstrează cheile originale. +Creează un nou iterator prin aplicarea funcției `$transformer` la fiecare element al iteratorului original. Funcția `$transformer` are semnătura `function ($value, $key, iterable $iterable): mixed`, iar valoarea sa de retur este utilizată ca noua valoare a elementului. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Metoda utilizează un generator, ceea ce înseamnă că transformarea are loc în mod incremental în timpul iterației. Acest lucru este eficient din punct de vedere al memoriei și permite gestionarea colecțiilor foarte mari. Dacă nu iterați prin toate elementele iteratorului rezultat, economisiți efort de calcul, deoarece nu sunt prelucrate toate elementele iteratorului original. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Creează un nou iterator prin transformarea valorilor și a cheilor iteratorului inițial. Funcția `$transformer` are semnătura `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Dacă `$transformer` returnează `null`, elementul este ignorat. Pentru elementele reținute, primul element al matricei returnate este utilizat ca nouă cheie, iar al doilea element ca nouă valoare. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Ca și `map()`, această metodă utilizează un generator pentru procesare incrementală și eficiență în memorie. Aceasta permite lucrul cu colecții mari și economisirea efortului de calcul prin prelucrarea doar a unei părți din rezultat. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Creează un înveliș în jurul unui iterator care memorează cheile și valorile acestuia în timpul iterației. Acest lucru permite iterarea repetată a datelor fără a fi necesară prelucrarea din nou a sursei de date originale. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Această metodă este utilă în situațiile în care trebuie să iterați asupra aceluiași set de date de mai multe ori, dar iteratorul original nu acceptă iterația repetată sau iterația repetată ar fi costisitoare (de exemplu, citirea datelor dintr-o bază de date sau dintr-un fișier). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Testează dacă cel puțin un element al iteratorului trece un test implementat în `$predicate` cu semnătura `function ($value, $key, iterable $iterable): bool`. +Verifică dacă cel puțin un element al iteratorului îndeplinește condiția definită în `$predicate`. Funcția `$predicate` are semnătura `function ($value, $key, iterable $iterable): bool` și trebuie să returneze `true` pentru cel puțin un element pentru ca metoda `some()` să returneze `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` -A se vedea [every() |#every()]. +Această metodă este utilă pentru a verifica rapid dacă există cel puțin un element într-o colecție care îndeplinește o anumită condiție, cum ar fi dacă colecția conține cel puțin un număr par. + +Consultați [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Convertește orice obiect iterabil (array, Traversable) într-un Iterator. Dacă intrarea este deja un Iterator, acesta este returnat neschimbat. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Această metodă este utilă atunci când trebuie să vă asigurați că aveți un Iterator, indiferent de tipul de date de intrare. Acest lucru poate fi util atunci când se creează funcții care lucrează cu diferite tipuri de date iterabile. diff --git a/utils/ro/strings.texy b/utils/ro/strings.texy index 2f57b83871..db8c06eb1f 100644 --- a/utils/ro/strings.texy +++ b/utils/ro/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Caută în șirul de caractere toate ocurențele care corespund expresiei regulate și returnează o matrice de matrici care conține expresia găsită și fiecare subexpresie. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Dacă `$lazy` este `true`, funcția returnează un `Generator` în loc de un array, ceea ce oferă beneficii semnificative de performanță atunci când se lucrează cu șiruri mari. Generatorul permite găsirea incrementală a potrivirilor, în loc să proceseze întregul șir odată. Acest lucru permite gestionarea eficientă a textelor de intrare extrem de mari. În plus, puteți întrerupe procesarea în orice moment dacă găsiți potrivirea dorită, economisind astfel timp de calcul. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/ru/@home.texy b/utils/ru/@home.texy index c3f516b34f..67d3255340 100644 --- a/utils/ru/@home.texy +++ b/utils/ru/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | Версия, совместимая с PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/ru/arrays.texy b/utils/ru/arrays.texy index 33326625d0..f2cf996e3b 100644 --- a/utils/ru/arrays.texy +++ b/utils/ru/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Создает новый массив путем преобразования значений и ключей исходного массива. Функция `$transformer` имеет сигнатуру `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Если `$transformer` возвращает `null`, элемент пропускается. Для сохраненных элементов первый элемент возвращаемого массива используется в качестве нового ключа, а второй - в качестве нового значения. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Этот метод полезен в ситуациях, когда необходимо изменить структуру массива (одновременно ключи и значения) или отфильтровать элементы при преобразовании (возвращая null для ненужных элементов). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/ru/iterables.texy b/utils/ru/iterables.texy index 6330be8877..17d8ad037a 100644 --- a/utils/ru/iterables.texy +++ b/utils/ru/iterables.texy @@ -11,7 +11,7 @@ composer require nette/utils ``` -Все примеры предполагают создание псевдонима: +Во всех примерах предполагается, что создан следующий псевдоним: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Проверяет наличие значения в итераторе. Используется строгое сравнение (`===`). +Поиск заданного значения в итераторе. Использует строгое сравнение (`===`) для проверки совпадения. Возвращает `true`, если значение найдено, иначе `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Этот метод полезен, когда нужно быстро определить, присутствует ли конкретное значение в итераторе, не перебирая вручную все элементы. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Проверяет наличие ключа в итераторе. Используется строгое сравнение (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Поиск заданного ключа в итераторе. Использует строгое сравнение (`===`) для проверки совпадения. Возвращает `true`, если ключ найден, иначе `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Проверяет, все ли элементы итератора проходят тест, реализованный в `$predicate` с сигнатурой `function ($value, $key, iterable $iterable): bool`. +Проверяет, все ли элементы итератора удовлетворяют условию, определенному в `$predicate`. Функция `$predicate` имеет сигнатуру `function ($value, $key, iterable $iterable): bool` и должна возвращать `true` для каждого элемента, чтобы метод `every()` вернул `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -См. [some() |#some()]. +Этот метод полезен для проверки того, что все элементы коллекции удовлетворяют определенному условию, например, все ли числа меньше определенного значения. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Итератор, который фильтрует элементы в соответствии с предикатом. Предикат имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. Сохраняет исходные ключи. +Создает новый итератор, содержащий только те элементы из исходного итератора, которые удовлетворяют условию, определенному в `$predicate`. Функция `$predicate` имеет сигнатуру `function ($value, $key, iterable $iterable): bool` и должна возвращать `true` для элементов, которые должны быть сохранены. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Метод использует генератор, то есть фильтрация происходит инкрементально во время итерации. Это экономит память и позволяет работать с очень большими коллекциями. Если вы не выполняете итерацию по всем элементам результирующего итератора, вы экономите вычислительные усилия, поскольку не все элементы исходного итератора обрабатываются. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Возвращает первый элемент (соответствующий предикату, если он указан). Если такого элемента нет, возвращается результат вызова `$else` или null. -Параметр `$predicate` имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. +Возвращает первый элемент итератора. Если указано `$predicate`, возвращается первый элемент, удовлетворяющий заданному условию. Функция `$predicate` имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. Если не найдено ни одного удовлетворяющего элемента, вызывается функция `$else` (если она предоставлена) и возвращается ее результат. Если `$else` не предоставлена, возвращается `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Этот метод полезен, когда нужно быстро получить первый элемент коллекции или первый элемент, удовлетворяющий определенному условию, без ручного итерационного просмотра всей коллекции. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Возвращает ключ первого элемента (соответствующего предикату, если он указан). Если такого элемента нет, возвращается результат вызова `$else` или null. Предикат имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. +Возвращает ключ первого элемента итератора. Если указано `$predicate`, возвращается ключ первого элемента, удовлетворяющего заданному условию. Функция `$predicate` имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. Если ни один элемент не найден, вызывается функция `$else` (если она предоставлена) и возвращается ее результат. Если `$else` не предоставлена, возвращается `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Итератор, преобразующий значения путем вызова `$transformer`. Имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. Сохраняет исходные ключи. +Создает новый итератор путем применения функции `$transformer` к каждому элементу исходного итератора. Функция `$transformer` имеет сигнатуру `function ($value, $key, iterable $iterable): mixed`, а ее возвращаемое значение используется в качестве нового значения элемента. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Метод использует генератор, то есть преобразование происходит инкрементально во время итерации. Это экономит память и позволяет работать с очень большими коллекциями. Если вы не выполняете итерацию по всем элементам результирующего итератора, вы экономите вычислительные усилия, поскольку не все элементы исходного итератора обрабатываются. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Создает новый итератор путем преобразования значений и ключей исходного итератора. Функция `$transformer` имеет сигнатуру `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Если `$transformer` возвращает `null`, элемент пропускается. Для сохраненных элементов первый элемент возвращаемого массива используется в качестве нового ключа, а второй элемент - в качестве нового значения. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Как и `map()`, этот метод использует генератор для инкрементной обработки и эффективности использования памяти. Это позволяет работать с большими коллекциями и экономить вычислительные усилия, обрабатывая только часть результата. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Создает обертку вокруг итератора, которая кэширует его ключи и значения во время итерации. Это позволяет повторять итерации над данными без необходимости повторной обработки исходного источника данных. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Этот метод полезен в ситуациях, когда вам нужно несколько раз просмотреть один и тот же набор данных, но исходный итератор не поддерживает повторную итерацию или повторная итерация будет дорогостоящей (например, при чтении данных из базы данных или файла). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Проверяет, проходит ли хотя бы один элемент итератора тест, реализованный в `$predicate` с подписью `function ($value, $key, iterable $iterable): bool`. +Проверяет, удовлетворяет ли хотя бы один элемент итератора условию, определенному в `$predicate`. Функция `$predicate` имеет сигнатуру `function ($value, $key, iterable $iterable): bool` и должна вернуть `true` хотя бы для одного элемента, чтобы метод `some()` вернул `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` -См. [every() |#every()]. +Этот метод полезен для быстрой проверки того, есть ли в коллекции хотя бы один элемент, удовлетворяющий определенному условию, например, содержит ли коллекция хотя бы одно четное число. + +Смотрите [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Преобразует любой итерируемый объект (массив, Traversable) в итератор. Если входной объект уже является итератором, он возвращается без изменений. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Этот метод полезен, когда нужно убедиться, что у вас есть итератор, независимо от типа входных данных. Это может быть полезно при создании функций, работающих с разными типами итерируемых данных. diff --git a/utils/ru/strings.texy b/utils/ru/strings.texy index 7a15e209a4..22b2a8ceef 100644 --- a/utils/ru/strings.texy +++ b/utils/ru/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Ищет в строке все вхождения, соответствующие регулярному выражению, и возвращает массив массивов, содержащих найденное выражение и каждое подвыражение. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Если `$lazy` равно `true`, то вместо массива функция возвращает `Generator`, что дает значительный выигрыш в производительности при работе с большими строками. Генератор позволяет находить совпадения постепенно, а не обрабатывать всю строку сразу. Это позволяет эффективно работать с очень большими входными текстами. Кроме того, вы можете прервать обработку в любой момент, если нашли нужное совпадение, что экономит вычислительное время. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/sl/@home.texy b/utils/sl/@home.texy index 8e5c925487..9a942e4e92 100644 --- a/utils/sl/@home.texy +++ b/utils/sl/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | različica | združljivo s PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/sl/arrays.texy b/utils/sl/arrays.texy index 362c4163ac..0ee53173e4 100644 --- a/utils/sl/arrays.texy +++ b/utils/sl/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Ustvari novo polje s preoblikovanjem vrednosti in ključev prvotnega polja. Funkcija `$transformer` ima podpis `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Če `$transformer` vrne `null`, se element preskoči. Pri ohranjenih elementih se prvi element vrnjenega polja uporabi kot novi ključ, drugi element pa kot nova vrednost. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Ta metoda je uporabna v primerih, ko je treba spremeniti strukturo polja (hkrati ključe in vrednosti) ali filtrirati elemente med transformacijo (tako, da se za neželene elemente vrne ničla). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/sl/iterables.texy b/utils/sl/iterables.texy index 5bcaa78a32..f396a6d65d 100644 --- a/utils/sl/iterables.texy +++ b/utils/sl/iterables.texy @@ -11,7 +11,7 @@ Namestitev: composer require nette/utils ``` -Vsi primeri predvidevajo vzpostavitev vzdevka: +Vsi primeri predvidevajo, da je ustvarjen naslednji vzdevek: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Preizkusi prisotnost vrednosti v iteratorju. Uporablja strogo primerjavo (`===`). +Poišče določeno vrednost v iteratorju. Za preverjanje ujemanja uporablja strogo primerjavo (`===`). Če je vrednost najdena, vrne `true`, sicer `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Ta metoda je uporabna, kadar morate hitro ugotoviti, ali je določena vrednost prisotna v iteratorju, ne da bi ročno iterirali skozi vse elemente. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Preizkusi prisotnost ključa v iteratorju. Uporablja strogo primerjavo (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Poišče dani ključ v iteratorju. Za preverjanje ujemanja uporablja strogo primerjavo (`===`). Če je ključ najden, vrne `true`, sicer `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Preizkusi, ali vsi elementi iteratorja prestanejo test, implementiran v `$predicate` s podpisom `function ($value, $key, iterable $iterable): bool`. +Preveri, ali vsi elementi iteratorja izpolnjujejo pogoj, opredeljen v `$predicate`. Funkcija `$predicate` ima podpis `function ($value, $key, iterable $iterable): bool` in mora vrniti `true` za vsak element, da metoda `every()` vrne `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Glej [some( |#some()]). +Ta metoda je uporabna za preverjanje, ali vsi elementi v zbirki izpolnjujejo določen pogoj, na primer ali so vsa števila pod določeno vrednostjo. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Iterator, ki filtrira elemente v skladu s predikatom. Predikat ima podpis `function ($value, $key, iterable $iterable): bool`. Ohranja prvotne ključe. +Ustvari nov iterator, ki vsebuje samo elemente iz prvotnega iteratorja, ki izpolnjujejo pogoj, določen v `$predicate`. Funkcija `$predicate` ima podpis `function ($value, $key, iterable $iterable): bool` in mora vrniti `true` za elemente, ki jih je treba ohraniti. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Metoda uporablja generator, kar pomeni, da filtriranje poteka postopoma med iteracijo. To je pomnilniško učinkovito in omogoča obdelavo zelo velikih zbirk. Če ne iteriramo skozi vse elemente dobljenega iteratorja, prihranimo pri računskem naporu, saj niso obdelani vsi elementi prvotnega iteratorja. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Vrne prvi element (ki ustreza predikatu, če je določen). Če takega elementa ni, vrne rezultat klica `$else` ali nič. -Parameter `$predicate` ima podpis `function ($value, $key, iterable $iterable): bool`. +Vrne prvi element iteratorja. Če je podan `$predicate`, vrne prvi element, ki izpolnjuje dani pogoj. Funkcija `$predicate` ima podpis `function ($value, $key, iterable $iterable): bool`. Če ni najden noben ustrezen element, se pokliče funkcija `$else` (če je zagotovljena) in vrne njen rezultat. Če funkcija `$else` ni navedena, se vrne `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Ta metoda je uporabna, kadar je treba hitro pridobiti prvi element zbirke ali prvi element, ki izpolnjuje določen pogoj, ne da bi ročno iterirali po celotni zbirki. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Vrne ključ prvega elementa (ki ustreza predikatu, če je določen). Če takega elementa ni, vrne rezultat klica `$else` ali nič. Predikat ima podpis `function ($value, $key, iterable $iterable): bool`. +Vrne ključ prvega elementa iteratorja. Če je podan `$predicate`, vrne ključ prvega elementa, ki izpolnjuje dani pogoj. Funkcija `$predicate` ima podpis `function ($value, $key, iterable $iterable): bool`. Če ni najden noben ustrezen element, se pokliče funkcija `$else` (če je zagotovljena) in vrne njen rezultat. Če funkcija `$else` ni podana, se vrne `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Iterator, ki preoblikuje vrednosti s klicem `$transformer`. Ima podpis `function ($value, $key, iterable $iterable): bool`. Ohrani prvotne ključe. +Ustvari nov iterator z uporabo funkcije `$transformer` za vsak element prvotnega iteratorja. Funkcija `$transformer` ima podpis `function ($value, $key, iterable $iterable): mixed`, njena vrnjena vrednost pa se uporabi kot nova vrednost elementa. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Metoda uporablja generator, kar pomeni, da se preoblikovanje izvaja postopoma med iteracijo. To je pomnilniško učinkovito in omogoča obdelavo zelo velikih zbirk. Če ne iteriramo skozi vse elemente dobljenega iteratorja, prihranimo pri računskem naporu, saj niso obdelani vsi elementi prvotnega iteratorja. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Ustvari nov iterator s preoblikovanjem vrednosti in ključev prvotnega iteratorja. Funkcija `$transformer` ima podpis `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Če `$transformer` vrne `null`, se element preskoči. Pri ohranjenih elementih se prvi element vrnjenega polja uporabi kot novi ključ, drugi element pa kot nova vrednost. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Tako kot `map()` tudi ta metoda uporablja generator za postopno obdelavo in pomnilniško učinkovitost. To omogoča delo z velikimi zbirkami in prihranek računskega napora z obdelavo le dela rezultata. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Ustvari ovoj okoli iteratorja, ki med iteracijo predpomni njegove ključe in vrednosti. To omogoča ponavljajoče se iteracije nad podatki, ne da bi bilo treba ponovno obdelati izvirni vir podatkov. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Ta metoda je uporabna v primerih, ko je treba večkrat iterirati po istem nizu podatkov, vendar izvirni iterator ne podpira ponavljajoče se iteracije ali pa bi bila ponavljajoča se iteracija draga (npr. branje podatkov iz zbirke podatkov ali datoteke). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Preizkusi, ali vsaj en element iteratorja izpolnjuje test, implementiran v `$predicate` s podpisom `function ($value, $key, iterable $iterable): bool`. +Preveri, ali vsaj en element iteratorja izpolnjuje pogoj, opredeljen v `$predicate`. Funkcija `$predicate` ima podpis `function ($value, $key, iterable $iterable): bool` in mora vrniti `true` za vsaj en element, da metoda `some()` vrne `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` -Glej [every( |#every()]). +Ta metoda je uporabna za hitro preverjanje, ali je v zbirki vsaj en element, ki izpolnjuje določen pogoj, na primer ali zbirka vsebuje vsaj eno sodo število. + +Glejte [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Pretvori katerikoli objekt iterabla (polje, Traversable) v Iterator. Če je vhod že Iterator, se vrne nespremenjen. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Ta metoda je uporabna, kadar morate zagotoviti, da imate Iterator, ne glede na vrsto vhodnih podatkov. To je lahko koristno pri ustvarjanju funkcij, ki delajo z različnimi vrstami iterativnih podatkov. diff --git a/utils/sl/strings.texy b/utils/sl/strings.texy index 9289376977..99ead40558 100644 --- a/utils/sl/strings.texy +++ b/utils/sl/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- V nizu poišče vse pojavitve, ki ustrezajo regularnemu izrazu, in vrne polje polj, ki vsebuje najden izraz in vsak podizraz. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Če je `$lazy` `true` , funkcija namesto polja vrne `Generator`, kar pri delu z velikimi nizi zagotavlja znatne prednosti pri delovanju. Generator omogoča postopno iskanje ujemanj, namesto da bi obdelal celoten niz naenkrat. To omogoča učinkovito obdelavo izjemno velikih vhodnih besedil. Poleg tega lahko obdelavo kadar koli prekinete, če najdete želeno ujemanje, s čimer prihranite računski čas. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/tr/@home.texy b/utils/tr/@home.texy index 9190e91cd9..604e0ca525 100644 --- a/utils/tr/@home.texy +++ b/utils/tr/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | sürüm | PHP ile uyumlu |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/tr/arrays.texy b/utils/tr/arrays.texy index a7e8b892b7..8644e1ad69 100644 --- a/utils/tr/arrays.texy +++ b/utils/tr/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Orijinal dizinin değerlerini ve anahtarlarını dönüştürerek yeni bir dizi oluşturur. `$transformer` işlevi `function ($value, $key, array $array): ?array{$newValue, $newKey}` imzasına sahiptir. `$transformer` işlevi `null` döndürürse, eleman atlanır. Tutulan elemanlar için, döndürülen dizinin ilk elemanı yeni anahtar ve ikinci elemanı yeni değer olarak kullanılır. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Bu yöntem, bir dizinin yapısını (hem anahtarları hem de değerleri aynı anda) değiştirmeniz veya dönüştürme sırasında öğeleri filtrelemeniz (istenmeyen öğeler için null döndürerek) gereken durumlarda kullanışlıdır. + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/tr/iterables.texy b/utils/tr/iterables.texy index 9bb6750c49..41a1427d08 100644 --- a/utils/tr/iterables.texy +++ b/utils/tr/iterables.texy @@ -11,7 +11,7 @@ Kurulum: composer require nette/utils ``` -Tüm örneklerde bir takma ad oluşturulduğu varsayılmaktadır: +Tüm örnekler aşağıdaki takma adın oluşturulduğunu varsayar: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Yineleyicide bir değerin varlığını test eder. Sıkı karşılaştırma kullanır (`===`). +Bir yineleyici içinde verilen bir değeri arar. Bir eşleşme olup olmadığını kontrol etmek için katı karşılaştırma (`===`) kullanır. Değer bulunursa `true`, aksi takdirde `false` döndürür. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Bu yöntem, tüm öğeleri manuel olarak yinelemeden bir yineleyicide belirli bir değerin bulunup bulunmadığını hızlı bir şekilde belirlemeniz gerektiğinde kullanışlıdır. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Yineleyicide bir anahtarın varlığını test eder. Sıkı karşılaştırma kullanır (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Bir yineleyici içinde verilen bir anahtarı arar. Bir eşleşme olup olmadığını kontrol etmek için katı karşılaştırma (`===`) kullanır. Anahtar bulunursa `true`, aksi takdirde `false` döndürür. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Yineleyicinin tüm öğelerinin `$predicate` içinde `function ($value, $key, iterable $iterable): bool` imzasıyla uygulanan bir testi geçip geçmediğini test eder. +Yineleyicinin tüm öğelerinin `$predicate` içinde tanımlanan koşulu sağlayıp sağlamadığını kontrol eder. `$predicate` işlevi `function ($value, $key, iterable $iterable): bool` imzasına sahiptir ve `every()` yönteminin `true` döndürmesi için her öğe için `true` döndürmelidir. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` - [some() |#some()] işlevine bakın. +Bu yöntem, bir koleksiyondaki tüm öğelerin, tüm sayıların belirli bir değerin altında olup olmadığı gibi belirli bir koşulu karşıladığını doğrulamak için kullanışlıdır. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Öğeleri bir yükleme göre filtreleyen yineleyici. Yüklem `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. Orijinal anahtarları korur. +Orijinal yineleyiciden yalnızca `$predicate` adresinde tanımlanan koşulu sağlayan öğeleri içeren yeni bir yineleyici oluşturur. `$predicate` işlevi `function ($value, $key, iterable $iterable): bool` imzasına sahiptir ve tutulması gereken öğeler için `true` döndürmelidir. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Yöntem bir üreteç kullanır, yani filtreleme yineleme sırasında artımlı olarak gerçekleşir. Bu, bellek açısından verimlidir ve çok büyük koleksiyonların işlenmesine olanak sağlar. Elde edilen yineleyicinin tüm öğeleri boyunca yineleme yapmazsanız, orijinal yineleyicinin tüm öğeleri işlenmediğinden hesaplama çabasından tasarruf edersiniz. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -İlk öğeyi döndürür (belirtilmişse, yüklemle eşleşen). Böyle bir öğe yoksa, `$else` çağrısının sonucunu veya null döndürür. - `$predicate` parametresi `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. +Yineleyicinin ilk öğesini döndürür. `$predicate` sağlanmışsa, verilen koşulu karşılayan ilk öğeyi döndürür. `$predicate` işlevi `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. Eşleşen bir öğe bulunamazsa, `$else` işlevi (sağlanmışsa) çağrılır ve sonucu döndürülür. `$else` sağlanmamışsa, `null` döndürülür. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Bu yöntem, bir koleksiyonun ilk öğesini veya belirli bir koşulu karşılayan ilk öğeyi, tüm koleksiyonda manuel olarak yinelemeden hızlı bir şekilde almanız gerektiğinde kullanışlıdır. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -İlk öğenin anahtarını döndürür (belirtilmişse, yüklemle eşleşen). Böyle bir öğe yoksa, `$else` çağrısının sonucunu veya null döndürür. Yüklem `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. +Yineleyicinin ilk öğesinin anahtarını döndürür. `$predicate` sağlanmışsa, verilen koşulu karşılayan ilk öğenin anahtarını döndürür. `$predicate` işlevi `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. Eşleşen bir öğe bulunamazsa, `$else` işlevi (sağlanmışsa) çağrılır ve sonucu döndürülür. `$else` sağlanmamışsa, `null` döndürülür. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- - `$transformer` adresini çağırarak değerleri dönüştüren yineleyici. `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. Orijinal anahtarları korur. +Orijinal yineleyicinin her bir öğesine `$transformer` işlevini uygulayarak yeni bir yineleyici oluşturur. `$transformer` işlevi `function ($value, $key, iterable $iterable): mixed` imzasına sahiptir ve geri dönüş değeri öğenin yeni değeri olarak kullanılır. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Yöntem bir üreteç kullanır, yani dönüşüm yineleme sırasında artımlı olarak gerçekleşir. Bu, bellek açısından verimlidir ve çok büyük koleksiyonların işlenmesine olanak sağlar. Elde edilen yineleyicinin tüm öğeleri boyunca yineleme yapmazsanız, orijinal yineleyicinin tüm öğeleri işlenmediğinden hesaplama çabasından tasarruf edersiniz. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Orijinal yineleyicinin değerlerini ve anahtarlarını dönüştürerek yeni bir yineleyici oluşturur. `$transformer` işlevi `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}` imzasına sahiptir. `$transformer` , `null` döndürürse, öğe atlanır. Tutulan elemanlar için, döndürülen dizinin ilk elemanı yeni anahtar ve ikinci elemanı yeni değer olarak kullanılır. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + + `map()` gibi, bu yöntem de artımlı işleme ve bellek verimliliği için bir üreteç kullanır. Bu, büyük koleksiyonlarla çalışmaya ve sonucun yalnızca bir kısmını işleyerek hesaplama çabasından tasarruf etmeye olanak tanır. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Yineleme sırasında anahtarlarını ve değerlerini önbelleğe alan bir yineleyici etrafında bir sarmalayıcı oluşturur. Bu, orijinal veri kaynağını yeniden işlemek zorunda kalmadan veriler üzerinde tekrarlanan yinelemelere olanak tanır. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Bu yöntem, aynı veri kümesi üzerinde birden çok kez yineleme yapmanız gereken, ancak orijinal yineleyicinin yinelemeyi desteklemediği veya yinelemenin maliyetli olacağı durumlarda (örneğin, bir veritabanından veya dosyadan veri okuma) kullanışlıdır. + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Yineleyicinin en az bir öğesinin `$predicate` içinde `function ($value, $key, iterable $iterable): bool` imzasıyla uygulanan bir testi geçip geçmediğini test eder. +Yineleyicinin en az bir öğesinin `$predicate` içinde tanımlanan koşulu sağlayıp sağlamadığını kontrol eder. `$predicate` işlevi `function ($value, $key, iterable $iterable): bool` imzasına sahiptir ve `some()` yönteminin `true` döndürmesi için en az bir öğe için `true` döndürmelidir. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` +Bu yöntem, bir koleksiyonda belirli bir koşulu karşılayan en az bir öğe olup olmadığını (örneğin, koleksiyonun en az bir çift sayı içerip içermediğini) hızlı bir şekilde doğrulamak için kullanışlıdır. + Bkz. [every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Herhangi bir yinelenebilir nesneyi (dizi, Traversable) bir Iterator'a dönüştürür. Girdi zaten bir Iterator ise, değişmeden döndürülür. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Bu yöntem, girdi veri türünden bağımsız olarak bir Yineleyiciniz olduğundan emin olmanız gerektiğinde kullanışlıdır. Bu, farklı yinelenebilir veri türleriyle çalışan fonksiyonlar oluştururken faydalı olabilir. diff --git a/utils/tr/strings.texy b/utils/tr/strings.texy index 43579b10ed..86a1669f76 100644 --- a/utils/tr/strings.texy +++ b/utils/tr/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Dizeyi, düzenli ifadeyle eşleşen tüm oluşumlar için arar ve bulunan ifadeyi ve her bir alt ifadeyi içeren bir dizi dizisi döndürür. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Eğer `$lazy` `true` ise, fonksiyon bir dizi yerine bir `Generator` döndürür, bu da büyük dizelerle çalışırken önemli performans avantajları sağlar. Üreteç, tüm dizeyi bir kerede işlemek yerine eşleşmelerin artımlı olarak bulunmasına olanak tanır. Bu, son derece büyük girdi metinlerinin verimli bir şekilde işlenmesini sağlar. Ayrıca, istediğiniz eşleşmeyi bulduğunuzda işlemeyi istediğiniz zaman kesebilir ve hesaplama süresinden tasarruf edebilirsiniz. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/utils/uk/@home.texy b/utils/uk/@home.texy index 9fa4b85aba..1189910bc7 100644 --- a/utils/uk/@home.texy +++ b/utils/uk/@home.texy @@ -35,7 +35,7 @@ composer require nette/utils | Версія, сумісна з PHP |-----------|------------------- -| Nette Utils 4.0 | PHP 8.0 – 8.3 +| Nette Utils 4.0 | PHP 8.0 – 8.4 | Nette Utils 3.2 | PHP 7.2 – 8.3 | Nette Utils 3.0 - 3.1 | PHP 7.1 - 8.0 | Nette Utils 2.5 | PHP 5.6 - 8.0 diff --git a/utils/uk/arrays.texy b/utils/uk/arrays.texy index cd19d823e4..3099c3d6ff 100644 --- a/utils/uk/arrays.texy +++ b/utils/uk/arrays.texy @@ -310,6 +310,20 @@ $res = Arrays::map($array, fn($value) => $value . $value); ``` +mapWithKeys(array $array, callable $transformer): array .[method] +----------------------------------------------------------------- + +Створює новий масив шляхом перетворення значень і ключів вихідного масиву. Функція `$transformer` має сигнатуру `function ($value, $key, array $array): ?array{$newValue, $newKey}`. Якщо `$transformer` повертає `null`, елемент пропускається. Для збережених елементів перший елемент повернутого масиву використовується як новий ключ, а другий елемент - як нове значення. + +```php +$array = ['a' => 1, 'b' => 2, 'c' => 3]; +$result = Arrays::mapWithKeys($array, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Цей метод корисний у ситуаціях, коли потрібно змінити структуру масиву (і ключі, і значення одночасно) або відфільтрувати елементи під час перетворення (повертаючи нуль для небажаних елементів). + + mergeTree(array $array1, array $array2): array .[method] -------------------------------------------------------- diff --git a/utils/uk/iterables.texy b/utils/uk/iterables.texy index 4321573824..a9009c63ad 100644 --- a/utils/uk/iterables.texy +++ b/utils/uk/iterables.texy @@ -11,7 +11,7 @@ composer require nette/utils ``` -Усі приклади передбачають створення псевдоніма: +У всіх прикладах передбачається, що створено наступний псевдонім: ```php use Nette\Utils\Iterables; @@ -21,18 +21,20 @@ use Nette\Utils\Iterables; contains(iterable $iterable, $value): bool .[method] ---------------------------------------------------- -Перевіряє наявність значення в ітераторі. Використовує строге порівняння (`===`). +Шукає задане значення в ітераторі. Використовує строге порівняння (`===`) для перевірки на збіг. Повертає `true`, якщо значення знайдено, інакше `false`. ```php Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false ``` +Цей метод корисний, коли вам потрібно швидко визначити, чи присутнє певне значення в ітераторі без ручного перебору всіх елементів. -containsKey(iterable $iterable, $value): bool .[method] -------------------------------------------------------- -Перевіряє наявність ключа в ітераторі. Використовує строге порівняння (`===`). +containsKey(iterable $iterable, $key): bool .[method] +----------------------------------------------------- + +Шукає заданий ключ в ітераторі. Використовує строге порівняння (`===`) для перевірки на збіг. Повертає `true`, якщо ключ знайдено, інакше `false`. ```php Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true @@ -43,7 +45,7 @@ Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false every(iterable $iterable, callable $predicate): bool .[method] -------------------------------------------------------------- -Перевіряє, чи всі елементи ітератора проходять тест, реалізований у `$predicate` з сигнатурою `function ($value, $key, iterable $iterable): bool`. +Перевіряє, чи всі елементи ітератора задовольняють умову, визначену в `$predicate`. Функція `$predicate` має сигнатуру `function ($value, $key, iterable $iterable): bool` і повинна повертати `true` для кожного елементу, щоб метод `every()` повертав `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -51,13 +53,13 @@ $isBelowThreshold = fn($value) => $value < 40; $res = Iterables::every($iterator, $isBelowThreshold); // true ``` -Див. [функцію some() |#some()]. +Цей метод корисний для перевірки того, що всі елементи колекції задовольняють певну умову, наприклад, чи всі числа є меншими за певне значення. filter(iterable $iterable, callable $predicate): Generator .[method] -------------------------------------------------------------------- -Ітератор, який фільтрує елементи за предикатом. Предикат має сигнатуру `function ($value, $key, iterable $iterable): bool`. Зберігає оригінальні ключі. +Створює новий ітератор, який містить тільки ті елементи з початкового ітератора, які задовольняють умову, визначену в `$predicate`. Функція `$predicate` має сигнатуру `function ($value, $key, iterable $iterable): bool` і повинна повернути `true` для елементів, які слід зберегти. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -65,12 +67,13 @@ $iterator = Iterables::filter($iterator, fn($v) => $v < 3); // 1, 2 ``` +Метод використовує генератор, що означає, що фільтрація відбувається інкрементно під час ітерації. Це ефективно використовує пам'ять і дозволяє обробляти дуже великі колекції. Якщо ви не перебираєте всі елементи результуючого ітератора, ви економите обчислювальні зусилля, оскільки не всі елементи початкового ітератора обробляються. + first(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ------------------------------------------------------------------------------------------- -Повертає перший елемент (що збігається з предикатом, якщо його вказано). Якщо такого елемента не існує, повертає результат виклику `$else` або нуль. -Параметр `$predicate` має сигнатуру `function ($value, $key, iterable $iterable): bool`. +Повертає перший елемент ітератора. Якщо вказано `$predicate`, повертається перший елемент, який задовольняє задану умову. Функція `$predicate` має сигнатуру `function ($value, $key, iterable $iterable): bool`. Якщо відповідного елемента не знайдено, викликається функція `$else` (якщо вона задана) і повертається її результат. Якщо `$else` не задано, повертається `null`. ```php Iterables::first(new ArrayIterator([1, 2, 3])); // 1 @@ -79,11 +82,13 @@ Iterables::first(new ArrayIterator([])); // null Iterables::first(new ArrayIterator([]), else: fn() => false); // false ``` +Цей метод корисний, коли потрібно швидко отримати перший елемент колекції або перший елемент, який задовольняє певну умову, без ручного перебору всієї колекції. + firstKey(iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed .[method] ---------------------------------------------------------------------------------------------- -Повертає ключ першого елемента (збігається з предикатом, якщо вказано). Якщо такого елемента не існує, повертає результат виклику `$else` або нуль. Предикат має сигнатуру `function ($value, $key, iterable $iterable): bool`. +Повертає ключ першого елемента ітератора. Якщо вказано `$predicate`, повертає ключ першого елемента, який задовольняє задану умову. Функція `$predicate` має сигнатуру `function ($value, $key, iterable $iterable): bool`. Якщо відповідного елемента не знайдено, викликається функція `$else` (якщо вона передбачена) і повертається її результат. Якщо `$else` не задано, повертається `null`. ```php Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 @@ -93,10 +98,10 @@ Iterables::firstKey(new ArrayIterator([])); // null ``` -map(iterable $iterable, callable $transformer): array .[method] ---------------------------------------------------------------- +map(iterable $iterable, callable $transformer): Generator .[method] +------------------------------------------------------------------- -Ітератор, що перетворює значення шляхом виклику `$transformer`. Має сигнатуру `function ($value, $key, iterable $iterable): bool`. Зберігає оригінальні ключі. +Створює новий ітератор шляхом застосування функції `$transformer` до кожного елемента початкового ітератора. Функція `$transformer` має сигнатуру `function ($value, $key, iterable $iterable): mixed` і її значення, що повертається, використовується як нове значення елемента. ```php $iterator = new ArrayIterator([1, 2, 3]); @@ -104,11 +109,41 @@ $iterator = Iterables::map($iterator, fn($v) => $v * 2); // 2, 4, 6 ``` +Метод використовує генератор, що означає, що перетворення відбувається інкрементно під час ітерації. Це ефективно використовує пам'ять і дозволяє працювати з дуже великими колекціями. Якщо ви не перебираєте всі елементи результуючого ітератора, ви економите обчислювальні зусилля, оскільки не всі елементи початкового ітератора обробляються. + + +mapWithKeys(iterable $iterable, callable $transformer): Generator .[method] +--------------------------------------------------------------------------- + +Створює новий ітератор шляхом перетворення значень і ключів вихідного ітератора. Функція `$transformer` має сигнатуру `function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}`. Якщо `$transformer` повертає `null`, елемент пропускається. Для збережених елементів перший елемент повернутого масиву використовується як новий ключ, а другий елемент - як нове значення. + +```php +$iterator = new ArrayIterator(['a' => 1, 'b' => 2]); +$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null); +// [4 => 'B'] +``` + +Як і `map()`, цей метод використовує генератор для інкрементної обробки та ефективності використання пам'яті. Це дозволяє працювати з великими колекціями та економити обчислювальні зусилля, обробляючи лише частину результату. + + +memoize(iterable $iterable): IteratorAggregate .[method] +-------------------------------------------------------- + +Створює обгортку навколо ітератора, яка кешує його ключі та значення під час ітерації. Це дозволяє повторювати ітерації над даними без необхідності переробляти початкове джерело даних. + +```php +$iterator = /* data that cannot be iterated multiple times */ +$memoized = Iterables::memoize($iterator); +// Now you can iterate $memoized multiple times without data loss +``` + +Цей метод корисний у ситуаціях, коли вам потрібно повторювати один і той самий набір даних кілька разів, але оригінальний ітератор не підтримує повторні ітерації або повторні ітерації були б дорогими (наприклад, читання даних з бази даних або файлу). + some(iterable $iterable, callable $predicate): bool .[method] ------------------------------------------------------------- -Перевіряє, чи проходить хоча б один елемент ітератора тест, реалізований у `$predicate` з сигнатурою `function ($value, $key, iterable $iterable): bool`. +Перевіряє, чи хоча б один елемент ітератора задовольняє умову, визначену в `$predicate`. Функція `$predicate` має сигнатуру `function ($value, $key, iterable $iterable): bool` і повинна повернути `true` для хоча б одного елементу, щоб метод `some()` повернув `true`. ```php $iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); @@ -116,4 +151,20 @@ $isEven = fn($value) => $value % 2 === 0; $res = Iterables::some($iterator, $isEven); // true ``` -Див. [функцію every() |#every()]. +Цей метод корисний для швидкої перевірки, чи є в колекції хоча б один елемент, який задовольняє певній умові, наприклад, чи містить колекція хоча б одне парне число. + +Див. опис [методу every() |#every()]. + + +toIterator(iterable $iterable): Iterator .[method] +-------------------------------------------------- + +Перетворює будь-який ітерований об'єкт (масив, Traversable) в ітератор. Якщо на вході вже є ітератор, він повертається без змін. + +```php +$array = [1, 2, 3]; +$iterator = Iterables::toIterator($array); +// Now you have an Iterator instead of an array +``` + +Цей метод корисний, коли вам потрібно переконатися, що у вас є ітератор, незалежно від типу вхідних даних. Це може бути корисно при створенні функцій, які працюють з різними типами даних, що повторюються. diff --git a/utils/uk/strings.texy b/utils/uk/strings.texy index d0bb35d4b0..f6af01fbfb 100644 --- a/utils/uk/strings.texy +++ b/utils/uk/strings.texy @@ -483,8 +483,8 @@ Strings::match('žlutý!', '~\w+(!+)?~', captureOffset: true, utf8: true); ``` -matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false): array .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +matchAll(string $subject, string $pattern, bool $captureOffset=false, int $offset=0, bool $unmatchedAsNull=false, bool $patternOrder=false, bool $utf8=false, bool $lazy=false): array|Generator .[method] +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Шукає в рядку всі входження, що відповідають регулярному виразу, і повертає масив масивів, що містять знайдений вираз і кожен підвираз. @@ -550,6 +550,16 @@ Strings::matchAll('žlutý kůň', '~\w+~', captureOffset: true, utf8: true); ] */ ``` +Якщо `$lazy` є `true`, функція повертає `Generator` замість масиву, що дає значні переваги у продуктивності при роботі з великими рядками. Генератор дозволяє шукати збіги поступово, а не обробляти весь рядок одразу. Це дозволяє ефективно працювати з дуже великими вхідними текстами. Крім того, ви можете перервати обробку в будь-який момент, якщо знайдете потрібний збіг, заощадивши час обчислень. + +```php +$matches = Strings::matchAll($largeText, '~\w+~', lazy: true); +foreach ($matches as $match) { + echo "Found: $match[0]\n"; + // Processing can be interrupted at any time +} +``` + replace(string $subject, string|array $pattern, string|callable $replacement='', int $limit=-1, bool $captureOffset=false, bool $unmatchedAsNull=false, bool $utf8=false): string .[method] ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- From 13d44703067c693e12b39f1b182a815f356e6fdd Mon Sep 17 00:00:00 2001 From: David Grudl Date: Fri, 9 Aug 2024 13:13:23 +0200 Subject: [PATCH 02/23] nette/database 3.2.4 --- database/bg/configuration.texy | 4 +- database/bg/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/cs/configuration.texy | 4 +- database/cs/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/cs/explorer.texy | 1 + database/de/configuration.texy | 4 +- database/de/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/el/configuration.texy | 4 +- database/el/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/en/configuration.texy | 4 +- database/en/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/es/configuration.texy | 4 +- database/es/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/fr/configuration.texy | 4 +- database/fr/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/hu/configuration.texy | 4 +- database/hu/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/it/configuration.texy | 4 +- database/it/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/pl/configuration.texy | 4 +- database/pl/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/pt/configuration.texy | 4 +- database/pt/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/ro/configuration.texy | 2 +- database/ro/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/ru/configuration.texy | 4 +- database/ru/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/sl/configuration.texy | 4 +- database/sl/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/tr/configuration.texy | 4 +- database/tr/core.texy | 92 ++++++++++++++++++++++++++++++++++ database/uk/configuration.texy | 4 +- database/uk/core.texy | 92 ++++++++++++++++++++++++++++++++++ 33 files changed, 1504 insertions(+), 31 deletions(-) diff --git a/database/bg/configuration.texy b/database/bg/configuration.texy index 240dd45ba5..ea28bef4cb 100644 --- a/database/bg/configuration.texy +++ b/database/bg/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # само за MySQL: set SET NAMES - charset: # (string) по подразбиране е 'utf8mb4' ('utf8' преди v5.5.3) + charset: # (string) по подразбиране е 'utf8mb4' # само за MySQL: преобразува TINYINT(1) в bool - supportBooleans: # (bool) по подразбиране е false + convertBoolean: # (bool) по подразбиране е false # връща колони с дати като неизменни обекти (от версия 3.2.1) newDateTime: # (bool) по подразбиране е false diff --git a/database/bg/core.texy b/database/bg/core.texy index 3f1ed5af5c..c65427e121 100644 --- a/database/bg/core.texy +++ b/database/bg/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Както можете да видите, методът `transaction()` връща стойността на обратната връзка. Функцията Transaction() също може да бъде вложена, което опростява прилагането на независими хранилища. + + +Отражение .[#toc-reflection] +============================ + +Nette Database предоставя инструменти за интроспекция на структурата на базата данни чрез класа [api:Nette\Database\Reflection]. Този клас ви позволява да извличате информация за таблици, колони, индекси и външни ключове. Можете да използвате отразяването, за да генерирате схеми, да създавате гъвкави приложения, които работят с бази данни, или да изграждате общи инструменти за бази данни. + +Можете да получите обект за отразяване от инстанция за връзка с база данни: + +```php +$reflection = $database->getReflection(); +``` + + +Работа с таблици .[#toc-working-with-tables] +-------------------------------------------- + +С помощта на отразяването можете да правите итерации по всички таблици в базата данни: + +```php +// Избройте имената на всички таблици +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Проверете дали дадена таблица съществува +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Извличане на определена таблица +$table = $reflection->getTable('users'); +``` + + +Информация за колоната .[#toc-column-information] +------------------------------------------------- + +За всяка таблица можете да получите подробна информация за нейните колони: + +```php +// Итерация над всички колони +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Извличане на конкретна колона +$idColumn = $table->getColumn('id'); +``` + + +Индекси и първични ключове .[#toc-indexes-and-primary-keys] +----------------------------------------------------------- + +Отражението предоставя информация за индексите и първичните ключове: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Списък на всички индекси +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Извличане на първичния ключ +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Чужди ключове .[#toc-foreign-keys] +---------------------------------- + +Можете също така да получите информация за чуждите ключове: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/cs/configuration.texy b/database/cs/configuration.texy index 14b2231d43..021ee3cd11 100644 --- a/database/cs/configuration.texy +++ b/database/cs/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # pouze MySQL: nastaví SET NAMES - charset: # (string) výchozí je 'utf8mb4' ('utf8' před verzí 5.5.3) + charset: # (string) výchozí je 'utf8mb4' # pouze MySQL: převádí TINYINT(1) na bool - supportBooleans: # (bool) výchozí je false + convertBoolean: # (bool) výchozí je false # vrací sloupce s datem jako immutable objekty (od verze 3.2.1) newDateTime: # (bool) výchozí je false diff --git a/database/cs/core.texy b/database/cs/core.texy index 02c3104e43..23623a760c 100644 --- a/database/cs/core.texy +++ b/database/cs/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Jak vidíte, metoda `transaction()` vrací návratovou hodnotu callbacku. Volání `transaction()` může být i zanořeno, což zjednodušuje implementaci nezávislých repozitářů. + + +Reflexe .{data-version:3.2.1} +============================= + +Nette Database poskytuje nástroje pro introspekci databázové struktury pomocí třídy [api:Nette\Database\Reflection]. Ta umožňuje získávat informace o tabulkách, sloupcích, indexech a cizích klíčích. Reflexi můžete využít ke generování schémat, vytváření flexibilních aplikací pracujících s databází nebo obecných databázových nástrojů. + +Objekt reflexe získáme z instance připojení k databázi: + +```php +$reflection = $database->getReflection(); +``` + + +Práce s tabulkami +----------------- + +Pomocí reflexe můžeme procházet všechny tabulky v databázi: + +```php +// Výpis názvů všech tabulek +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Ověření existence tabulky +if ($reflection->hasTable('users')) { + echo "Tabulka users existuje"; +} + +// Získání konkrétní tabulky +$table = $reflection->getTable('users'); +``` + + +Informace o sloupcích +--------------------- + +Pro každou tabulku můžeme získat detailní informace o jejích sloupcích: + +```php +// Procházení všech sloupců +foreach ($table->columns as $column) { + echo "Sloupec: " . $column->name . "\n"; + echo "Typ: " . $column->nativeType . "\n"; + echo "Může být NULL: " . ($column->nullable ? 'Ano' : 'Ne') . "\n"; + echo "Výchozí hodnota: " . ($column->default ?? 'Není') . "\n"; + echo "Je primární klíč: " . ($column->primary ? 'Ano' : 'Ne') . "\n"; + echo "Je auto-increment: " . ($column->autoIncrement ? 'Ano' : 'Ne') . "\n"; +} + +// Získání konkrétního sloupce +$idColumn = $table->getColumn('id'); +``` + + +Indexy a primární klíče +----------------------- + +Reflection poskytuje informace o indexech a primárních klíčích: + +```php +$vypisNazvySloupcu = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Výpis všech indexů +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Nepojmenovaný') . "\n"; + echo "Sloupce: " . $vypisNazvySloupcu($index->columns) . "\n"; + echo "Je unikátní: " . ($index->unique ? 'Ano' : 'Ne') . "\n"; + echo "Je primární klíč: " . ($index->primary ? 'Ano' : 'Ne') . "\n"; +} + +// Získání primárního klíče +if ($table->primaryKey) { + echo "Primární klíč: " . $vypisNazvySloupcu($table->primaryKey->columns) . "\n"; +} +``` + + +Cizí klíče +---------- + +Můžeme také získat informace o cizích klíčích: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Cizí klíč: " . ($fk->name ?? 'Nepojmenovaný') . "\n"; + echo "Lokální sloupce: " . $vypisNazvySloupcu($fk->localColumns) . "\n"; + echo "Odkazuje na tabulku: {$fk->foreignTable->name}\n"; + echo "Odkazuje na sloupce: " . $vypisNazvySloupcu($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/cs/explorer.texy b/database/cs/explorer.texy index 629eb372b7..d1f397fd5a 100644 --- a/database/cs/explorer.texy +++ b/database/cs/explorer.texy @@ -339,6 +339,7 @@ Database Explorer umí chytře escapovat parametry a identifikátory. Pro správ | `$row = $table->fetch()` | Vrátí další řádek výsledku | `$array = $table->fetchPairs($key, $value)` | Vrátí všechny výsledky jako asociativní pole | `$array = $table->fetchPairs($value)` | Vrátí všechny řádky jako asociativní pole +| `$array = $table->fetchPairs($callable)` | Callback vrací `[$value]` nebo `[$key, $value]` | `count($table)` | Vrátí počet řádků výsledku diff --git a/database/de/configuration.texy b/database/de/configuration.texy index d7284317dc..cf3baac899 100644 --- a/database/de/configuration.texy +++ b/database/de/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # nur MySQL: setzt SET NAMES - charset: # (string) Standardwert ist 'utf8mb4' ('utf8' vor v5.5.3) + charset: # (string) Standardwert ist 'utf8mb4' # nur MySQL: wandelt TINYINT(1) in bool um - supportBooleans: # (bool) standardmäßig false + convertBoolean: # (bool) standardmäßig false # Gibt Datumsspalten als unveränderliche Objekte zurück (seit Version 3.2.1) newDateTime: # (bool) standardmäßig false diff --git a/database/de/core.texy b/database/de/core.texy index 75b7f21349..ae71c85c57 100644 --- a/database/de/core.texy +++ b/database/de/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Wie Sie sehen können, gibt die Methode `transaction()` den Rückgabewert des Callbacks zurück. Die Transaktion() kann auch verschachtelt werden, was die Implementierung unabhängiger Repositories vereinfacht. + + +Reflexion .[#toc-reflection] +============================ + +Nette Database bietet mit der Klasse [api:Nette\Database\Reflection] Werkzeuge für die Introspektion der Datenbankstruktur. Mit dieser Klasse können Sie Informationen über Tabellen, Spalten, Indizes und Fremdschlüssel abrufen. Sie können Reflection verwenden, um Schemata zu generieren, flexible Anwendungen zu erstellen, die mit Datenbanken arbeiten, oder allgemeine Datenbank-Tools zu entwickeln. + +Sie können ein Reflection-Objekt von einer Datenbankverbindungsinstanz abrufen: + +```php +$reflection = $database->getReflection(); +``` + + +Arbeiten mit Tabellen .[#toc-working-with-tables] +------------------------------------------------- + +Mit Hilfe von Reflection können Sie über alle Tabellen in der Datenbank iterieren: + +```php +// Auflisten der Namen aller Tabellen +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Prüfen, ob eine Tabelle existiert +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Abrufen einer bestimmten Tabelle +$table = $reflection->getTable('users'); +``` + + +Informationen zur Säule .[#toc-column-information] +-------------------------------------------------- + +Für jede Tabelle können Sie detaillierte Informationen über ihre Spalten erhalten: + +```php +// Iterieren über alle Spalten +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Eine bestimmte Spalte abrufen +$idColumn = $table->getColumn('id'); +``` + + +Indizes und Primärschlüssel .[#toc-indexes-and-primary-keys] +------------------------------------------------------------ + +Reflection bietet Informationen zu Indizes und Primärschlüsseln: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Alle Indizes auflisten +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Abrufen des Primärschlüssels +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Ausländische Schlüssel .[#toc-foreign-keys] +------------------------------------------- + +Sie können auch Informationen über Fremdschlüssel erhalten: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/el/configuration.texy b/database/el/configuration.texy index 81e8d3d1e1..ff1516d944 100644 --- a/database/el/configuration.texy +++ b/database/el/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # μόνο MySQL: ορίζει SET NAMES - charset: # (string) προεπιλογή 'utf8mb4' ('utf8' πριν την έκδοση v5.5.3) + charset: # (string) προεπιλογή 'utf8mb4' # μόνο MySQL: μετατρέπει το TINYINT(1) σε bool - supportBooleans: # (bool) προεπιλογή σε false + convertBoolean: # (bool) προεπιλογή σε false # επιστρέφει τις στήλες ημερομηνίας ως αμετάβλητα αντικείμενα (από την έκδοση 3.2.1) newDateTime: # (bool) με προεπιλογή false diff --git a/database/el/core.texy b/database/el/core.texy index 8087562d37..b1f0de4d02 100644 --- a/database/el/core.texy +++ b/database/el/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Όπως μπορείτε να δείτε, η μέθοδος `transaction()` επιστρέφει την τιμή επιστροφής του callback. Η transaction() μπορεί επίσης να είναι εμφωλευμένη, γεγονός που απλοποιεί την υλοποίηση ανεξάρτητων αποθετηρίων. + + +Αντανάκλαση .[#toc-reflection] +============================== + +Η Nette Database παρέχει εργαλεία για την ενδοσκόπηση της δομής της βάσης δεδομένων μέσω της κλάσης [api:Nette\Database\Reflection]. Αυτή η κλάση σας επιτρέπει να ανακτάτε πληροφορίες σχετικά με πίνακες, στήλες, δείκτες και ξένα κλειδιά. Μπορείτε να χρησιμοποιήσετε την αντανάκλαση για να δημιουργήσετε σχήματα, να δημιουργήσετε ευέλικτες εφαρμογές που δουλεύουν με βάσεις δεδομένων ή να δημιουργήσετε γενικά εργαλεία βάσεων δεδομένων. + +Μπορείτε να λάβετε ένα αντικείμενο αντανάκλασης από μια περίπτωση σύνδεσης με βάση δεδομένων: + +```php +$reflection = $database->getReflection(); +``` + + +Εργασία με πίνακες .[#toc-working-with-tables] +---------------------------------------------- + +Χρησιμοποιώντας την αντανάκλαση, μπορείτε να κάνετε επανάληψη σε όλους τους πίνακες της βάσης δεδομένων: + +```php +// Αναφέρετε τα ονόματα όλων των πινάκων +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Έλεγχος αν υπάρχει πίνακας +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Ανάκτηση ενός συγκεκριμένου πίνακα +$table = $reflection->getTable('users'); +``` + + +Πληροφορίες στήλης .[#toc-column-information] +--------------------------------------------- + +Για κάθε πίνακα, μπορείτε να λάβετε λεπτομερείς πληροφορίες για τις στήλες του: + +```php +// Επανάληψη σε όλες τις στήλες +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Ανάκτηση μιας συγκεκριμένης στήλης +$idColumn = $table->getColumn('id'); +``` + + +Δείκτες και πρωτεύοντα κλειδιά .[#toc-indexes-and-primary-keys] +--------------------------------------------------------------- + +Η αντανάκλαση παρέχει πληροφορίες σχετικά με τους δείκτες και τα πρωτεύοντα κλειδιά: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Κατάλογος όλων των ευρετηρίων +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Ανάκτηση του πρωτεύοντος κλειδιού +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Ξένα κλειδιά .[#toc-foreign-keys] +--------------------------------- + +Μπορείτε επίσης να λάβετε πληροφορίες σχετικά με τα ξένα κλειδιά: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/en/configuration.texy b/database/en/configuration.texy index b6c78ce38a..23f06962d6 100644 --- a/database/en/configuration.texy +++ b/database/en/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # MySQL only: sets SET NAMES - charset: # (string) defaults to 'utf8mb4' ('utf8' before v5.5.3) + charset: # (string) defaults to 'utf8mb4' # MySQL only: converts TINYINT(1) to bool - supportBooleans: # (bool) defaults to false + convertBoolean: # (bool) defaults to false # returns date columns as immutable objects (since version 3.2.1) newDateTime: # (bool) defaults to false diff --git a/database/en/core.texy b/database/en/core.texy index d950f13509..1b48ece063 100644 --- a/database/en/core.texy +++ b/database/en/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { As you can see, the `transaction()` method returns the return value of the callback. The transaction() can also be nested, which simplifies the implementation of independent repositories. + + +Reflection .{data-version:3.2.1} +================================ + +Nette Database provides tools for introspecting database structure through the [api:Nette\Database\Reflection] class. This class allows you to retrieve information about tables, columns, indexes, and foreign keys. You can use reflection to generate schemas, create flexible applications that work with databases, or build general database tools. + +You can obtain a reflection object from a database connection instance: + +```php +$reflection = $database->getReflection(); +``` + + +Working with Tables +------------------- + +Using reflection, you can iterate over all tables in the database: + +```php +// List the names of all tables +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Check if a table exists +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Retrieve a specific table +$table = $reflection->getTable('users'); +``` + + +Column Information +------------------ + +For each table, you can get detailed information about its columns: + +```php +// Iterate over all columns +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes' : 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes' : 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes' : 'No') . "\n"; +} + +// Retrieve a specific column +$idColumn = $table->getColumn('id'); +``` + + +Indexes and Primary Keys +------------------------ + +Reflection provides information about indexes and primary keys: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// List all indexes +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes' : 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes' : 'No') . "\n"; +} + +// Retrieve the primary key +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Foreign Keys +------------ + +You can also get information about foreign keys: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/es/configuration.texy b/database/es/configuration.texy index 1588b547f3..db55b6863c 100644 --- a/database/es/configuration.texy +++ b/database/es/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # sólo MySQL: sets SET NAMES - charset: # (string) defaults to 'utf8mb4' ('utf8' before v5.5.3) + charset: # (string) defaults to 'utf8mb4' # sólo MySQL: convierte TINYINT(1) a bool - supportBooleans: # (bool) por defecto false + convertBoolean: # (bool) por defecto false # devuelve columnas de fecha como objetos inmutables (desde la versión 3.2.1) newDateTime: # (bool) por defecto false diff --git a/database/es/core.texy b/database/es/core.texy index 9944ca9332..2db4eceb66 100644 --- a/database/es/core.texy +++ b/database/es/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Como puede ver, el método `transaction()` devuelve el valor de retorno de la llamada de retorno. La transacción() también se puede anidar, lo que simplifica la implementación de repositorios independientes. + + +Reflexión .[#toc-reflection] +============================ + +Nette Database proporciona herramientas para la introspección de la estructura de la base de datos a través de la clase [api:Nette\Database\Reflection]. Esta clase permite recuperar información sobre tablas, columnas, índices y claves externas. Puedes utilizar reflection para generar esquemas, crear aplicaciones flexibles que trabajen con bases de datos o construir herramientas generales de bases de datos. + +Puede obtener un objeto reflection a partir de una instancia de conexión a una base de datos: + +```php +$reflection = $database->getReflection(); +``` + + +Trabajar con tablas .[#toc-working-with-tables] +----------------------------------------------- + +Usando reflection, puedes iterar sobre todas las tablas de la base de datos: + +```php +// Listar los nombres de todas las tablas +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Comprobar si existe una tabla +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Recuperar una tabla específica +$table = $reflection->getTable('users'); +``` + + +Información sobre columnas .[#toc-column-information] +----------------------------------------------------- + +Para cada tabla, puede obtener información detallada sobre sus columnas: + +```php +// Iterar sobre todas las columnas +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Recuperar una columna específica +$idColumn = $table->getColumn('id'); +``` + + +Índices y claves primarias .[#toc-indexes-and-primary-keys] +----------------------------------------------------------- + +Reflection proporciona información sobre índices y claves primarias: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Listar todos los índices +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Recuperar la clave primaria +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Claves extranjeras .[#toc-foreign-keys] +--------------------------------------- + +También puede obtener información sobre claves foráneas: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/fr/configuration.texy b/database/fr/configuration.texy index 730a7b0aa7..727c33a531 100644 --- a/database/fr/configuration.texy +++ b/database/fr/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # uniquement MySQL: sets SET NAMES - charset: # (string) par défaut 'utf8mb4' ('utf8' avant v5.5.3) + charset: # (string) par défaut 'utf8mb4' # uniquement MySQL : convertit TINYINT(1) en bool - supportBooleans : # (bool) valeur par défaut : false + convertBoolean : # (bool) valeur par défaut : false # renvoie les colonnes de date sous forme d'objets immuables (depuis la version 3.2.1) newDateTime : # (bool) valeur par défaut : false diff --git a/database/fr/core.texy b/database/fr/core.texy index 2703fcc41d..cee8eb3219 100644 --- a/database/fr/core.texy +++ b/database/fr/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Comme vous pouvez le voir, la méthode `transaction()` renvoie la valeur de retour de la callback. La transaction() peut également être imbriquée, ce qui simplifie la mise en œuvre de référentiels indépendants. + + +Réflexion .[#toc-reflection] +============================ + +Nette Database fournit des outils d'introspection de la structure de la base de données par le biais de la classe [api:Nette\Database\Reflection]. Cette classe vous permet de récupérer des informations sur les tables, les colonnes, les index et les clés étrangères. Vous pouvez utiliser la réflexion pour générer des schémas, créer des applications flexibles qui fonctionnent avec des bases de données ou construire des outils généraux pour les bases de données. + +Vous pouvez obtenir un objet de réflexion à partir d'une instance de connexion à la base de données : + +```php +$reflection = $database->getReflection(); +``` + + +Travailler avec des tableaux .[#toc-working-with-tables] +-------------------------------------------------------- + +En utilisant la réflexion, vous pouvez itérer sur toutes les tables de la base de données : + +```php +// Liste des noms de toutes les tables +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Vérifier si une table existe +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Récupérer une table spécifique +$table = $reflection->getTable('users'); +``` + + +Informations sur les colonnes .[#toc-column-information] +-------------------------------------------------------- + +Pour chaque table, vous pouvez obtenir des informations détaillées sur ses colonnes : + +```php +// Itérer sur toutes les colonnes +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Récupérer une colonne spécifique +$idColumn = $table->getColumn('id'); +``` + + +Index et clés primaires .[#toc-indexes-and-primary-keys] +-------------------------------------------------------- + +La réflexion fournit des informations sur les index et les clés primaires : + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Liste de tous les index +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Récupérer la clé primaire +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Clés étrangères .[#toc-foreign-keys] +------------------------------------ + +Vous pouvez également obtenir des informations sur les clés étrangères : + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/hu/configuration.texy b/database/hu/configuration.texy index 680680c7e8..ad28e6f1ed 100644 --- a/database/hu/configuration.texy +++ b/database/hu/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # csak MySQL: sets SET NAMES - charset: # (string) alapértelmezés szerint 'utf8mb4' ('utf8' a v5.5.3 előtt) + charset: # (string) alapértelmezés szerint 'utf8mb4' # csak MySQL: TINYINT(1) bool-ra konvertálja - supportBooleans: # (bool) alapértelmezett értéke false + convertBoolean: # (bool) alapértelmezett értéke false # a dátum oszlopokat megváltoztathatatlan objektumként adja vissza (3.2.1 verzió óta) newDateTime: # (bool) alapértelmezett értéke false diff --git a/database/hu/core.texy b/database/hu/core.texy index 6c303bbcff..5ae0d48220 100644 --- a/database/hu/core.texy +++ b/database/hu/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Mint látható, a `transaction()` metódus a callback visszatérési értékét adja vissza. A tranzakció() is beágyazható, ami egyszerűsíti a független tárolók megvalósítását. + + +Reflection .[#toc-reflection] +============================= + +A Nette Database a [api:Nette\Database\Reflection] osztályon keresztül eszközöket biztosít az adatbázis szerkezetének áttekintéséhez. Ez az osztály lehetővé teszi a táblákról, oszlopokról, indexekről és idegen kulcsokról szóló információk lekérdezését. A reflexiót használhatja sémák létrehozására, adatbázisokkal dolgozó rugalmas alkalmazások létrehozására vagy általános adatbázis-eszközök készítésére. + +A reflection objektumot egy adatbázis-kapcsolati példányból szerezheti meg: + +```php +$reflection = $database->getReflection(); +``` + + +Munka táblázatokkal .[#toc-working-with-tables] +----------------------------------------------- + +A tükrözés segítségével az adatbázis összes tábláján végig tudsz menni: + +```php +// Az összes táblázat nevének felsorolása +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Ellenőrizze, hogy létezik-e táblázat +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Egy adott táblázat lekérdezése +$table = $reflection->getTable('users'); +``` + + +Oszlop információk .[#toc-column-information] +--------------------------------------------- + +Az egyes táblák oszlopairól részletes információkat kaphat: + +```php +// Ismétlés az összes oszlopon +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Egy adott oszlop kinyerése +$idColumn = $table->getColumn('id'); +``` + + +Indexek és elsődleges kulcsok .[#toc-indexes-and-primary-keys] +-------------------------------------------------------------- + +A Reflection az indexekről és az elsődleges kulcsokról nyújt információt: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Az összes index felsorolása +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Az elsődleges kulcs kinyerése +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Idegen kulcsok .[#toc-foreign-keys] +----------------------------------- + +Az idegen kulcsokról is tájékozódhat: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/it/configuration.texy b/database/it/configuration.texy index c4a9ea938d..eef1be2113 100644 --- a/database/it/configuration.texy +++ b/database/it/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # solo MySQL: imposta SET NAMES - charset: # (string) predefinito a 'utf8mb4' ('utf8' prima della v5.5.3) + charset: # (string) predefinito a 'utf8mb4' # solo MySQL: converte TINYINT(1) in bool - supportBooleans: # (bool) predefinito a false + convertBoolean: # (bool) predefinito a false # restituisce le colonne di data come oggetti immutabili (dalla versione 3.2.1) newDateTime: # (bool) predefinito a false diff --git a/database/it/core.texy b/database/it/core.texy index 562e9d941f..113a6f97a5 100644 --- a/database/it/core.texy +++ b/database/it/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Come si può vedere, il metodo `transaction()` restituisce il valore di ritorno della callback. Il metodo transaction() può anche essere annidato, il che semplifica l'implementazione di repository indipendenti. + + +Riflessione .[#toc-reflection] +============================== + +Nette Database offre strumenti per l'introspezione della struttura del database attraverso la classe [api:Nette\Database\Reflection]. Questa classe consente di recuperare informazioni su tabelle, colonne, indici e chiavi esterne. È possibile utilizzare la riflessione per generare schemi, creare applicazioni flessibili che lavorano con i database o costruire strumenti generali per i database. + +È possibile ottenere un oggetto reflection da un'istanza di connessione al database: + +```php +$reflection = $database->getReflection(); +``` + + +Lavorare con le tabelle .[#toc-working-with-tables] +--------------------------------------------------- + +Utilizzando la riflessione, è possibile iterare su tutte le tabelle del database: + +```php +// Elencare i nomi di tutte le tabelle +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Controllare se una tabella esiste +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Recuperare una tabella specifica +$table = $reflection->getTable('users'); +``` + + +Informazioni sulla colonna .[#toc-column-information] +----------------------------------------------------- + +Per ogni tabella è possibile ottenere informazioni dettagliate sulle sue colonne: + +```php +// Iterare su tutte le colonne +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Recuperare una colonna specifica +$idColumn = $table->getColumn('id'); +``` + + +Indici e chiavi primarie .[#toc-indexes-and-primary-keys] +--------------------------------------------------------- + +La riflessione fornisce informazioni su indici e chiavi primarie: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Elencare tutti gli indici +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Recuperare la chiave primaria +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Chiavi straniere .[#toc-foreign-keys] +------------------------------------- + +È inoltre possibile ottenere informazioni sulle chiavi esterne: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/pl/configuration.texy b/database/pl/configuration.texy index 6aeabff64d..f75ca3e36d 100644 --- a/database/pl/configuration.texy +++ b/database/pl/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # Tylko MySQL: ustawia SET NAMES - charset: # (string) default is 'utf8mb4' ('utf8' before 5.5.3) + charset: # (string) default is 'utf8mb4' # Tylko MySQL: konwertuje TINYINT(1) na bool - supportBooleans: # (bool) domyślnie false + convertBoolean: # (bool) domyślnie false # zwraca kolumny daty jako niezmienne obiekty (od wersji 3.2.1) newDateTime: # (bool) domyślnie false diff --git a/database/pl/core.texy b/database/pl/core.texy index 706713ee75..b6caa291a0 100644 --- a/database/pl/core.texy +++ b/database/pl/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Jak widać, metoda `transaction()` zwraca wartość zwrotną wywołania zwrotnego. Callback `transaction()` może być również zagnieżdżony, co upraszcza implementację niezależnych repozytoriów. + + +Refleksja .[#toc-reflection] +============================ + +Nette Database zapewnia narzędzia do introspekcji struktury bazy danych poprzez klasę [api:Nette\Database\Reflection]. Klasa ta umożliwia pobieranie informacji o tabelach, kolumnach, indeksach i kluczach obcych. Refleksji można używać do generowania schematów, tworzenia elastycznych aplikacji współpracujących z bazami danych lub tworzenia ogólnych narzędzi bazodanowych. + +Obiekt refleksji można uzyskać z instancji połączenia z bazą danych: + +```php +$reflection = $database->getReflection(); +``` + + +Praca z tabelami .[#toc-working-with-tables] +-------------------------------------------- + +Używając refleksji, można iterować po wszystkich tabelach w bazie danych: + +```php +// Lista nazw wszystkich tabel +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Sprawdzenie, czy tabela istnieje +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Pobieranie określonej tabeli +$table = $reflection->getTable('users'); +``` + + +Informacje o kolumnie .[#toc-column-information] +------------------------------------------------ + +Dla każdej tabeli można uzyskać szczegółowe informacje o jej kolumnach: + +```php +// Iteracja po wszystkich kolumnach +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Pobieranie określonej kolumny +$idColumn = $table->getColumn('id'); +``` + + +Indeksy i klucze podstawowe .[#toc-indexes-and-primary-keys] +------------------------------------------------------------ + +Refleksja dostarcza informacji na temat indeksów i kluczy głównych: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Lista wszystkich indeksów +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Pobieranie klucza głównego +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Klucze obce .[#toc-foreign-keys] +-------------------------------- + +Można również uzyskać informacje na temat kluczy obcych: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/pt/configuration.texy b/database/pt/configuration.texy index c3d56d07b6..4ed03b56c0 100644 --- a/database/pt/configuration.texy +++ b/database/pt/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # somente MySQL: define o SET NAMES - charset: # (string) padrão para 'utf8mb4' ('utf8' antes da v5.5.3) + charset: # (string) padrão para 'utf8mb4' # somente MySQL: converte TINYINT(1) em bool - supportBooleans: # (bool) tem como padrão false + convertBoolean: # (bool) tem como padrão false # retorna colunas de data como objetos imutáveis (desde a versão 3.2.1) newDateTime: # (bool) tem como padrão false diff --git a/database/pt/core.texy b/database/pt/core.texy index a3a5df1e0a..d4f6314ea0 100644 --- a/database/pt/core.texy +++ b/database/pt/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Como você pode ver, o método `transaction()` retorna o valor de retorno da ligação de retorno. A transação() também pode ser aninhada, o que simplifica a implementação de repositórios independentes. + + +Reflexão .[#toc-reflection] +=========================== + +O Nette Database fornece ferramentas para introspecção da estrutura do banco de dados por meio da classe [api:Nette\Database\Reflection]. Essa classe permite que você recupere informações sobre tabelas, colunas, índices e chaves estrangeiras. Você pode usar a reflexão para gerar esquemas, criar aplicativos flexíveis que funcionem com bancos de dados ou criar ferramentas gerais de banco de dados. + +É possível obter um objeto de reflexão de uma instância de conexão de banco de dados: + +```php +$reflection = $database->getReflection(); +``` + + +Trabalhando com tabelas .[#toc-working-with-tables] +--------------------------------------------------- + +Usando a reflexão, você pode iterar sobre todas as tabelas do banco de dados: + +```php +// Listar os nomes de todas as tabelas +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Verificar se uma tabela existe +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Recuperar uma tabela específica +$table = $reflection->getTable('users'); +``` + + +Informações sobre a coluna .[#toc-column-information] +----------------------------------------------------- + +Para cada tabela, você pode obter informações detalhadas sobre suas colunas: + +```php +// Iterar por todas as colunas +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Recuperar uma coluna específica +$idColumn = $table->getColumn('id'); +``` + + +Índices e chaves primárias .[#toc-indexes-and-primary-keys] +----------------------------------------------------------- + +A reflexão fornece informações sobre índices e chaves primárias: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Listar todos os índices +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Recuperar a chave primária +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Chaves estrangeiras .[#toc-foreign-keys] +---------------------------------------- + +Você também pode obter informações sobre chaves estrangeiras: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/ro/configuration.texy b/database/ro/configuration.texy index a4f9c7c4c6..6d86d3d4eb 100644 --- a/database/ro/configuration.texy +++ b/database/ro/configuration.texy @@ -52,7 +52,7 @@ database: charset: # (șir de caractere) implicit la "utf8mb4" ("utf8" înainte de v5.5.3) # numai MySQL: convertește TINYINT(1) în bool - supportBooleans: # (bool) implicit la false + convertBoolean: # (bool) implicit la false # returnează coloanele de date ca obiecte imuabile (începând cu versiunea 3.2.1) newDateTime: # (bool) valoarea implicită este false diff --git a/database/ro/core.texy b/database/ro/core.texy index 4314a3fe2d..4f6a811159 100644 --- a/database/ro/core.texy +++ b/database/ro/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { După cum puteți vedea, metoda `transaction()` returnează valoarea de returnare a callback-ului. Tranzacția() poate fi, de asemenea, imbricata, ceea ce simplifică implementarea de depozite independente. + + +Reflecție .[#toc-reflection] +============================ + +Nette Database oferă instrumente pentru introspecția structurii bazei de date prin clasa [api:Nette\Database\Reflection]. Această clasă vă permite să obțineți informații despre tabele, coloane, indexuri și chei străine. Puteți utiliza reflecția pentru a genera scheme, pentru a crea aplicații flexibile care lucrează cu baze de date sau pentru a construi instrumente generale pentru baze de date. + +Puteți obține un obiect reflection dintr-o instanță de conexiune la o bază de date: + +```php +$reflection = $database->getReflection(); +``` + + +Lucrul cu tabelele .[#toc-working-with-tables] +---------------------------------------------- + +Folosind reflexia, puteți itera peste toate tabelele din baza de date: + +```php +// Lista numele tuturor tabelelor +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Verificați dacă un tabel există +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Preluarea unui anumit tabel +$table = $reflection->getTable('users'); +``` + + +Informații despre coloană .[#toc-column-information] +---------------------------------------------------- + +Pentru fiecare tabel, puteți obține informații detaliate despre coloanele sale: + +```php +// Iterați peste toate coloanele +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Preluarea unei anumite coloane +$idColumn = $table->getColumn('id'); +``` + + +Indexuri și chei primare .[#toc-indexes-and-primary-keys] +--------------------------------------------------------- + +Reflecția oferă informații despre indici și chei primare: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Lista tuturor indicilor +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Recuperarea cheii primare +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Chei străine .[#toc-foreign-keys] +--------------------------------- + +De asemenea, puteți obține informații despre cheile străine: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/ru/configuration.texy b/database/ru/configuration.texy index b5f4e5b7af..15be644a34 100644 --- a/database/ru/configuration.texy +++ b/database/ru/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # только для MySQL: устанавливает SET NAMES - charset: # (string) по умолчанию 'utf8mb4' ('utf8' до v5.5.3) + charset: # (string) по умолчанию 'utf8mb4' # Только для MySQL: преобразует TINYINT(1) в bool - supportBooleans: # (bool) по умолчанию false + convertBoolean: # (bool) по умолчанию false # возвращает столбцы даты как неизменяемые объекты (с версии 3.2.1) newDateTime: # (bool) по умолчанию false diff --git a/database/ru/core.texy b/database/ru/core.texy index 50d46cab53..53b198198f 100644 --- a/database/ru/core.texy +++ b/database/ru/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Как видите, метод `transaction()` возвращает возвращаемое значение обратного вызова. Транзакция() также может быть вложенной, что упрощает реализацию независимых хранилищ. + + +Отражение .[#toc-reflection] +============================ + +Nette Database предоставляет инструменты для изучения структуры базы данных с помощью класса [api:Nette\Database\Reflection]. Этот класс позволяет получать информацию о таблицах, столбцах, индексах и внешних ключах. Вы можете использовать отражение для генерации схем, создания гибких приложений, работающих с базами данных, или создания общих инструментов для работы с базами данных. + +Объект отражения можно получить из экземпляра соединения с базой данных: + +```php +$reflection = $database->getReflection(); +``` + + +Работа с таблицами .[#toc-working-with-tables] +---------------------------------------------- + +Используя отражение, вы можете выполнить итерацию по всем таблицам в базе данных: + +```php +// Список имен всех таблиц +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Проверить, существует ли таблица +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Получить определенную таблицу +$table = $reflection->getTable('users'); +``` + + +Информация о колоннах .[#toc-column-information] +------------------------------------------------ + +Для каждой таблицы можно получить подробную информацию о ее столбцах: + +```php +// Итерация по всем столбцам +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Получение определенного столбца +$idColumn = $table->getColumn('id'); +``` + + +Индексы и первичные ключи .[#toc-indexes-and-primary-keys] +---------------------------------------------------------- + +Отражение предоставляет информацию об индексах и первичных ключах: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Список всех индексов +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Получение первичного ключа +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Иностранные ключи .[#toc-foreign-keys] +-------------------------------------- + +Вы также можете получить информацию о внешних ключах: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/sl/configuration.texy b/database/sl/configuration.texy index ab22611a5f..8d17819357 100644 --- a/database/sl/configuration.texy +++ b/database/sl/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (niz) # samo MySQL: nastavi SET NAMES - charset: # (niz) privzeta vrednost je 'utf8mb4' ('utf8' pred v5.5.3) + charset: # (niz) privzeta vrednost je 'utf8mb4' # samo MySQL: pretvori TINYINT(1) v bool - supportBooleans: # (bool) privzeto false + convertBoolean: # (bool) privzeto false # vrne stolpce datumov kot nespremenljive predmete (od različice 3.2.1) newDateTime: # (bool) privzeto false diff --git a/database/sl/core.texy b/database/sl/core.texy index 1f65ebf455..300d2fe391 100644 --- a/database/sl/core.texy +++ b/database/sl/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Kot lahko vidite, metoda `transaction()` vrne povratno vrednost povratnega klica. Metoda transaction() je lahko tudi vgnezdena, kar poenostavi izvajanje neodvisnih skladišč. + + +Razmislek .[#toc-reflection] +============================ + +Podatkovna baza Nette zagotavlja orodja za introspekcijo strukture podatkovne baze prek razreda [api:Nette\Database\Reflection]. Ta razred omogoča pridobivanje informacij o tabelah, stolpcih, indeksih in tujih ključih. Refleksijo lahko uporabite za izdelavo shem, ustvarjanje prilagodljivih aplikacij, ki delajo s podatkovnimi zbirkami, ali za izdelavo splošnih orodij za podatkovne zbirke. + +Objekt refleksije lahko pridobite iz primerka povezave s podatkovno bazo: + +```php +$reflection = $database->getReflection(); +``` + + +Delo s tabelami .[#toc-working-with-tables] +------------------------------------------- + +Z uporabo refleksije lahko iterirate po vseh tabelah v zbirki podatkov: + +```php +// Seznam imen vseh tabel +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Preverite, ali tabela obstaja +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// iskanje določene tabele +$table = $reflection->getTable('users'); +``` + + +Informacije o stolpcih .[#toc-column-information] +------------------------------------------------- + +Za vsako tabelo lahko dobite podrobne informacije o njenih stolpcih: + +```php +// Iterirajte po vseh stolpcih +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Pridobite določen stolpec +$idColumn = $table->getColumn('id'); +``` + + +Indeksi in primarni ključi .[#toc-indexes-and-primary-keys] +----------------------------------------------------------- + +Odsev zagotavlja informacije o indeksih in primarnih ključih: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Seznam vseh indeksov +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Pridobite primarni ključ +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Tuji ključi .[#toc-foreign-keys] +-------------------------------- + +Pridobite lahko tudi informacije o tujih ključih: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/tr/configuration.texy b/database/tr/configuration.texy index 055619a838..ccfb815289 100644 --- a/database/tr/configuration.texy +++ b/database/tr/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # sadece MySQL: SET NAMES setleri - charset: # (string) varsayılan olarak 'utf8mb4' ('utf8' v5.5.3'ten önce) + charset: # (string) varsayılan olarak 'utf8mb4' # sadece MySQL: TINYINT(1)'i bool'a dönüştürür - supportBooleans: # (bool) varsayılan değer false + convertBoolean: # (bool) varsayılan değer false # tarih sütunlarını değişmez nesneler olarak döndürür (3.2.1 sürümünden beri) newDateTime: # (bool) varsayılan değer false diff --git a/database/tr/core.texy b/database/tr/core.texy index 5532d29906..5ebcb92626 100644 --- a/database/tr/core.texy +++ b/database/tr/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Gördüğünüz gibi, `transaction()` yöntemi geri aramanın dönüş değerini döndürür. transaction() da iç içe geçebilir, bu da bağımsız depoların uygulanmasını basitleştirir. + + +Yansıma .[#toc-reflection] +========================== + +Nette Database, [api:Nette\Database\Reflection] sınıfı aracılığıyla veritabanı yapısını incelemek için araçlar sağlar. Bu sınıf tablolar, sütunlar, dizinler ve yabancı anahtarlar hakkında bilgi almanızı sağlar. Yansımayı şemalar oluşturmak, veritabanlarıyla çalışan esnek uygulamalar oluşturmak veya genel veritabanı araçları oluşturmak için kullanabilirsiniz. + +Bir veritabanı bağlantı örneğinden bir yansıma nesnesi elde edebilirsiniz: + +```php +$reflection = $database->getReflection(); +``` + + +Tablolarla Çalışma .[#toc-working-with-tables] +---------------------------------------------- + +Yansımayı kullanarak, veritabanındaki tüm tablolar üzerinde yineleme yapabilirsiniz: + +```php +// Tüm tabloların adlarını listeleyin +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Bir tablonun var olup olmadığını kontrol edin +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Belirli bir tabloyu alma +$table = $reflection->getTable('users'); +``` + + +Kolon Bilgileri .[#toc-column-information] +------------------------------------------ + +Her tablo için sütunları hakkında ayrıntılı bilgi alabilirsiniz: + +```php +// Tüm sütunlar üzerinde yinele +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Belirli bir sütunu alma +$idColumn = $table->getColumn('id'); +``` + + +Dizinler ve Birincil Anahtarlar .[#toc-indexes-and-primary-keys] +---------------------------------------------------------------- + +Reflection, dizinler ve birincil anahtarlar hakkında bilgi sağlar: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Tüm dizinleri listele +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Birincil anahtarı al +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Yabancı Anahtarlar .[#toc-foreign-keys] +--------------------------------------- + +Yabancı anahtarlar hakkında da bilgi alabilirsiniz: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` diff --git a/database/uk/configuration.texy b/database/uk/configuration.texy index 96d8d649db..833988c987 100644 --- a/database/uk/configuration.texy +++ b/database/uk/configuration.texy @@ -49,10 +49,10 @@ database: sqlmode: # (string) # тільки для MySQL: встановлює SET NAMES - charset: # (string) за замовчуванням 'utf8mb4' ('utf8' до v5.5.3) + charset: # (string) за замовчуванням 'utf8mb4' # тільки MySQL: перетворює TINYINT(1) в bool - supportBooleans: # (bool) за замовчуванням дорівнює false + convertBoolean: # (bool) за замовчуванням дорівнює false # повертає стовпці дати як незмінні об'єкти (починаючи з версії 3.2.1) newDateTime: # (bool) за замовчуванням дорівнює false diff --git a/database/uk/core.texy b/database/uk/core.texy index fb2022e9f7..f0e898c5c5 100644 --- a/database/uk/core.texy +++ b/database/uk/core.texy @@ -348,3 +348,95 @@ $id = $database->transaction(function ($database) { Як бачите, метод `transaction()` повертає значення зворотного виклику, що повертається. Транзакція() також може бути вкладеною, що спрощує реалізацію незалежних сховищ. + + +Рефлексія .[#toc-reflection] +============================ + +Nette Database надає інструменти для самоаналізу структури бази даних за допомогою класу [api:Nette\Database\Reflection]. Цей клас дозволяє отримувати інформацію про таблиці, стовпці, індекси та зовнішні ключі. Ви можете використовувати рефлексію для генерації схем, створення гнучких додатків, які працюють з базами даних, або створення загальних інструментів для роботи з базами даних. + +Ви можете отримати об'єкт рефлексії з екземпляра підключення до бази даних: + +```php +$reflection = $database->getReflection(); +``` + + +Робота з таблицями .[#toc-working-with-tables] +---------------------------------------------- + +Використовуючи рефлексію, ви можете ітераційно переглядати всі таблиці в базі даних: + +```php +// Перерахувати назви всіх таблиць +foreach ($reflection->tables as $tableName => $table) { + echo $tableName . "\n"; +} + +// Перевірити, чи існує таблиця +if ($reflection->hasTable('users')) { + echo "The 'users' table exists"; +} + +// Отримати конкретну таблицю +$table = $reflection->getTable('users'); +``` + + +Інформація про колонку .[#toc-column-information] +------------------------------------------------- + +Для кожної таблиці ви можете отримати детальну інформацію про її стовпці: + +```php +// Ітерація по всіх стовпцях +foreach ($table->columns as $column) { + echo "Column: " . $column->name . "\n"; + echo "Type: " . $column->nativeType . "\n"; + echo "Nullable: " . ($column->nullable ? 'Yes': 'No') . "\n"; + echo "Default value: " . ($column->default ?? 'None') . "\n"; + echo "Primary key: " . ($column->primary ? 'Yes': 'No') . "\n"; + echo "Auto-increment: " . ($column->autoIncrement ? 'Yes': 'No') . "\n"; +} + +// Отримати певний стовпець +$idColumn = $table->getColumn('id'); +``` + + +Індекси та первинні ключі .[#toc-indexes-and-primary-keys] +---------------------------------------------------------- + +Reflection надає інформацію про індекси та первинні ключі: + +```php +$listColumnNames = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns)); + +// Перерахувати всі індекси +foreach ($table->indexes as $index) { + echo "Index: " . ($index->name ?? 'Unnamed') . "\n"; + echo "Columns: " . $listColumnNames($index->columns) . "\n"; + echo "Unique: " . ($index->unique ? 'Yes': 'No') . "\n"; + echo "Primary key: " . ($index->primary ? 'Yes': 'No') . "\n"; +} + +// Отримати первинний ключ +if ($table->primaryKey) { + echo "Primary key: " . $listColumnNames($table->primaryKey->columns) . "\n"; +} +``` + + +Зовнішні ключі .[#toc-foreign-keys] +----------------------------------- + +Ви також можете отримати інформацію про зовнішні ключі: + +```php +foreach ($table->foreignKeys as $fk) { + echo "Foreign key: " . ($fk->name ?? 'Unnamed') . "\n"; + echo "Local columns: " . $listColumnNames($fk->localColumns) . "\n"; + echo "References table: {$fk->foreignTable->name}\n"; + echo "References columns: " . $listColumnNames($fk->foreignColumns) . "\n"; +} +``` From ea66fe8c24b193a820811badb8433c8470cfe5ec Mon Sep 17 00:00:00 2001 From: David Grudl Date: Wed, 4 Sep 2024 23:29:20 +0200 Subject: [PATCH 03/23] typo --- dependency-injection/bg/extensions.texy | 2 +- dependency-injection/de/extensions.texy | 2 +- dependency-injection/el/extensions.texy | 2 +- dependency-injection/en/extensions.texy | 2 +- dependency-injection/es/extensions.texy | 2 +- dependency-injection/fr/extensions.texy | 2 +- dependency-injection/hu/extensions.texy | 2 +- dependency-injection/it/extensions.texy | 2 +- dependency-injection/ja/extensions.texy | 2 +- dependency-injection/pl/extensions.texy | 2 +- dependency-injection/pt/extensions.texy | 2 +- dependency-injection/ro/extensions.texy | 2 +- dependency-injection/ru/extensions.texy | 2 +- dependency-injection/sl/extensions.texy | 2 +- dependency-injection/tr/extensions.texy | 2 +- dependency-injection/uk/extensions.texy | 2 +- forms/bg/validation.texy | 4 ++-- forms/de/validation.texy | 4 ++-- forms/el/validation.texy | 4 ++-- forms/es/validation.texy | 4 ++-- forms/fr/validation.texy | 4 ++-- forms/hu/validation.texy | 4 ++-- forms/it/validation.texy | 4 ++-- forms/pl/validation.texy | 4 ++-- forms/pt/validation.texy | 4 ++-- forms/ro/validation.texy | 4 ++-- forms/ru/validation.texy | 4 ++-- forms/sl/validation.texy | 4 ++-- forms/tr/validation.texy | 4 ++-- forms/uk/validation.texy | 4 ++-- latte/ja/develop.texy | 3 ++- php-generator/bg/@home.texy | 10 +++++----- php-generator/cs/@home.texy | 4 ++-- php-generator/de/@home.texy | 10 +++++----- php-generator/el/@home.texy | 10 +++++----- php-generator/en/@home.texy | 4 ++-- php-generator/es/@home.texy | 10 +++++----- php-generator/fr/@home.texy | 10 +++++----- php-generator/hu/@home.texy | 10 +++++----- php-generator/it/@home.texy | 10 +++++----- php-generator/ja/@home.texy | 10 +++++----- php-generator/pl/@home.texy | 10 +++++----- php-generator/pt/@home.texy | 10 +++++----- php-generator/ro/@home.texy | 10 +++++----- php-generator/ru/@home.texy | 10 +++++----- php-generator/sl/@home.texy | 10 +++++----- php-generator/tr/@home.texy | 10 +++++----- php-generator/uk/@home.texy | 10 +++++----- 48 files changed, 125 insertions(+), 124 deletions(-) diff --git a/dependency-injection/bg/extensions.texy b/dependency-injection/bg/extensions.texy index ce13c90c1b..9e1a004644 100644 --- a/dependency-injection/bg/extensions.texy +++ b/dependency-injection/bg/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $инициализация .[wiki-method] ============================= -Конфигураторът се извиква от кода за инициализация след [създаването на контейнер |application:bootstrap#index-php], който се създава чрез запис в обекта `$this->initialization` с помощта на [метода addBody() |php-generator:#method-and-function-body]. +Конфигураторът се извиква от кода за инициализация след [създаването на контейнер |application:bootstrap#index-php], който се създава чрез запис в обекта `$this->initialization` с помощта на [метода addBody() |php-generator:#method-and-function-bodies]. Ще покажем пример за това как да стартирате сесия или услуги, които имат таг `run`, като използвате кода за инициализация: diff --git a/dependency-injection/de/extensions.texy b/dependency-injection/de/extensions.texy index 9761299aa9..1652d8881c 100644 --- a/dependency-injection/de/extensions.texy +++ b/dependency-injection/de/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $Initialisierung .[wiki-method] =============================== -Der Configurator ruft den Initialisierungscode nach der [Erstellung des Containers |application:bootstrap#index.php] auf, der durch Schreiben in ein Objekt `$this->initialization` mit der [Methode addBody() |php-generator:#method-and-function-body] erzeugt wird. +Der Configurator ruft den Initialisierungscode nach der [Erstellung des Containers |application:bootstrap#index.php] auf, der durch Schreiben in ein Objekt `$this->initialization` mit der [Methode addBody() |php-generator:#method-and-function-bodies] erzeugt wird. Wir werden ein Beispiel zeigen, wie man eine Session oder Dienste mit dem Tag `run` unter Verwendung des Initialisierungscodes startet: diff --git a/dependency-injection/el/extensions.texy b/dependency-injection/el/extensions.texy index 969759ea52..ac8a328055 100644 --- a/dependency-injection/el/extensions.texy +++ b/dependency-injection/el/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -Ο διαμορφωτής καλεί τον κώδικα αρχικοποίησης μετά τη [δημιουργία του περιέκτη |application:bootstrap#index.php], ο οποίος δημιουργείται με εγγραφή σε ένα αντικείμενο `$this->initialization` χρησιμοποιώντας τη [μέθοδο addBody() |php-generator:#method-and-function-body]. +Ο διαμορφωτής καλεί τον κώδικα αρχικοποίησης μετά τη [δημιουργία του περιέκτη |application:bootstrap#index.php], ο οποίος δημιουργείται με εγγραφή σε ένα αντικείμενο `$this->initialization` χρησιμοποιώντας τη [μέθοδο addBody() |php-generator:#method-and-function-bodies]. Θα δείξουμε ένα παράδειγμα για το πώς να ξεκινήσετε μια συνεδρία ή να ξεκινήσετε υπηρεσίες που έχουν την ετικέτα `run` χρησιμοποιώντας κώδικα αρχικοποίησης: diff --git a/dependency-injection/en/extensions.texy b/dependency-injection/en/extensions.texy index 4e016ce8b7..7180a78b89 100644 --- a/dependency-injection/en/extensions.texy +++ b/dependency-injection/en/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -The Configurator calls the initialization code after [container creation |application:bootstrap#index.php], which is created by writing to an object `$this->initialization` using [method addBody() |php-generator:#method-and-function-body]. +The Configurator calls the initialization code after [container creation |application:bootstrap#index.php], which is created by writing to an object `$this->initialization` using [method addBody() |php-generator:#method-and-function-bodies]. We will show an example of how to start a session or start services that have the `run` tag using initialization code: diff --git a/dependency-injection/es/extensions.texy b/dependency-injection/es/extensions.texy index 4d1deedefd..5aea07c4aa 100644 --- a/dependency-injection/es/extensions.texy +++ b/dependency-injection/es/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -El Configurador llama al código de inicialización después de [container creation |application:bootstrap#index.php], que se crea escribiendo en un objeto `$this->initialization` usando [method addBody() |php-generator:#method-and-function-body]. +El Configurador llama al código de inicialización después de [container creation |application:bootstrap#index.php], que se crea escribiendo en un objeto `$this->initialization` usando [method addBody() |php-generator:#method-and-function-bodies]. Vamos a mostrar un ejemplo de cómo iniciar una sesión o iniciar servicios que tienen la etiqueta `run` usando código de inicialización: diff --git a/dependency-injection/fr/extensions.texy b/dependency-injection/fr/extensions.texy index e54b2acff0..a8e8b5bb93 100644 --- a/dependency-injection/fr/extensions.texy +++ b/dependency-injection/fr/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialisation .[wiki-method] ============================== -Le configurateur appelle le code d'initialisation après la [création du conteneur |application:bootstrap#index.php], qui est créé en écrivant dans un objet `$this->initialization` à l'aide de la [méthode addBody() |php-generator:#method-and-function-body]. +Le configurateur appelle le code d'initialisation après la [création du conteneur |application:bootstrap#index.php], qui est créé en écrivant dans un objet `$this->initialization` à l'aide de la [méthode addBody() |php-generator:#method-and-function-bodies]. Nous allons montrer un exemple de la façon de démarrer une session ou de lancer des services qui ont la balise `run` en utilisant le code d'initialisation : diff --git a/dependency-injection/hu/extensions.texy b/dependency-injection/hu/extensions.texy index 1064295fba..d46f379952 100644 --- a/dependency-injection/hu/extensions.texy +++ b/dependency-injection/hu/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $inicializálás .[wiki-method] ============================= -A konfigurátor a [konténer létrehozása |application:bootstrap#index.php] után hívja meg az inicializálási kódot, amely a `$this->initialization` objektumba való írással jön létre az [addBody() metódus |php-generator:#method-and-function-body] segítségével. +A konfigurátor a [konténer létrehozása |application:bootstrap#index.php] után hívja meg az inicializálási kódot, amely a `$this->initialization` objektumba való írással jön létre az [addBody() metódus |php-generator:#method-and-function-bodies] segítségével. Mutatunk egy példát arra, hogyan indíthatunk el egy munkamenetet vagy indíthatunk el szolgáltatásokat, amelyek a `run` címkével rendelkeznek az inicializálási kód segítségével: diff --git a/dependency-injection/it/extensions.texy b/dependency-injection/it/extensions.texy index 380674ded4..e408550d46 100644 --- a/dependency-injection/it/extensions.texy +++ b/dependency-injection/it/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $inizializzazione .[wiki-method] ================================ -Il Configuratore chiama il codice di inizializzazione dopo la [creazione del contenitore |application:bootstrap#index.php], che viene creato scrivendo su un oggetto `$this->initialization` con il [metodo addBody() |php-generator:#method-and-function-body]. +Il Configuratore chiama il codice di inizializzazione dopo la [creazione del contenitore |application:bootstrap#index.php], che viene creato scrivendo su un oggetto `$this->initialization` con il [metodo addBody() |php-generator:#method-and-function-bodies]. Verrà mostrato un esempio di come avviare una sessione o servizi che hanno il tag `run` usando il codice di inizializzazione: diff --git a/dependency-injection/ja/extensions.texy b/dependency-injection/ja/extensions.texy index beccfd35c0..4c41625fb1 100644 --- a/dependency-injection/ja/extensions.texy +++ b/dependency-injection/ja/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -Configurator は、[コンテナ作成 |application:en:bootstrap#index.php]後に初期化コードを呼び出します。このコードは、[メソッド addBody() |php-generator:#method-and-function-body] を使用してオブジェクト`$this->initialization` に書き込むことで作成されます。 +Configurator は、[コンテナ作成 |application:en:bootstrap#index.php]後に初期化コードを呼び出します。このコードは、[メソッド addBody() |php-generator:#method-and-function-bodies] を使用してオブジェクト`$this->initialization` に書き込むことで作成されます。 ここでは、初期化コードを用いて、セッションの開始や、`run` タグを持つサービスの開始を行う例を示します。 diff --git a/dependency-injection/pl/extensions.texy b/dependency-injection/pl/extensions.texy index 4f1d5723c1..0e1d1e1128 100644 --- a/dependency-injection/pl/extensions.texy +++ b/dependency-injection/pl/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $inicjalizacja .[wiki-method][#toc-initialization] ================================================== -Po [utworzeniu kontenera |application:bootstrap#index-php] klasa Configurator wywołuje kod inicjalizacyjny, który powstaje poprzez zapis do obiektu `$this->initialization` za pomocą [metody addBody() |php-generator:#Method-and-Function-Body]. +Po [utworzeniu kontenera |application:bootstrap#index-php] klasa Configurator wywołuje kod inicjalizacyjny, który powstaje poprzez zapis do obiektu `$this->initialization` za pomocą [metody addBody() |php-generator:#method-and-function-bodies]. Pokażemy przykład, jak np. kod inicjalizujący może uruchomić sesję lub uruchomić usługi, które mają znacznik `run`: diff --git a/dependency-injection/pt/extensions.texy b/dependency-injection/pt/extensions.texy index 6d38a69bf3..31f01cfc28 100644 --- a/dependency-injection/pt/extensions.texy +++ b/dependency-injection/pt/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $inicialização .[wiki-method] ============================= -O Configurador chama o código de inicialização após a [criação do recipiente |application:bootstrap#index.php], que é criado escrevendo para um objeto `$this->initialization` usando [o método addBody() |php-generator:#method-and-function-body]. +O Configurador chama o código de inicialização após a [criação do recipiente |application:bootstrap#index.php], que é criado escrevendo para um objeto `$this->initialization` usando [o método addBody() |php-generator:#method-and-function-bodies]. Mostraremos um exemplo de como iniciar uma sessão ou iniciar serviços que tenham a tag `run` usando o código de inicialização: diff --git a/dependency-injection/ro/extensions.texy b/dependency-injection/ro/extensions.texy index 39bab90248..1c3ba3ce1d 100644 --- a/dependency-injection/ro/extensions.texy +++ b/dependency-injection/ro/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initializare .[wiki-method] ============================ -Configuratorul apelează codul de inițializare după [crearea containerului |application:bootstrap#index.php], care este creat prin scrierea într-un obiect `$this->initialization` folosind [metoda addBody() |php-generator:#method-and-function-body]. +Configuratorul apelează codul de inițializare după [crearea containerului |application:bootstrap#index.php], care este creat prin scrierea într-un obiect `$this->initialization` folosind [metoda addBody() |php-generator:#method-and-function-bodies]. Vom prezenta un exemplu de pornire a unei sesiuni sau de pornire a serviciilor care au eticheta `run` folosind codul de inițializare: diff --git a/dependency-injection/ru/extensions.texy b/dependency-injection/ru/extensions.texy index fea62eaef2..dee2ae9e5d 100644 --- a/dependency-injection/ru/extensions.texy +++ b/dependency-injection/ru/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -Configurator вызывается кодом инициализации после [создания контейнера |application:bootstrap#index-php], который создается путем записи в объект `$this->initialization` с помощью [метода addBody() |php-generator:#method-and-function-body]. +Configurator вызывается кодом инициализации после [создания контейнера |application:bootstrap#index-php], который создается путем записи в объект `$this->initialization` с помощью [метода addBody() |php-generator:#method-and-function-bodies]. Мы покажем пример того, как запустить сессию или сервисы, которые имеют тег `run` с помощью кода инициализации: diff --git a/dependency-injection/sl/extensions.texy b/dependency-injection/sl/extensions.texy index 6deff98ca1..cc56617c46 100644 --- a/dependency-injection/sl/extensions.texy +++ b/dependency-injection/sl/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -Konfigurator pokliče inicializacijsko kodo po [ustvarjanju vsebnika |application:bootstrap#index.php], ki se ustvari z zapisom v objekt `$this->initialization` z [metodo addBody() |php-generator:#method-and-function-body]. +Konfigurator pokliče inicializacijsko kodo po [ustvarjanju vsebnika |application:bootstrap#index.php], ki se ustvari z zapisom v objekt `$this->initialization` z [metodo addBody() |php-generator:#method-and-function-bodies]. Prikazali bomo primer, kako z inicializacijsko kodo zaženemo sejo ali zaženemo storitve, ki imajo oznako `run`: diff --git a/dependency-injection/tr/extensions.texy b/dependency-injection/tr/extensions.texy index a3036620d4..d58ba90564 100644 --- a/dependency-injection/tr/extensions.texy +++ b/dependency-injection/tr/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $başlatma .[wiki-method] ======================== -Yapılandırıcı, [addBody() yöntemi |php-generator:#method-and-function-body] kullanılarak bir `$this->initialization` nesnesine yazılarak oluşturulan [konteyner oluşturulduktan |application:bootstrap#index.php] sonra başlatma kodunu çağırır. +Yapılandırıcı, [addBody() yöntemi |php-generator:#method-and-function-bodies] kullanılarak bir `$this->initialization` nesnesine yazılarak oluşturulan [konteyner oluşturulduktan |application:bootstrap#index.php] sonra başlatma kodunu çağırır. Bir oturumun nasıl başlatılacağına veya başlatma kodunu kullanarak `run` etiketine sahip hizmetlerin nasıl başlatılacağına dair bir örnek göstereceğiz: diff --git a/dependency-injection/uk/extensions.texy b/dependency-injection/uk/extensions.texy index eba51856f6..b865d00aa4 100644 --- a/dependency-injection/uk/extensions.texy +++ b/dependency-injection/uk/extensions.texy @@ -170,7 +170,7 @@ class BlogExtension extends Nette\DI\CompilerExtension $initialization .[wiki-method] ============================== -Configurator викликається кодом ініціалізації після [створення контейнера |application:bootstrap#index-php], який створюється шляхом запису в об'єкт `$this->initialization` за допомогою [методу addBody() |php-generator:#method-and-function-body]. +Configurator викликається кодом ініціалізації після [створення контейнера |application:bootstrap#index-php], який створюється шляхом запису в об'єкт `$this->initialization` за допомогою [методу addBody() |php-generator:#method-and-function-bodies]. Ми покажемо приклад того, як запустити сесію або сервіси, які мають тег `run` за допомогою коду ініціалізації: diff --git a/forms/bg/validation.texy b/forms/bg/validation.texy index 24c9c6f343..ba3c97bdce 100644 --- a/forms/bg/validation.texy +++ b/forms/bg/validation.texy @@ -39,8 +39,8 @@ Nette се предлага с редица предварително дефи | `Valid` | записът преминава валидиране (за [Условие |#Условия]) | - -Въвеждане на текст ------------------- +Въвеждане на текст .[#toc-text-inputs] +-------------------------------------- За елементите `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` могат да се приложат и някои от следните правила: diff --git a/forms/de/validation.texy b/forms/de/validation.texy index 19f7c7f1d2..d1a923d128 100644 --- a/forms/de/validation.texy +++ b/forms/de/validation.texy @@ -39,8 +39,8 @@ Nette verfügt über eine Reihe von vordefinierten Regeln, deren Namen Konstante | `Valid` | Eingabe besteht Validierung (für [Bedingungen |#conditions]) | - -Texteingaben ------------- +Texteingaben .[#toc-text-inputs] +-------------------------------- Für die Elemente `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` können auch einige der folgenden Regeln angewendet werden: diff --git a/forms/el/validation.texy b/forms/el/validation.texy index a8ce34ae09..68422555e5 100644 --- a/forms/el/validation.texy +++ b/forms/el/validation.texy @@ -39,8 +39,8 @@ $form->addPassword('password', 'Password:') | `Valid` | η είσοδος περνάει την επικύρωση (για τις [συνθήκες |#conditions]) | - -Είσοδοι κειμένου ----------------- +Είσοδοι κειμένου .[#toc-text-inputs] +------------------------------------ Για τα στοιχεία `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` μπορούν επίσης να εφαρμοστούν ορισμένοι από τους ακόλουθους κανόνες: diff --git a/forms/es/validation.texy b/forms/es/validation.texy index 43d2bea472..3a07b00586 100644 --- a/forms/es/validation.texy +++ b/forms/es/validation.texy @@ -39,8 +39,8 @@ Nette viene con una serie de reglas predefinidas cuyos nombres son constantes de | `Valid` | la entrada pasa la validación (para [condiciones |#conditions]) | - -Entradas de texto ------------------ +Entradas de texto .[#toc-text-inputs] +------------------------------------- Para los elementos `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` también se pueden aplicar algunas de las siguientes reglas: diff --git a/forms/fr/validation.texy b/forms/fr/validation.texy index 6066a17c4a..4d750f7048 100644 --- a/forms/fr/validation.texy +++ b/forms/fr/validation.texy @@ -39,8 +39,8 @@ Nette est livré avec un certain nombre de règles prédéfinies dont les noms s | `Valid` | L'entrée passe la validation (pour les [conditions |#conditions]) | - -Entrées de texte ----------------- +Entrées de texte .[#toc-text-inputs] +------------------------------------ Pour les éléments `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()`, certaines des règles suivantes peuvent également être appliquées : diff --git a/forms/hu/validation.texy b/forms/hu/validation.texy index c7823a0d1d..3e70858bf0 100644 --- a/forms/hu/validation.texy +++ b/forms/hu/validation.texy @@ -39,8 +39,8 @@ A Nette számos előre definiált szabályt tartalmaz, amelyek neve a `Nette\For | `Valid` | a bemenet átmegy az érvényesítésen ( [feltételek |#conditions] esetén) | - -Szöveges bemenetek ------------------- +Szöveges bemenetek .[#toc-text-inputs] +-------------------------------------- A `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` elemekre a következő szabályok közül néhányat is lehet alkalmazni: diff --git a/forms/it/validation.texy b/forms/it/validation.texy index 6eefbe5208..b4f71f97c5 100644 --- a/forms/it/validation.texy +++ b/forms/it/validation.texy @@ -39,8 +39,8 @@ Nette dispone di una serie di regole predefinite i cui nomi sono costanti della | `Valid` | l'input supera la convalida (per le [condizioni |#conditions]) | - -Ingressi di testo ------------------ +Ingressi di testo .[#toc-text-inputs] +------------------------------------- Per gli elementi `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` si possono applicare anche alcune delle seguenti regole: diff --git a/forms/pl/validation.texy b/forms/pl/validation.texy index 7e3c5479f9..743ac60ead 100644 --- a/forms/pl/validation.texy +++ b/forms/pl/validation.texy @@ -39,8 +39,8 @@ Nette posiada szereg predefiniowanych reguł, których nazwy są stałymi klasy | `Valid` | czy element został wypełniony poprawnie? (dla [warunków |#Conditions]) | - -Wejścia tekstowe ----------------- +Wejścia tekstowe .[#toc-text-inputs] +------------------------------------ W przypadku elementów `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` można również zastosować niektóre z poniższych reguł: diff --git a/forms/pt/validation.texy b/forms/pt/validation.texy index f8e2442bc2..803e9b2a38 100644 --- a/forms/pt/validation.texy +++ b/forms/pt/validation.texy @@ -39,8 +39,8 @@ O Nette vem com várias regras predefinidas cujos nomes são constantes da class | `Valid` | validação dos passes de entrada (para [condições |#conditions]) | - -Entradas de texto ------------------ +Entradas de texto .[#toc-text-inputs] +------------------------------------- Para os elementos `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()`, algumas das regras a seguir também podem ser aplicadas: diff --git a/forms/ro/validation.texy b/forms/ro/validation.texy index 06f5ed2c88..4ea0350077 100644 --- a/forms/ro/validation.texy +++ b/forms/ro/validation.texy @@ -39,8 +39,8 @@ Nette vine cu un număr de reguli predefinite ale căror nume sunt constante din | `Valid` | input passes validation (for [conditions |#conditions]) | - -Intrări de text ---------------- +Intrări de text .[#toc-text-inputs] +----------------------------------- Pentru elementele `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` se pot aplica, de asemenea, unele dintre următoarele reguli: diff --git a/forms/ru/validation.texy b/forms/ru/validation.texy index 5a42aab855..a48bb25189 100644 --- a/forms/ru/validation.texy +++ b/forms/ru/validation.texy @@ -39,8 +39,8 @@ Nette поставляется с рядом предопределенных п | `Valid` | ввод проходит валидацию (для [#Условия]) | - -Текстовые вводы ---------------- +Текстовые вводы .[#toc-text-inputs] +----------------------------------- Для элементов `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` также могут быть применены некоторые из следующих правил: diff --git a/forms/sl/validation.texy b/forms/sl/validation.texy index 2ee6d3b803..ee2fdd7143 100644 --- a/forms/sl/validation.texy +++ b/forms/sl/validation.texy @@ -39,8 +39,8 @@ Nette ima na voljo številna vnaprej določena pravila, katerih imena so konstan | `Valid` | vhodni podatki so uspešno preverjeni (za [pogoje |#conditions]) | - -Besedilni vnosi ---------------- +Besedilni vnosi .[#toc-text-inputs] +----------------------------------- Za elemente `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` se lahko uporabijo tudi nekatera od naslednjih pravil: diff --git a/forms/tr/validation.texy b/forms/tr/validation.texy index 9b99cfc658..5c1e590924 100644 --- a/forms/tr/validation.texy +++ b/forms/tr/validation.texy @@ -39,8 +39,8 @@ Nette, isimleri `Nette\Forms\Form` sınıfının sabitleri olan bir dizi öncede | `Valid` | girdi doğrulamayı geçer ( [koşullar |#conditions] için) | - -Metin girişleri ---------------- +Metin girişleri .[#toc-text-inputs] +----------------------------------- `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` öğeleri için aşağıdaki kurallardan bazıları da uygulanabilir: diff --git a/forms/uk/validation.texy b/forms/uk/validation.texy index 9cde855621..f86c24d604 100644 --- a/forms/uk/validation.texy +++ b/forms/uk/validation.texy @@ -39,8 +39,8 @@ Nette постачається з низкою попередньо визнач | `Valid` | введення проходить валідацію (для [Умови |#Условия])| - -Текстові дані -------------- +Текстові дані .[#toc-text-inputs] +--------------------------------- Для елементів `addText()`, `addPassword()`, `addTextArea()`, `addEmail()`, `addInteger()`, `addFloat()` також можна застосувати деякі з наступних правил: diff --git a/latte/ja/develop.texy b/latte/ja/develop.texy index 4bcca138fe..27fab15e1c 100644 --- a/latte/ja/develop.texy +++ b/latte/ja/develop.texy @@ -163,7 +163,8 @@ try { // PHPのラテ・エラーとコンパイル・エラーをキャッチする echo 'Error: ' . $e->getMessage(); -}``` +} +``` ロケール .[#toc-locale]{data-version:3.0.18} diff --git a/php-generator/bg/@home.texy b/php-generator/bg/@home.texy index 84b1dd3580..6268197c19 100644 --- a/php-generator/bg/@home.texy +++ b/php-generator/bg/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -За да дефинирате т.нар. вариационни параметри (а също и оператора splat, spread, ellipsis, unpacking или three dots), използвайте `setVariadics()`: +За да дефинирате т.нар. вариационни параметри (а също и оператора splat, spread, ellipsis, unpacking или three dots), използвайте `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Метод и тяло на функцията .[#toc-method-and-function-body] ----------------------------------------------------------- +Метод и тяло на функцията .[#toc-method-and-function-bodies] +------------------------------------------------------------ Тялото може да се предаде на метода `setBody()` наведнъж или последователно (ред по ред) чрез многократно извикване на `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Можете също така да подавате параметри на `Literal` и да ги форматирате във валиден PHP код, като използвате [специални заместители |#method-and-function-body-generator]: +Можете също така да подавате параметри на `Literal` и да ги форматирате във валиден PHP код, като използвате [специални заместители |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/cs/@home.texy b/php-generator/cs/@home.texy index abbc84d111..4e43708598 100644 --- a/php-generator/cs/@home.texy +++ b/php-generator/cs/@home.texy @@ -362,7 +362,7 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Pro definici tzv. variadics parametrů (nebo též splat operátor) slouží `setVariadics()`: +Pro definici tzv. variadics parametrů (nebo též splat operátor) slouží `setVariadic()`: ```php $method = $class->addMethod('count'); @@ -573,7 +573,7 @@ class Demo } ``` -Můžete také předat parametry do `Literal` a nechat je zformátovat do platného kódu PHP pomocí [zástupných znaků|#Generování těl metod a funkcí]: +Můžete také předat parametry do `Literal` a nechat je zformátovat do platného kódu PHP pomocí [zástupných znaků|#tela-metod-a-funkci]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/de/@home.texy b/php-generator/de/@home.texy index 8ee6152a76..b702ccfa1f 100644 --- a/php-generator/de/@home.texy +++ b/php-generator/de/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Um die sogenannten Variadics-Parameter (oder auch den Splat-, Spread-, Ellipsis-, Unpacking- oder Three Dots-Operator) zu definieren, verwenden Sie `setVariadics()`: +Um die sogenannten Variadics-Parameter (oder auch den Splat-, Spread-, Ellipsis-, Unpacking- oder Three Dots-Operator) zu definieren, verwenden Sie `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Methode und Funktionskörper .[#toc-method-and-function-body] ------------------------------------------------------------- +Methode und Funktionskörper .[#toc-method-and-function-bodies] +-------------------------------------------------------------- Der Körper kann der Methode `setBody()` auf einmal oder sequentiell (Zeile für Zeile) durch wiederholten Aufruf von `addBody()` übergeben werden: @@ -573,7 +573,7 @@ class Demo } ``` -Sie können auch Parameter an `Literal` übergeben und diese mit Hilfe [spezieller Platzhalter |#method-and-function-body-generator] in gültigen PHP-Code umwandeln lassen: +Sie können auch Parameter an `Literal` übergeben und diese mit Hilfe [spezieller Platzhalter |#method-and-function-bodies] in gültigen PHP-Code umwandeln lassen: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/el/@home.texy b/php-generator/el/@home.texy index adc47e3fbb..93a82e630c 100644 --- a/php-generator/el/@home.texy +++ b/php-generator/el/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Για να ορίσετε τις λεγόμενες παραμέτρους variadics (ή επίσης τον τελεστή splat, spread, ellipsis, unpacking ή three dots), χρησιμοποιήστε `setVariadics()`: +Για να ορίσετε τις λεγόμενες παραμέτρους variadics (ή επίσης τον τελεστή splat, spread, ellipsis, unpacking ή three dots), χρησιμοποιήστε `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Σώμα μεθόδου και συνάρτησης .[#toc-method-and-function-body] ------------------------------------------------------------- +Σώμα μεθόδου και συνάρτησης .[#toc-method-and-function-bodies] +-------------------------------------------------------------- Το σώμα μπορεί να περάσει στη μέθοδο `setBody()` αμέσως ή διαδοχικά (γραμμή προς γραμμή) καλώντας επανειλημμένα τη μέθοδο `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Μπορείτε επίσης να περάσετε παραμέτρους στη διεύθυνση `Literal` και να τις μορφοποιήσετε σε έγκυρο κώδικα PHP χρησιμοποιώντας [ειδικούς συμπαραστάτες |#method-and-function-body-generator]: +Μπορείτε επίσης να περάσετε παραμέτρους στη διεύθυνση `Literal` και να τις μορφοποιήσετε σε έγκυρο κώδικα PHP χρησιμοποιώντας [ειδικούς συμπαραστάτες |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/en/@home.texy b/php-generator/en/@home.texy index 20de526afb..b0be959343 100644 --- a/php-generator/en/@home.texy +++ b/php-generator/en/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -To define the so-called variadics parameters (or also the splat, spread, ellipsis, unpacking or three dots operator), use `setVariadics()`: +To define the so-called variadics parameters (or also the splat, spread, ellipsis, unpacking or three dots operator), use `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` diff --git a/php-generator/es/@home.texy b/php-generator/es/@home.texy index fe4d193d12..c53c512da6 100644 --- a/php-generator/es/@home.texy +++ b/php-generator/es/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Para definir los llamados parámetros variádicos (o también el operador splat, spread, ellipsis, unpacking o tres puntos), utilice `setVariadics()`: +Para definir los llamados parámetros variádicos (o también el operador splat, spread, ellipsis, unpacking o tres puntos), utilice `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Método y cuerpo de la función .[#toc-method-and-function-body] --------------------------------------------------------------- +Método y cuerpo de la función .[#toc-method-and-function-bodies] +---------------------------------------------------------------- El cuerpo puede pasarse al método `setBody()` de una vez o secuencialmente (línea por línea) llamando repetidamente a `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -También puede pasar parámetros a `Literal` y hacer que se formatee en código PHP válido utilizando [marcadores de posición especiales |#method-and-function-body-generator]: +También puede pasar parámetros a `Literal` y hacer que se formatee en código PHP válido utilizando [marcadores de posición especiales |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/fr/@home.texy b/php-generator/fr/@home.texy index 2df1b8f742..22ee5e3b0d 100644 --- a/php-generator/fr/@home.texy +++ b/php-generator/fr/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Pour définir les paramètres dits variadiques (ou également l'opérateur splat, spread, ellipsis, unpacking ou trois points), utilisez `setVariadics()`: +Pour définir les paramètres dits variadiques (ou également l'opérateur splat, spread, ellipsis, unpacking ou trois points), utilisez `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Méthode et corps de fonction .[#toc-method-and-function-body] -------------------------------------------------------------- +Méthode et corps de fonction .[#toc-method-and-function-bodies] +--------------------------------------------------------------- Le corps peut être transmis à la méthode `setBody()` en une seule fois ou de manière séquentielle (ligne par ligne) en appelant à plusieurs reprises `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Vous pouvez également passer des paramètres à `Literal` et les faire formater en code PHP valide à l'aide de [caractères de remplacement spéciaux |#method-and-function-body-generator]: +Vous pouvez également passer des paramètres à `Literal` et les faire formater en code PHP valide à l'aide de [caractères de remplacement spéciaux |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/hu/@home.texy b/php-generator/hu/@home.texy index 64d67f47c9..d5175f7292 100644 --- a/php-generator/hu/@home.texy +++ b/php-generator/hu/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Az úgynevezett variadics paraméterek (vagy akár a splat, spread, ellipszis, kipakolás vagy a három pont operátor) definiálásához használja a `setVariadics()`: +Az úgynevezett variadics paraméterek (vagy akár a splat, spread, ellipszis, kipakolás vagy a három pont operátor) definiálásához használja a `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Módszer és funkciótest .[#toc-method-and-function-body] -------------------------------------------------------- +Módszer és funkciótest .[#toc-method-and-function-bodies] +--------------------------------------------------------- A test átadható a `setBody()` metódusnak egyszerre vagy szekvenciálisan (soronként) a `addBody()` ismételt hívásával: @@ -573,7 +573,7 @@ class Demo } ``` -A `Literal` oldalnak paramétereket is átadhat, és azt [speciális helyőrzőket |#method-and-function-body-generator] használva érvényes PHP-kóddá formázhatja: +A `Literal` oldalnak paramétereket is átadhat, és azt [speciális helyőrzőket |#method-and-function-bodies] használva érvényes PHP-kóddá formázhatja: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/it/@home.texy b/php-generator/it/@home.texy index 8c6834cf33..77dfc8f8a6 100644 --- a/php-generator/it/@home.texy +++ b/php-generator/it/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Per definire i cosiddetti parametri variadici (o anche gli operatori splat, spread, ellipsis, unpacking o tre punti), utilizzare `setVariadics()`: +Per definire i cosiddetti parametri variadici (o anche gli operatori splat, spread, ellipsis, unpacking o tre punti), utilizzare `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Metodo e corpo della funzione .[#toc-method-and-function-body] --------------------------------------------------------------- +Metodo e corpo della funzione .[#toc-method-and-function-bodies] +---------------------------------------------------------------- Il corpo può essere passato al metodo `setBody()` in una sola volta o in sequenza (riga per riga) chiamando ripetutamente `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -È anche possibile passare dei parametri a `Literal` e farli formattare in codice PHP valido, utilizzando [speciali segnaposto |#method-and-function-body-generator]: +È anche possibile passare dei parametri a `Literal` e farli formattare in codice PHP valido, utilizzando [speciali segnaposto |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/ja/@home.texy b/php-generator/ja/@home.texy index 44c35f1c69..0a043cd0ee 100644 --- a/php-generator/ja/@home.texy +++ b/php-generator/ja/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -いわゆる variadics パラメータ（あるいは splat, spread, ellipsis, unpacking, three dots オペレータ）を定義するには、`setVariadics()` を使用します。 +いわゆる variadics パラメータ（あるいは splat, spread, ellipsis, unpacking, three dots オペレータ）を定義するには、`setVariadic()` を使用します。 ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -メソッドと関数本体 .[#toc-method-and-function-body] ------------------------------------------- +メソッドと関数本体 .[#toc-method-and-function-bodies] +-------------------------------------------- 本体は、`setBody()` メソッドに一度に渡すこともできますし、`addBody()` を繰り返し呼び出すことで順次（一行ずつ）渡すこともできます。 @@ -573,7 +573,7 @@ class Demo } ``` -`Literal` にパラメータを渡すと、[特別なプレースホルダーを使って |#method-and-function-body-generator]有効な PHP コードにフォーマットさせることもできます。 +`Literal` にパラメータを渡すと、[特別なプレースホルダーを使って |#method-and-function-bodies]有効な PHP コードにフォーマットさせることもできます。 ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/pl/@home.texy b/php-generator/pl/@home.texy index 20dd2737c1..2ce02ec8fc 100644 --- a/php-generator/pl/@home.texy +++ b/php-generator/pl/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Aby zdefiniować tzw. parametry variadics (lub również operator splat, spread, elipsa, rozpakowywanie czy trzy kropki), należy użyć `setVariadics()`: +Aby zdefiniować tzw. parametry variadics (lub również operator splat, spread, elipsa, rozpakowywanie czy trzy kropki), należy użyć `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Metoda i ciało funkcji .[#toc-method-and-function-body] -------------------------------------------------------- +Metoda i ciało funkcji .[#toc-method-and-function-bodies] +--------------------------------------------------------- Ciało może być przekazane do metody `setBody()` jednorazowo lub sekwencyjnie (linia po linii) poprzez wielokrotne wywołanie `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Możesz również przekazać parametry do `Literal` i mieć je sformatowane w poprawny kod PHP za pomocą [specjalnych placeholderów |#method-and-function-body-generator]: +Możesz również przekazać parametry do `Literal` i mieć je sformatowane w poprawny kod PHP za pomocą [specjalnych placeholderów |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/pt/@home.texy b/php-generator/pt/@home.texy index 9cf37e054a..9826bd8f9c 100644 --- a/php-generator/pt/@home.texy +++ b/php-generator/pt/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Para definir os chamados parâmetros de variação (ou também o splat, spread, elipse, desempacotamento ou operador de três pontos), use `setVariadics()`: +Para definir os chamados parâmetros de variação (ou também o splat, spread, elipse, desempacotamento ou operador de três pontos), use `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Método e Função Corpo .[#toc-method-and-function-body] ------------------------------------------------------- +Método e Função Corpo .[#toc-method-and-function-bodies] +-------------------------------------------------------- O corpo pode ser passado para o método `setBody()` de uma vez ou sequencialmente (linha por linha), ligando repetidamente para `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Você também pode passar os parâmetros para `Literal` e formatá-lo em código PHP válido usando [marcadores de lugar especiais |#method-and-function-body-generator]: +Você também pode passar os parâmetros para `Literal` e formatá-lo em código PHP válido usando [marcadores de lugar especiais |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/ro/@home.texy b/php-generator/ro/@home.texy index 26da1299d6..654182007b 100644 --- a/php-generator/ro/@home.texy +++ b/php-generator/ro/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Pentru a defini așa-numiții parametri variadici (sau, de asemenea, operatorul splat, spread, elipsis, unpacking sau trei puncte), utilizați `setVariadics()`: +Pentru a defini așa-numiții parametri variadici (sau, de asemenea, operatorul splat, spread, elipsis, unpacking sau trei puncte), utilizați `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Metoda și corpul funcției .[#toc-method-and-function-body] ----------------------------------------------------------- +Metoda și corpul funcției .[#toc-method-and-function-bodies] +------------------------------------------------------------ Corpul poate fi transmis metodei `setBody()` o dată sau secvențial (linie cu linie) prin apelarea repetată a metodei `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Puteți, de asemenea, să transmiteți parametri la `Literal` și să formatați codul PHP valid folosind [caractere de poziție speciale |#method-and-function-body-generator]: +Puteți, de asemenea, să transmiteți parametri la `Literal` și să formatați codul PHP valid folosind [caractere de poziție speciale |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/ru/@home.texy b/php-generator/ru/@home.texy index 66bc911e8d..ca802725c6 100644 --- a/php-generator/ru/@home.texy +++ b/php-generator/ru/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Для определения так называемых вариативных параметров (а также операторов splat, spread, ellipsis, unpacking или three dots) используйте `setVariadics()`: +Для определения так называемых вариативных параметров (а также операторов splat, spread, ellipsis, unpacking или three dots) используйте `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Метод и тело функции .[#toc-method-and-function-body] ------------------------------------------------------ +Метод и тело функции .[#toc-method-and-function-bodies] +------------------------------------------------------- Содержимое функции или метода может быть передано методу `setBody()` сразу или последовательно (строка за строкой) путем многократного вызова `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Вы также можете передавать параметры в `Literal` и форматировать их в правильный PHP-код с помощью [специальных заполнителей |#method-and-function-body-generator]: +Вы также можете передавать параметры в `Literal` и форматировать их в правильный PHP-код с помощью [специальных заполнителей |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/sl/@home.texy b/php-generator/sl/@home.texy index f20bf6ed39..38295d8b38 100644 --- a/php-generator/sl/@home.texy +++ b/php-generator/sl/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Za določitev tako imenovanih parametrov variadics (ali tudi operatorjev splat, spread, elipsis, unpacking ali tri pike) uporabite `setVariadics()`: +Za določitev tako imenovanih parametrov variadics (ali tudi operatorjev splat, spread, elipsis, unpacking ali tri pike) uporabite `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Metoda in telo funkcije .[#toc-method-and-function-body] --------------------------------------------------------- +Metoda in telo funkcije .[#toc-method-and-function-bodies] +---------------------------------------------------------- Telo lahko metodi `setBody()` posredujete naenkrat ali zaporedno (vrstico za vrstico) z večkratnim klicem `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Rezultat: Na naslov `Literal` lahko posredujete tudi parametre, ki se s [posebnimi nadomestki |#method-and-function-body-generator] oblikujejo v veljavno PHP kodo: +Rezultat: Na naslov `Literal` lahko posredujete tudi parametre, ki se s [posebnimi nadomestki |#method-and-function-bodies] oblikujejo v veljavno PHP kodo: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/tr/@home.texy b/php-generator/tr/@home.texy index ca68e290fe..54d00a680c 100644 --- a/php-generator/tr/@home.texy +++ b/php-generator/tr/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Variadics parametrelerini (veya splat, spread, ellipsis, unpacking veya three dots operatörlerini) tanımlamak için `setVariadics()` adresini kullanın: +Variadics parametrelerini (veya splat, spread, ellipsis, unpacking veya three dots operatörlerini) tanımlamak için `setVariadic()` adresini kullanın: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Yöntem ve İşlev Gövde .[#toc-method-and-function-body] ------------------------------------------------------- +Yöntem ve İşlev Gövde .[#toc-method-and-function-bodies] +-------------------------------------------------------- Gövde `setBody()` yöntemine bir kerede veya `addBody()` adresini tekrar tekrar çağırarak sırayla (satır satır) aktarılabilir: @@ -573,7 +573,7 @@ class Demo } ``` -Ayrıca `Literal` adresine parametre aktarabilir ve [özel yer tutucular |#method-and-function-body-generator] kullanarak geçerli PHP kodu olarak biçimlendirilmesini sağlayabilirsiniz: +Ayrıca `Literal` adresine parametre aktarabilir ve [özel yer tutucular |#method-and-function-bodies] kullanarak geçerli PHP kodu olarak biçimlendirilmesini sağlayabilirsiniz: ```php new Literal('substr(?, ?)', [$a, $b]); diff --git a/php-generator/uk/@home.texy b/php-generator/uk/@home.texy index 2aff78d110..b9cdaf9a08 100644 --- a/php-generator/uk/@home.texy +++ b/php-generator/uk/@home.texy @@ -362,11 +362,11 @@ $method->addParameter('items', []) // $items = [] // function count(&$items = []) ``` -Для визначення так званих варіадичних параметрів (або також операторів splat, spread, еліпсис, розпакування або три крапки) використовуйте `setVariadics()`: +Для визначення так званих варіадичних параметрів (або також операторів splat, spread, еліпсис, розпакування або три крапки) використовуйте `setVariadic()`: ```php $method = $class->addMethod('count'); -$method->setVariadics(true); +$method->setVariadic(true); $method->addParameter('items'); ``` @@ -379,8 +379,8 @@ function count(...$items) ``` -Метод і тіло функції .[#toc-method-and-function-body] ------------------------------------------------------ +Метод і тіло функції .[#toc-method-and-function-bodies] +------------------------------------------------------- Тіло можна передати в метод `setBody()` одразу або послідовно (рядок за рядком) шляхом багаторазового виклику `addBody()`: @@ -573,7 +573,7 @@ class Demo } ``` -Ви також можете передати параметри на адресу `Literal` і відформатувати їх у коректний PHP-код за допомогою [спеціальних заповнювачів |#method-and-function-body-generator]: +Ви також можете передати параметри на адресу `Literal` і відформатувати їх у коректний PHP-код за допомогою [спеціальних заповнювачів |#method-and-function-bodies]: ```php new Literal('substr(?, ?)', [$a, $b]); From aeb709716f8739b7dcab9db55cdfc1f3b3017baf Mon Sep 17 00:00:00 2001 From: David Grudl Date: Tue, 10 Sep 2024 11:30:23 +0200 Subject: [PATCH 04/23] php-generator 4.1.6 --- php-generator/bg/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/cs/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/de/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/el/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/en/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/es/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/fr/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/hu/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/it/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/ja/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/pl/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/pt/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/ro/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/ru/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/sl/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/tr/@home.texy | 32 ++++++++++++++++++++++++++++++++ php-generator/uk/@home.texy | 32 ++++++++++++++++++++++++++++++++ 17 files changed, 544 insertions(+) diff --git a/php-generator/bg/@home.texy b/php-generator/bg/@home.texy index 6268197c19..80b6ed7027 100644 --- a/php-generator/bg/@home.texy +++ b/php-generator/bg/@home.texy @@ -843,6 +843,38 @@ $file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php')); Ако трябва да манипулирате глобален код във файлове или отделни оператори в тялото на метод, по-добре е да използвате директно библиотеката `nikic/php-parser`. +Манипулатор на класове .[#toc-class-manipulator] +------------------------------------------------ + +Класът [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] предоставя инструменти за манипулиране на класове. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Методът `inheritMethod()` копира метод от родителски клас или имплементиран интерфейс във вашия клас. Това ви позволява да замените метода или да разширите неговата сигнатура: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Методът `inheritProperty()` копира свойство от родителски клас във вашия клас. Това е полезно, когато искате да имате същото свойство във вашия клас, но евентуално с различна стойност по подразбиране: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Методът `implementInterface()` автоматично имплементира всички методи от дадения интерфейс във вашия клас: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Сега вашият клас имплементира SomeInterface и включва всички негови методи +``` + + Дъмпер за променливи .[#toc-variables-dumper] --------------------------------------------- diff --git a/php-generator/cs/@home.texy b/php-generator/cs/@home.texy index 4e43708598..241b06e39e 100644 --- a/php-generator/cs/@home.texy +++ b/php-generator/cs/@home.texy @@ -843,6 +843,38 @@ Vyžaduje se, aby byl nainstalován `nikic/php-parser`. Pokud potřebujete manipulovat s globálním kódem v souborech nebo s jednotlivými příkazy v tělech metod, je lepší použít přímo knihovnu `nikic/php-parser`. +Class Manipulator +----------------- + +Třída [ClassManipulator|api:Nette\PhpGenerator\ClassManipulator] poskytuje nástroje pro manipulaci s třídami. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Metoda `inheritMethod()` zkopíruje metodu z rodičovské třídy nebo implementovaného rozhraní do vaší třídy. To vám umožní přepsat metodu nebo rozšířit její signaturu: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); + ``` + +Metoda `inheritProperty()` zkopíruje vlastnost z rodičovské třídy do vaší třídy. Je to užitečné, když chcete ve své třídě mít stejnou vlastnost, ale třeba s jinou výchozí hodnotou: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Metoda `implementInterface()` automaticky implementuje všechny metody z daného rozhraní ve vaší třídě: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Nyní vaše třída implementuje SomeInterface a obsahuje všechny jeho metody +``` + + Výpis proměnných ---------------- diff --git a/php-generator/de/@home.texy b/php-generator/de/@home.texy index b702ccfa1f..de0662647b 100644 --- a/php-generator/de/@home.texy +++ b/php-generator/de/@home.texy @@ -843,6 +843,38 @@ Dazu muss `nikic/php-parser` installiert sein. Wenn Sie globalen Code in Dateien oder einzelne Anweisungen in Methodenkörpern manipulieren müssen, ist es besser, die Bibliothek `nikic/php-parser` direkt zu verwenden. +Klasse Manipulator .[#toc-class-manipulator] +-------------------------------------------- + +Die Klasse [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] bietet Werkzeuge zur Manipulation von Klassen. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Die Methode `inheritMethod()` kopiert eine Methode aus einer übergeordneten Klasse oder einer implementierten Schnittstelle in Ihre Klasse. Auf diese Weise können Sie die Methode außer Kraft setzen oder ihre Signatur erweitern: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Die Methode `inheritProperty()` kopiert eine Eigenschaft aus einer übergeordneten Klasse in Ihre Klasse. Dies ist nützlich, wenn Sie die gleiche Eigenschaft in Ihrer Klasse haben möchten, aber möglicherweise mit einem anderen Standardwert: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Die Methode `implementInterface()` implementiert automatisch alle Methoden der angegebenen Schnittstelle in Ihrer Klasse: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Ihre Klasse implementiert nun SomeInterface und enthält alle seine Methoden +``` + + Variablen-Dumper .[#toc-variables-dumper] ----------------------------------------- diff --git a/php-generator/el/@home.texy b/php-generator/el/@home.texy index 93a82e630c..ca87244ab6 100644 --- a/php-generator/el/@home.texy +++ b/php-generator/el/@home.texy @@ -843,6 +843,38 @@ $file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php')); Αν πρέπει να χειριστείτε συνολικό κώδικα σε αρχεία ή μεμονωμένες εντολές σε σώματα μεθόδων, είναι προτιμότερο να χρησιμοποιήσετε απευθείας τη βιβλιοθήκη `nikic/php-parser`. +Χειριστής τάξης .[#toc-class-manipulator] +----------------------------------------- + +Η κλάση [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] παρέχει εργαλεία για το χειρισμό κλάσεων. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Η μέθοδος `inheritMethod()` αντιγράφει μια μέθοδο από μια γονική κλάση ή μια διεπαφή που έχει υλοποιηθεί στην κλάση σας. Αυτό σας επιτρέπει να υπερεκτελείτε τη μέθοδο ή να επεκτείνετε την υπογραφή της: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Η μέθοδος `inheritProperty()` αντιγράφει μια ιδιότητα από μια γονική κλάση στην κλάση σας. Αυτό είναι χρήσιμο όταν θέλετε να έχετε την ίδια ιδιότητα στην κλάση σας, αλλά ενδεχομένως με διαφορετική προεπιλεγμένη τιμή: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Η μέθοδος `implementInterface()` υλοποιεί αυτόματα όλες τις μεθόδους της δεδομένης διεπαφής στην κλάση σας: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Τώρα η κλάση σας υλοποιεί το SomeInterface και περιλαμβάνει όλες τις μεθόδους του +``` + + Μεταβλητές Dumper .[#toc-variables-dumper] ------------------------------------------ diff --git a/php-generator/en/@home.texy b/php-generator/en/@home.texy index b0be959343..ccd879bf4a 100644 --- a/php-generator/en/@home.texy +++ b/php-generator/en/@home.texy @@ -843,6 +843,38 @@ It requires `nikic/php-parser` to be installed. If you need to manipulate global code in files or individual statements in method bodies, it's better to use the `nikic/php-parser` library directly. +Class Manipulator +----------------- + +The [ClassManipulator|api:Nette\PhpGenerator\ClassManipulator] class provides tools for manipulating classes. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +The `inheritMethod()` method copies a method from a parent class or implemented interface into your class. This allows you to override the method or extend its signature: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +The `inheritProperty()` method copies a property from a parent class into your class. This is useful when you want to have the same property in your class, but possibly with a different default value: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +The `implementInterface()` method automatically implements all methods from the given interface in your class: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Now your class implements SomeInterface and includes all its methods +``` + + Variable Dumping ---------------- diff --git a/php-generator/es/@home.texy b/php-generator/es/@home.texy index c53c512da6..0ee0eb3d70 100644 --- a/php-generator/es/@home.texy +++ b/php-generator/es/@home.texy @@ -843,6 +843,38 @@ Esto requiere que `nikic/php-parser` esté instalado. Si necesita manipular código global en archivos o sentencias individuales en cuerpos de métodos, es mejor utilizar directamente la biblioteca `nikic/php-parser`. +Manipulador de clases .[#toc-class-manipulator] +----------------------------------------------- + +La clase [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] proporciona herramientas para manipular clases. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +El método `inheritMethod()` copia un método de una clase padre o de una interfaz implementada en su clase. Esto le permite sobrescribir el método o extender su firma: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +El método `inheritProperty()` copia una propiedad de una clase padre en tu clase. Esto es útil cuando se desea tener la misma propiedad en su clase, pero posiblemente con un valor predeterminado diferente: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +El método `implementInterface()` implementa automáticamente todos los métodos de la interfaz dada en su clase: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Ahora tu clase implementa CiertaInterfaz e incluye todos sus métodos +``` + + Volquete de variables .[#toc-variables-dumper] ---------------------------------------------- diff --git a/php-generator/fr/@home.texy b/php-generator/fr/@home.texy index 22ee5e3b0d..d0279a6c3a 100644 --- a/php-generator/fr/@home.texy +++ b/php-generator/fr/@home.texy @@ -843,6 +843,38 @@ Cela nécessite l'installation de `nikic/php-parser`. Si vous devez manipuler du code global dans des fichiers ou des instructions individuelles dans des corps de méthodes, il est préférable d'utiliser directement la bibliothèque `nikic/php-parser`. +Manipulateur de classe .[#toc-class-manipulator] +------------------------------------------------ + +La classe [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] fournit des outils pour manipuler les classes. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +La méthode `inheritMethod()` copie une méthode d'une classe parente ou d'une interface implémentée dans votre classe. Cela vous permet de remplacer la méthode ou d'étendre sa signature : + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +La méthode `inheritProperty()` copie une propriété d'une classe parente dans votre classe. Cette méthode est utile lorsque vous souhaitez avoir la même propriété dans votre classe, mais éventuellement avec une valeur par défaut différente : + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +La méthode `implementInterface()` implémente automatiquement toutes les méthodes de l'interface donnée dans votre classe : + +```php +$manipulator->implementInterface(SomeInterface::class); +// Maintenant, votre classe implémente SomeInterface et inclut toutes ses méthodes +``` + + Dumper de variables .[#toc-variables-dumper] -------------------------------------------- diff --git a/php-generator/hu/@home.texy b/php-generator/hu/@home.texy index d5175f7292..cd1cc89d34 100644 --- a/php-generator/hu/@home.texy +++ b/php-generator/hu/@home.texy @@ -843,6 +843,38 @@ Ehhez telepíteni kell a `nikic/php-parser` oldalt. Ha fájlokban lévő globális kódot vagy a metódusok testében lévő egyes utasításokat kell manipulálnia, jobb, ha közvetlenül a `nikic/php-parser` könyvtárat használja. +Osztály Manipulátor .[#toc-class-manipulator] +--------------------------------------------- + +A [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] osztály eszközöket biztosít az osztályok manipulálásához. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +A `inheritMethod()` metódus egy metódust másol át egy szülő osztályból vagy egy implementált interfészből az osztályodba. Ez lehetővé teszi a metódus felülírását vagy a szignatúrájának kiterjesztését: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +A `inheritProperty()` metódus egy tulajdonságot másol át egy szülő osztályból az Ön osztályába. Ez akkor hasznos, ha ugyanazt a tulajdonságot szeretné az osztályában, de esetleg más alapértelmezett értékkel: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +A `implementInterface()` metódus automatikusan megvalósítja az adott interfész összes metódusát az osztályodban: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Most az osztályod megvalósítja a SomeInterface-t és tartalmazza annak összes metódusát. +``` + + Változók Dumper .[#toc-variables-dumper] ---------------------------------------- diff --git a/php-generator/it/@home.texy b/php-generator/it/@home.texy index 77dfc8f8a6..5d3c701cc1 100644 --- a/php-generator/it/@home.texy +++ b/php-generator/it/@home.texy @@ -843,6 +843,38 @@ Questo richiede l'installazione di `nikic/php-parser`. Se è necessario manipolare il codice globale nei file o le singole dichiarazioni nei corpi dei metodi, è meglio usare direttamente la libreria `nikic/php-parser`. +Manipolatore di classe .[#toc-class-manipulator] +------------------------------------------------ + +La classe [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] fornisce strumenti per la manipolazione delle classi. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Il metodo `inheritMethod()` copia un metodo da una classe padre o da un'interfaccia implementata nella propria classe. Ciò consente di sovrascrivere il metodo o di estenderne la firma: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Il metodo `inheritProperty()` copia una proprietà da una classe padre nella vostra classe. È utile quando si vuole avere la stessa proprietà nella propria classe, ma eventualmente con un valore predefinito diverso: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Il metodo `implementInterface()` implementa automaticamente tutti i metodi dell'interfaccia data nella vostra classe: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Ora la classe implementa SomeInterface e include tutti i suoi metodi +``` + + Dumper di variabili .[#toc-variables-dumper] -------------------------------------------- diff --git a/php-generator/ja/@home.texy b/php-generator/ja/@home.texy index 0a043cd0ee..8468614408 100644 --- a/php-generator/ja/@home.texy +++ b/php-generator/ja/@home.texy @@ -843,6 +843,38 @@ $file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php')); ファイル内のグローバルコードやメソッド本体内の個々のステートメントを操作する必要がある場合は、 `nikic/php-parser` ライブラリを直接使用するのがよい。 +クラス・マニピュレーター.[#toc-class-manipulator] +------------------------------------- + +[ClassManipulator |api:Nette\PhpGenerator\ClassManipulator]クラスは、クラスを操作するためのツールを提供します。 + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +`inheritMethod()` メソッドは、親クラスまたは実装されたインターフェイスのメソッドをあなたのクラスにコピーします。これにより、メソッドをオーバーライドしたり、シグネチャを拡張したりできます： + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +`inheritProperty()` メソッドは、親クラスからあなたのクラスにプロパティをコピーします。これは、同じプロパティを自分のクラスにも持たせたいが、デフォルト値が異なる可能性がある場合に便利です： + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +`implementInterface()` メソッドは、指定されたインターフェイスのすべてのメソッドを自動的にクラスに実装します： + +```php +$manipulator->implementInterface(SomeInterface::class); +// これで、あなたのクラスは SomeInterface を実装し、そのすべてのメソッドを含むようになった。 +``` + + 変数ダンパ .[#toc-variables-dumper] ------------------------------ diff --git a/php-generator/pl/@home.texy b/php-generator/pl/@home.texy index 2ce02ec8fc..3f68976960 100644 --- a/php-generator/pl/@home.texy +++ b/php-generator/pl/@home.texy @@ -843,6 +843,38 @@ Wymaga to zainstalowania `nikic/php-parser`. Jeśli musisz manipulować globalnym kodem w plikach lub pojedynczymi stwierdzeniami w ciałach metod, lepiej jest użyć bezpośrednio biblioteki `nikic/php-parser`. +Class Manipulator .[#toc-class-manipulator] +------------------------------------------- + +Klasa [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] zapewnia narzędzia do manipulowania klasami. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Metoda `inheritMethod()` kopiuje metodę z klasy nadrzędnej lub zaimplementowanego interfejsu do klasy użytkownika. Pozwala to na nadpisanie metody lub rozszerzenie jej sygnatury: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Metoda `inheritProperty()` kopiuje właściwość z klasy nadrzędnej do klasy użytkownika. Jest to przydatne, gdy chcesz mieć tę samą właściwość w swojej klasie, ale prawdopodobnie z inną wartością domyślną: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Metoda `implementInterface()` automatycznie implementuje wszystkie metody z danego interfejsu w klasie: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Teraz twoja klasa implementuje interfejs SomeInterface i zawiera wszystkie jego metody +``` + + Zrzutka zmiennych .[#toc-variables-dumper] ------------------------------------------ diff --git a/php-generator/pt/@home.texy b/php-generator/pt/@home.texy index 9826bd8f9c..3e797093a6 100644 --- a/php-generator/pt/@home.texy +++ b/php-generator/pt/@home.texy @@ -843,6 +843,38 @@ Isto requer que `nikic/php-parser` seja instalado. Se você precisar manipular o código global em arquivos ou declarações individuais em corpos de métodos, é melhor usar a biblioteca `nikic/php-parser` diretamente. +Manipulador de classe .[#toc-class-manipulator] +----------------------------------------------- + +A classe [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] fornece ferramentas para a manipulação de classes. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +O método `inheritMethod()` copia um método de uma classe pai ou de uma interface implementada em sua classe. Isso permite que você substitua o método ou estenda sua assinatura: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +O método `inheritProperty()` copia uma propriedade de uma classe principal para a sua classe. Isso é útil quando você deseja ter a mesma propriedade em sua classe, mas possivelmente com um valor padrão diferente: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +O método `implementInterface()` implementa automaticamente todos os métodos da interface fornecida em sua classe: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Agora sua classe implementa SomeInterface e inclui todos os seus métodos +``` + + Variáveis Dumper .[#toc-variables-dumper] ----------------------------------------- diff --git a/php-generator/ro/@home.texy b/php-generator/ro/@home.texy index 654182007b..edc02152f3 100644 --- a/php-generator/ro/@home.texy +++ b/php-generator/ro/@home.texy @@ -843,6 +843,38 @@ Acest lucru necesită instalarea `nikic/php-parser`. Dacă aveți nevoie să manipulați codul global din fișiere sau declarațiile individuale din corpurile metodelor, este mai bine să utilizați direct biblioteca `nikic/php-parser`. +Manipulator de clasă .[#toc-class-manipulator] +---------------------------------------------- + +Clasa [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] oferă instrumente pentru manipularea claselor. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Metoda `inheritMethod()` copiază o metodă dintr-o clasă părinte sau dintr-o interfață implementată în clasa dumneavoastră. Acest lucru vă permite să suprascrieți metoda sau să-i extindeți semnătura: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Metoda `inheritProperty()` copiază o proprietate dintr-o clasă părinte în clasa dumneavoastră. Acest lucru este util atunci când doriți să aveți aceeași proprietate în clasa dvs., dar eventual cu o valoare implicită diferită: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Metoda `implementInterface()` implementează automat toate metodele interfeței date în clasa dumneavoastră: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Acum clasa dvs. implementează SomeInterface și include toate metodele acesteia +``` + + Descărcător de variabile .[#toc-variables-dumper] ------------------------------------------------- diff --git a/php-generator/ru/@home.texy b/php-generator/ru/@home.texy index ca802725c6..dc328ce15a 100644 --- a/php-generator/ru/@home.texy +++ b/php-generator/ru/@home.texy @@ -843,6 +843,38 @@ $file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php')); Если вам нужно манипулировать глобальным кодом в файлах или отдельными утверждениями в телах методов, лучше использовать непосредственно библиотеку `nikic/php-parser`. +Манипулятор класса .[#toc-class-manipulator] +-------------------------------------------- + +Класс [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] предоставляет инструменты для манипулирования классами. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Метод `inheritMethod()` копирует метод из родительского класса или реализованного интерфейса в ваш класс. Это позволяет переопределить метод или расширить его сигнатуру: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Метод `inheritProperty()` копирует свойство из родительского класса в ваш класс. Это полезно, когда вы хотите иметь то же свойство в своем классе, но, возможно, с другим значением по умолчанию: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Метод `implementInterface()` автоматически реализует в вашем классе все методы из заданного интерфейса: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Теперь ваш класс реализует SomeInterface и включает все его методы +``` + + Дампинг переменных .[#toc-variables-dumper] ------------------------------------------- diff --git a/php-generator/sl/@home.texy b/php-generator/sl/@home.texy index 38295d8b38..015e74f7bd 100644 --- a/php-generator/sl/@home.texy +++ b/php-generator/sl/@home.texy @@ -843,6 +843,38 @@ Za to je treba namestiti `nikic/php-parser`. Če morate upravljati globalno kodo v datotekah ali posamezne stavke v telesih metod, je bolje, da neposredno uporabite knjižnico `nikic/php-parser`. +Manipulator razreda .[#toc-class-manipulator] +--------------------------------------------- + +Razred [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] ponuja orodja za manipulacijo z razredi. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Metoda `inheritMethod()` kopira metodo iz nadrejenega razreda ali implementiranega vmesnika v vaš razred. To vam omogoča, da metodo prekrijete ali razširite njen podpis: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Metoda `inheritProperty()` kopira lastnost iz nadrejenega razreda v vaš razred. To je uporabno, kadar želite imeti isto lastnost v svojem razredu, vendar po možnosti z drugo privzeto vrednostjo: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Metoda `implementInterface()` samodejno implementira vse metode iz danega vmesnika v vaš razred: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Zdaj vaš razred implementira SomeInterface in vključuje vse njegove metode +``` + + Zbiralnik spremenljivk .[#toc-variables-dumper] ----------------------------------------------- diff --git a/php-generator/tr/@home.texy b/php-generator/tr/@home.texy index 54d00a680c..6d27983caf 100644 --- a/php-generator/tr/@home.texy +++ b/php-generator/tr/@home.texy @@ -843,6 +843,38 @@ Bunun için `nikic/php-parser` adresinin yüklenmesi gerekir. Dosyalardaki genel kodu veya yöntem gövdelerindeki tek tek ifadeleri değiştirmeniz gerekiyorsa, `nikic/php-parser` kütüphanesini doğrudan kullanmak daha iyidir. +Sınıf Manipülatörü .[#toc-class-manipulator] +-------------------------------------------- + + [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] sınıfı, sınıfları [manipüle |api:Nette\PhpGenerator\ClassManipulator] etmek için araçlar sağlar. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + + `inheritMethod()` yöntemi, bir üst sınıftaki veya uygulanan arayüzdeki bir yöntemi sınıfınıza kopyalar. Bu, yöntemi geçersiz kılmanıza veya imzasını genişletmenize olanak tanır: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + + `inheritProperty()` yöntemi, bir özelliği bir üst sınıftan sınıfınıza kopyalar. Bu, sınıfınızda aynı özelliğe sahip olmak, ancak muhtemelen farklı bir varsayılan değere sahip olmak istediğinizde kullanışlıdır: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + + `implementInterface()` yöntemi, sınıfınızda verilen arayüzdeki tüm yöntemleri otomatik olarak uygular: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Şimdi sınıfınız SomeInterface'i uyguluyor ve tüm yöntemlerini içeriyor +``` + + Değişkenler Damperi .[#toc-variables-dumper] -------------------------------------------- diff --git a/php-generator/uk/@home.texy b/php-generator/uk/@home.texy index b9cdaf9a08..3a6c88f616 100644 --- a/php-generator/uk/@home.texy +++ b/php-generator/uk/@home.texy @@ -843,6 +843,38 @@ $file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php')); Якщо вам потрібно маніпулювати глобальним кодом у файлах або окремими операторами в тілах методів, краще використовувати безпосередньо бібліотеку `nikic/php-parser`. +Клас Маніпулятор .[#toc-class-manipulator] +------------------------------------------ + +Клас [ClassManipulator |api:Nette\PhpGenerator\ClassManipulator] надає інструменти для маніпулювання класами. + +```php +$class = new Nette\PhpGenerator\ClassType('Demo'); +$manipulator = new Nette\PhpGenerator\ClassManipulator($class); +``` + +Метод `inheritMethod()` копіює метод з батьківського класу або реалізованого інтерфейсу у ваш клас. Це дозволяє перевизначити метод або розширити його сигнатуру: + +```php +$method = $manipulator->inheritMethod('bar'); +$method->setBody('...'); +``` + +Метод `inheritProperty()` копіює властивість з батьківського класу у ваш клас. Це корисно, коли ви хочете мати таку саму властивість у своєму класі, але, можливо, з іншим значенням за замовчуванням: + +```php +$property = $manipulator->inheritProperty('foo'); +$property->setValue('new value'); +``` + +Метод `implementInterface()` автоматично реалізує всі методи з даного інтерфейсу у вашому класі: + +```php +$manipulator->implementInterface(SomeInterface::class); +// Тепер ваш клас реалізує SomeInterface і включає всі його методи +``` + + Дампер змінних .[#toc-variables-dumper] --------------------------------------- From 16181a4ad53400568783a4e2aaaecadd19e65d8d Mon Sep 17 00:00:00 2001 From: David Grudl Date: Sun, 9 Jun 2024 20:44:17 +0200 Subject: [PATCH 05/23] nette/application 3.2.6 --- application/bg/configuration.texy | 5 ++++- application/bg/templates.texy | 2 +- application/cs/configuration.texy | 5 ++++- application/cs/templates.texy | 2 +- application/de/configuration.texy | 5 ++++- application/de/templates.texy | 2 +- application/el/configuration.texy | 5 ++++- application/el/templates.texy | 2 +- application/en/configuration.texy | 5 ++++- application/en/templates.texy | 2 +- application/es/configuration.texy | 5 ++++- application/es/templates.texy | 2 +- application/fr/configuration.texy | 9 ++++++--- application/fr/templates.texy | 2 +- application/hu/configuration.texy | 5 ++++- application/hu/templates.texy | 2 +- application/it/configuration.texy | 7 +++++-- application/it/templates.texy | 2 +- application/pl/configuration.texy | 5 ++++- application/pl/templates.texy | 2 +- application/pt/configuration.texy | 5 ++++- application/pt/templates.texy | 2 +- application/ro/configuration.texy | 5 ++++- application/ro/templates.texy | 2 +- application/ru/configuration.texy | 5 ++++- application/ru/templates.texy | 2 +- application/sl/configuration.texy | 5 ++++- application/sl/templates.texy | 2 +- application/tr/configuration.texy | 5 ++++- application/tr/templates.texy | 2 +- application/uk/configuration.texy | 5 ++++- application/uk/templates.texy | 2 +- latte/cs/cookbook/migration-from-latte2.texy | 2 +- latte/en/cookbook/migration-from-latte2.texy | 2 +- 34 files changed, 85 insertions(+), 37 deletions(-) diff --git a/application/bg/configuration.texy b/application/bg/configuration.texy index 30bc0d30c0..0e2aeb11b1 100644 --- a/application/bg/configuration.texy +++ b/application/bg/configuration.texy @@ -95,6 +95,9 @@ latte: # позволява [проверка на генерирания код |latte:develop#Checking Generated Code] phpLinter: ... # (string) по подразбиране е null + # задава локала + locale: cs_CZ # (string) по подразбиране е null + # клас $this->template templateClass: App\MyTemplateClass # по подразбиране Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ latte: ```neon latte: расширения: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/bg/templates.texy b/application/bg/templates.texy index 584b6cbff3..0be4f81857 100644 --- a/application/bg/templates.texy +++ b/application/bg/templates.texy @@ -285,7 +285,7 @@ protected function beforeRender(): void ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` След това транслаторът може да се използва например като филтър `|translate`, като на метода `translate()` се предават допълнителни параметри (вж. `foo, bar`): diff --git a/application/cs/configuration.texy b/application/cs/configuration.texy index acab7d7adf..84954e2e59 100644 --- a/application/cs/configuration.texy +++ b/application/cs/configuration.texy @@ -95,6 +95,9 @@ latte: # aktivuje [kontrolu vygenerovaného kódu |latte:develop#Kontrola vygenerovaného kódu] phpLinter: ... # (string) výchozí je null + # nastaví locale + locale: cs_CZ # (string) výchozí je null + # třída objektu $this->template templateClass: App\MyTemplateClass # výchozí je Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Pokud používáte Latte verze 3, můžete přidávat nové [rozšíření |latt ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Pokud používáte Latte verze 2, můžete registrovat nové tagy (makra) buď uvedením jména třídy, nebo referencí na službu. Jako výchozí je zavolána metoda `install()`, ale to lze změnit tím, že uvedeme jméno jiné metody: diff --git a/application/cs/templates.texy b/application/cs/templates.texy index 8caa687b44..470c68748b 100644 --- a/application/cs/templates.texy +++ b/application/cs/templates.texy @@ -285,7 +285,7 @@ Translator je alternativně možné nastavit pomocí [konfigurace |configuration ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Poté lze překladač používat například jako filtr `|translate`, a to včetně doplňujících parametrů, které se předají metodě `translate()` (viz `foo, bar`): diff --git a/application/de/configuration.texy b/application/de/configuration.texy index d5b665b684..848f7abb64 100644 --- a/application/de/configuration.texy +++ b/application/de/configuration.texy @@ -95,6 +95,9 @@ Latte: # aktiviert die [Überprüfung von generiertem Code |latte:develop#Checking Generated Code] phpLinter: ... # (string) Voreinstellung ist null + # legt das Gebietsschema fest + locale: cs_CZ # (string) Voreinstellung ist null + # Klasse von $this->template templateClass: App\MyTemplateClass # Standardwert ist Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Wenn Sie Latte Version 3 verwenden, können Sie neue [Erweiterungen |latte:creat ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/de/templates.texy b/application/de/templates.texy index 8860819f5f..466cb501c3 100644 --- a/application/de/templates.texy +++ b/application/de/templates.texy @@ -285,7 +285,7 @@ Alternativ kann der Übersetzer auch über die [Konfiguration |configuration#Lat ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Der Übersetzer kann dann z.B. als Filter `|translate` verwendet werden, wobei zusätzliche Parameter an die Methode `translate()` übergeben werden (siehe `foo, bar`): diff --git a/application/el/configuration.texy b/application/el/configuration.texy index 99bea2563d..dcf8543ece 100644 --- a/application/el/configuration.texy +++ b/application/el/configuration.texy @@ -95,6 +95,9 @@ latte: # ενεργοποιεί τον [έλεγχο του παραγόμενου κώδικα |latte:develop#Checking Generated Code] phpLinter: ... # (string) η προεπιλογή είναι null + # ορίζει την τοπική γλώσσα + locale: cs_CZ # (string) η προεπιλογή είναι null + # κλάση του $this->template templateClass: App\MyTemplateClass # προεπιλογή σε Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ latte: ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/el/templates.texy b/application/el/templates.texy index 39c2ddca2e..dfe884dd1b 100644 --- a/application/el/templates.texy +++ b/application/el/templates.texy @@ -285,7 +285,7 @@ protected function beforeRender(): void ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Ο μεταφραστής μπορεί στη συνέχεια να χρησιμοποιηθεί, για παράδειγμα, ως φίλτρο `|translate`, με πρόσθετες παραμέτρους που περνούν στη μέθοδο `translate()` (βλ. `foo, bar`): diff --git a/application/en/configuration.texy b/application/en/configuration.texy index fba71aa4fd..e9df62aef7 100644 --- a/application/en/configuration.texy +++ b/application/en/configuration.texy @@ -95,6 +95,9 @@ latte: # enables [checking generated code |latte:develop#Checking Generated Code] phpLinter: ... # (string) default is null + # sets the locale + locale: cs_CZ # (string) default is null + # class of $this->template templateClass: App\MyTemplateClass # defaults to Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ If you are using Latte version 3, you can add new [extension |latte:creating-ext ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` If you are using Latte version 2, you can register new tags either by entering the class name or by referring to the service. Method `install()` is called by default, but this can be changed by specifying the name of another method: diff --git a/application/en/templates.texy b/application/en/templates.texy index 8069d6b23d..bdc524c4e4 100644 --- a/application/en/templates.texy +++ b/application/en/templates.texy @@ -285,7 +285,7 @@ Alternatively, the translator can be set using the [configuration |configuration ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` The translator can then be used, for example, as a filter `|translate`, with additional parameters passed to the `translate()` method (see `foo, bar`): diff --git a/application/es/configuration.texy b/application/es/configuration.texy index bbde2bac4e..aa5273344b 100644 --- a/application/es/configuration.texy +++ b/application/es/configuration.texy @@ -95,6 +95,9 @@ latte: # habilita la [comprobación del código generado |latte:develop#Checking Generated Code] phpLinter: ... # (string) por defecto es null + # establece la configuración regional + locale: cs_CZ # (string) por defecto es null + # clase de $this->plantilla templateClass: App\MyTemplateClass # por defecto Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Si está utilizando la versión 3 de Latte, puede añadir una nueva [extensión ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/es/templates.texy b/application/es/templates.texy index 44a0bbeb7a..af06db6505 100644 --- a/application/es/templates.texy +++ b/application/es/templates.texy @@ -285,7 +285,7 @@ Alternativamente, el traductor se puede establecer utilizando la [configuración ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` El traductor puede utilizarse, por ejemplo, como un filtro `|translate`, con parámetros adicionales pasados al método `translate()` (véase `foo, bar`): diff --git a/application/fr/configuration.texy b/application/fr/configuration.texy index 4398c0e7fe..d180bce83a 100644 --- a/application/fr/configuration.texy +++ b/application/fr/configuration.texy @@ -90,10 +90,13 @@ latte: strictTypes: ... # (bool) vaut false par défaut # active le [mode strict de l'analyseur |latte:develop#strict mode] - strictParsing : ... # (bool) la valeur par défaut est false + strictParsing: ... # (bool) la valeur par défaut est false # permet de [vérifier le code généré |latte:develop#Checking Generated Code] - phpLinter : ... # (string) la valeur par défaut est null + phpLinter: ... # (string) la valeur par défaut est null + + # définit la locale + locale: cs_CZ # (string) la valeur par défaut est null # classe de $this->template templateClass: App\MyTemplateClass # Valeur par défaut: Nette\Bridges\ApplicationLatte\DefaultTemplate @@ -104,7 +107,7 @@ Si vous utilisez la version 3 de Latte, vous pouvez ajouter une nouvelle [extens ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/fr/templates.texy b/application/fr/templates.texy index dc2ccff07f..494ea2da09 100644 --- a/application/fr/templates.texy +++ b/application/fr/templates.texy @@ -285,7 +285,7 @@ Alternativement, le traducteur peut être défini à l'aide de la [configuration ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Le traducteur peut alors être utilisé, par exemple, comme un filtre `|translate`, avec des paramètres supplémentaires transmis à la méthode `translate()` (voir `foo, bar`) : diff --git a/application/hu/configuration.texy b/application/hu/configuration.texy index 2dc8e2a87a..8c07c79a3a 100644 --- a/application/hu/configuration.texy +++ b/application/hu/configuration.texy @@ -95,6 +95,9 @@ latte: # engedélyezi a [generált kód ellenőrzését |latte:develop#Checking Generated Code] phpLinter: ... # (string) alapértelmezett a null + # beállítja a nyelvjárást + locale: cs_CZ # (string) alapértelmezett érték nulla + # $this->template osztálya templateClass: # alapértelmezett értéke Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Ha a Latte 3. verzióját használja, akkor új [bővítményt |latte:creating-e ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/hu/templates.texy b/application/hu/templates.texy index d51d03bbc6..3f46d2d377 100644 --- a/application/hu/templates.texy +++ b/application/hu/templates.texy @@ -285,7 +285,7 @@ Alternatívaként a fordítót a [konfiguráció |configuration#Latte] segítsé ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` A fordító ekkor például a `|translate` szűrőként használható, a `translate()` metódusnak átadott további paraméterekkel (lásd `foo, bar`): diff --git a/application/it/configuration.texy b/application/it/configuration.texy index be8d2ebc12..c4703d5632 100644 --- a/application/it/configuration.texy +++ b/application/it/configuration.texy @@ -93,7 +93,10 @@ latte: strictParsing: ... # (bool) l'impostazione predefinita è false # abilita il [controllo del codice generato |latte:develop#Checking Generated Code] - phpLinter: ... # (stringa) il valore predefinito è null + phpLinter: ... # (string) il valore predefinito è null + + # imposta il locale + locale: cs_CZ # (string) il valore predefinito è null # classe di $this->template templateClass: App\MyTemplateClass # predefinita a Nette\Bridges\ApplicationLatte\DefaultTemplate @@ -104,7 +107,7 @@ Se si utilizza la versione 3 di Latte, è possibile aggiungere nuove [estensioni ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/it/templates.texy b/application/it/templates.texy index 2d3412da33..55e31fa8b9 100644 --- a/application/it/templates.texy +++ b/application/it/templates.texy @@ -285,7 +285,7 @@ In alternativa, il traduttore può essere impostato utilizzando la [configurazio ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Il traduttore può essere utilizzato, ad esempio, come filtro `|translate`, con parametri aggiuntivi passati al metodo `translate()` (vedere `foo, bar`): diff --git a/application/pl/configuration.texy b/application/pl/configuration.texy index 7986b64e24..d59b60bb8e 100644 --- a/application/pl/configuration.texy +++ b/application/pl/configuration.texy @@ -95,6 +95,9 @@ latte: # włącza [sprawdzanie wygenerowanego kodu |latte:develop#Checking Generated Code] phpLinter: ... # (string) domyślnie null + # ustawia ustawienia regionalne + locale: cs_CZ # (string) domyślnie null + # klasa obiektów $this->template templateClass: AppMyTemplateClass # domyślnie jest Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Jeśli używasz Latte w wersji 3, możesz dodać nowe [rozszerzenia |latte:creat ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/pl/templates.texy b/application/pl/templates.texy index cb89c8cf68..51705f00d3 100644 --- a/application/pl/templates.texy +++ b/application/pl/templates.texy @@ -285,7 +285,7 @@ Alternatywnie, tłumacz może być ustawiony za pomocą [konfiguracji |configura ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Translator może być wtedy użyty np. jako filtr `|translate`, z dodatkowymi parametrami przekazywanymi do metody `translate()` (patrz `foo, bar`): diff --git a/application/pt/configuration.texy b/application/pt/configuration.texy index d83543aca8..55e3c0cb5d 100644 --- a/application/pt/configuration.texy +++ b/application/pt/configuration.texy @@ -95,6 +95,9 @@ latte: # Permite [verificar o código gerado |latte:develop#Checking Generated Code] phpLinter: ... # (string) o padrão é null + # Define a localidade + locale: cs_CZ # (string) o padrão é nulo + # classe de $this->template templateClass: App\MyTemplateClass # defaults to Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Se você estiver usando Latte versão 3, você pode adicionar uma nova [extensã ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/pt/templates.texy b/application/pt/templates.texy index 75e73e1d98..2886c6740e 100644 --- a/application/pt/templates.texy +++ b/application/pt/templates.texy @@ -285,7 +285,7 @@ Alternativamente, o tradutor pode ser definido usando a [configuração |configu ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` O tradutor pode então ser usado, por exemplo, como um filtro `|translate`, com parâmetros adicionais passados para o método `translate()` (ver `foo, bar`): diff --git a/application/ro/configuration.texy b/application/ro/configuration.texy index 4783df2ade..d5965b0e36 100644 --- a/application/ro/configuration.texy +++ b/application/ro/configuration.texy @@ -95,6 +95,9 @@ latte: # activează [verificarea codului generat |latte:develop#Checking Generated Code] phpLinter: ... # (string) implicit este null + # stabilește localul + locale: cs_CZ # (string) implicit este nul + # clasa lui $this->template templateClass: App\MyTemplateClass # valoarea implicită este Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Dacă utilizați Latte versiunea 3, puteți adăuga o nouă [extensie |latte:cre ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/ro/templates.texy b/application/ro/templates.texy index a12657b6f9..043a5fb016 100644 --- a/application/ro/templates.texy +++ b/application/ro/templates.texy @@ -285,7 +285,7 @@ Alternativ, traducătorul poate fi setat cu ajutorul [configurației |configurat ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Traducătorul poate fi apoi utilizat, de exemplu, ca filtru `|translate`, cu parametri suplimentari trecuți la metoda `translate()` (a se vedea `foo, bar`): diff --git a/application/ru/configuration.texy b/application/ru/configuration.texy index 9cb80fc192..0121aa4071 100644 --- a/application/ru/configuration.texy +++ b/application/ru/configuration.texy @@ -95,6 +95,9 @@ latte: # включает [проверку сгенерированного кода |latte:develop#Checking Generated Code] phpLinter: ... # (string) по умолчанию равно null + # устанавливает локаль + locale: cs_CZ # (string) по умолчанию null + # класс $this->template templateClass: App\MyTemplateClass # по умолчанию Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ latte: ```neon latte: расширения: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/ru/templates.texy b/application/ru/templates.texy index f506d32046..4be9f83e4d 100644 --- a/application/ru/templates.texy +++ b/application/ru/templates.texy @@ -285,7 +285,7 @@ protected function beforeRender(): void ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Транслятор можно использовать, например, в качестве фильтра `|translate`, передав дополнительные параметры в метод `translate()` (см. `foo, bar`): diff --git a/application/sl/configuration.texy b/application/sl/configuration.texy index b12fdcd385..179324658b 100644 --- a/application/sl/configuration.texy +++ b/application/sl/configuration.texy @@ -95,6 +95,9 @@ latte: # omogoča [preverjanje ustvarjene kode |latte:develop#Checking Generated Code] phpLinter: ... # (string) privzeto je null + # nastavi krajevni jezik + locale: cs_CZ # (string) privzeto je nič + # razred $this->template templateClass: App\MyTemplateClass # privzeto je Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ latte: ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/sl/templates.texy b/application/sl/templates.texy index 966b1524a2..06c0ddeb10 100644 --- a/application/sl/templates.texy +++ b/application/sl/templates.texy @@ -285,7 +285,7 @@ Prevajalnik lahko nastavimo tudi s [konfiguracijo |configuration#Latte]: ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Prevajalnik lahko nato uporabimo na primer kot filter `|translate`, pri čemer metodi `translate()` posredujemo dodatne parametre (glej `foo, bar`): diff --git a/application/tr/configuration.texy b/application/tr/configuration.texy index 2f1ed45c00..62d7a3f3f7 100644 --- a/application/tr/configuration.texy +++ b/application/tr/configuration.texy @@ -95,6 +95,9 @@ latte: # [oluşturulan kodun kontrol |latte:develop#Checking Generated Code]edilmesini sağlar phpLinter: ... # (string) varsayılan null + # yerel ayarı ayarlar + locale: cs_CZ # (string) varsayılan null + # $this->template sınıfı templateClass: App\MyTemplateClass # varsayılan olarak Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ Latte sürüm 3 kullanıyorsanız, kullanarak yeni [uzantı |latte:creating-exte ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/tr/templates.texy b/application/tr/templates.texy index ca42448aad..bd2fea6eee 100644 --- a/application/tr/templates.texy +++ b/application/tr/templates.texy @@ -285,7 +285,7 @@ Alternatif olarak, çevirmen [yapılandırma |configuration#Latte] kullanılarak ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Çevirmen daha sonra örneğin `|translate` filtresi olarak kullanılabilir ve ek parametreler `translate()` yöntemine aktarılabilir (bkz. `foo, bar`): diff --git a/application/uk/configuration.texy b/application/uk/configuration.texy index 3fe82774a3..9e34868a04 100644 --- a/application/uk/configuration.texy +++ b/application/uk/configuration.texy @@ -95,6 +95,9 @@ latte: # включає [перевірку згенерованого коду |latte:develop#Checking Generated Code] phpLinter: ... # (string) за замовчуванням null + # встановлює локаль + locale: cs_CZ # (string) за замовчуванням null + # клас $this->template templateClass: App\MyTemplateClass # за замовчуванням Nette\Bridges\ApplicationLatte\DefaultTemplate ``` @@ -104,7 +107,7 @@ latte: ```neon latte: расширения: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` /--comment diff --git a/application/uk/templates.texy b/application/uk/templates.texy index 4b2fda15f0..c4ed7aee2b 100644 --- a/application/uk/templates.texy +++ b/application/uk/templates.texy @@ -285,7 +285,7 @@ protected function beforeRender(): void ```neon latte: extensions: - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` Тоді перекладач можна використовувати, наприклад, як фільтр `|translate`, з додатковими параметрами, переданими методу `translate()` (див. `foo, bar`): diff --git a/latte/cs/cookbook/migration-from-latte2.texy b/latte/cs/cookbook/migration-from-latte2.texy index bd8cfc0352..4718cb2d74 100644 --- a/latte/cs/cookbook/migration-from-latte2.texy +++ b/latte/cs/cookbook/migration-from-latte2.texy @@ -177,7 +177,7 @@ V Latte 2 bylo možné registrovat nové tagy pomocí [konfiguračního souboru latte: extensions: - App\Templating\LatteExtension - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` diff --git a/latte/en/cookbook/migration-from-latte2.texy b/latte/en/cookbook/migration-from-latte2.texy index 825cf2275a..8215f592ab 100644 --- a/latte/en/cookbook/migration-from-latte2.texy +++ b/latte/en/cookbook/migration-from-latte2.texy @@ -177,7 +177,7 @@ In Latte 2 it was possible to register new tags using [config file |application: latte: extensions: - App\Templating\LatteExtension - - Latte\Essential\TranslatorExtension + - Latte\Essential\TranslatorExtension(@Nette\Localization\Translator) ``` From d8f3f803db2774b56e263530bd4dc4c5db9fe566 Mon Sep 17 00:00:00 2001 From: David Grudl Date: Mon, 2 Sep 2024 01:21:39 +0200 Subject: [PATCH 06/23] new translation wip --- latte/de/filters.texy | 482 ++++++++++++++++++++-------------------- latte/de/tags.texy | 500 +++++++++++++++++++++--------------------- 2 files changed, 491 insertions(+), 491 deletions(-) diff --git a/latte/de/filters.texy b/latte/de/filters.texy index 8e445dd3c3..7db3a09bd2 100644 --- a/latte/de/filters.texy +++ b/latte/de/filters.texy @@ -1,101 +1,101 @@ -Latte Filtern -************* +Latte Filter +************ .[perex] -Filter sind Funktionen, die die Daten in der gewünschten Form verändern oder formatieren. Dies ist eine Zusammenfassung der eingebauten Filter, die verfügbar sind. +In Templates können wir Funktionen verwenden, die bei der Anpassung oder Umformatierung von Daten in die endgültige Form helfen. Wir nennen sie *Filter*. .[table-latte-filters] -|## String / Array Transformation -| `batch` | [Auflistung linearer Daten in einer Tabelle |#batch] -| `breakLines` | [fügt HTML-Zeilenumbrüche vor allen Zeilenumbrüchen ein |#breakLines] -| `bytes` | [formatiert Größe in Bytes |#bytes] -| `clamp` | [klemmt Wert auf den Bereich |#clamp] -| `dataStream` | [Konvertierung des Daten-URI-Protokolls |#datastream] -| `date` | [formatiert das Datum und die Uhrzeit |#date] -| `explode` | [trennt eine Zeichenkette durch das angegebene Trennzeichen auf |#explode] -| `first` | [gibt das erste Element eines Arrays oder ein Zeichen einer Zeichenkette zurück |#first] -| `group` | [gruppiert Daten nach verschiedenen Kriterien |#group] -| `implode` | [fügt ein Array zu einer Zeichenkette zusammen |#implode] -| `indent` | [rückt den Text von links mit einer Anzahl von Tabulatorenein |#indent] -| `join` | [verbindet ein Array mit einer Zeichenkette|#implode] -| `last` | [gibt das letzte Element eines Arrays oder ein Zeichen einer Zeichenkette zurück |#last] -| `length` | [gibt die Länge einer Zeichenkette oder eines Arrays zurück |#length] -| `localDate` | [formatiert das Datum und die Uhrzeit entsprechend dem Gebietsschema |#localDate] -| `number` | [formatiert Zahlen |#number] -| `padLeft` | [vervollständigt die Zeichenkette auf die angegebene Länge von links |#padLeft] -| `padRight` | [vervollständigt die Zeichenkette auf die angegebene Länge von rechts |#padRight] -| `random` | [gibt zufällige Elemente eines Arrays oder Zeichen einer Zeichenkette zurück |#random] -| `repeat` | [Wiederholt die Zeichenkette |#repeat] -| `replace` | [ersetzt alle Vorkommen der gesuchten Zeichenkette durch die Ersetzung |#replace] -| `replaceRE` | [ersetzt alle Vorkommen entsprechend dem regulären Ausdruck |#replaceRE] -| `reverse` | [kehrt eine UTF-8 Zeichenkette oder ein Array um |#reverse] -| `slice` | [extrahiert einen Ausschnitt aus einem Array oder einer Zeichenkette |#slice] -| `sort` | [sortiert ein Array |#sort] -| `spaceless` | [entfernt Leerzeichen |#spaceless], ähnlich dem [spaceless |tags] tag -| `split` | [trennt eine Zeichenkette durch das angegebene Trennzeichen auf |#explode] -| `strip` | [Entfernt Leerzeichen |#spaceless] -| `stripHtml` | [entfernt HTML-Tags und konvertiert HTML-Entities in Text |#stripHtml] -| `substr` | [gibt einen Teil der Zeichenkette zurück |#substr] -| `trim` | [entfernt Leerzeichen aus der Zeichenkette |#trim] -| `translate` | [Übersetzung in andere Sprachen |#translate] -| `truncate` | [verkürzt die Länge unter Beibehaltung ganzer Wörter |#truncate] -| `webalize` | [passt die UTF-8-Zeichenfolge an die in der URL verwendete Forman |#webalize] +|## Transformation +| `batch` | [Auflistung linearer Daten in einer Tabelle |#batch] +| `breakLines` | [Fügt HTML-Zeilenumbrüche am Ende der Zeilen hinzu |#breakLines] +| `bytes` | [formatiert die Größe in Bytes |#bytes] +| `clamp` | [begrenzt einen Wert auf einen bestimmten Bereich |#clamp] +| `dataStream` | [Konvertierung für das Data URI-Protokoll |#datastream] +| `date` | [formatiert Datum und Uhrzeit |#date] +| `explode` | [teilt eine Zeichenkette in ein Array anhand eines Trennzeichens |#explode] +| `first` | [gibt das erste Element eines Arrays oder Zeichen einer Zeichenkette zurück |#first] +| `group` | [gruppiert Daten nach verschiedenen Kriterien |#group] +| `implode` | [verbindet ein Array zu einer Zeichenkette |#implode] +| `indent` | [rückt Text von links um eine bestimmte Anzahl von Tabulatoren ein |#indent] +| `join` | [verbindet ein Array zu einer Zeichenkette |#implode] +| `last` | [gibt das letzte Element eines Arrays oder Zeichen einer Zeichenkette zurück |#last] +| `length` | [gibt die Länge einer Zeichenkette in Zeichen oder eines Arrays zurück |#length] +| `localDate` | [formatiert Datum und Uhrzeit entsprechend den Ländereinstellungen |#localDate] +| `number` | [formatiert eine Zahl |#number] +| `padLeft` | [füllt eine Zeichenkette links auf eine bestimmte Länge auf |#padLeft] +| `padRight` | [füllt eine Zeichenkette rechts auf eine bestimmte Länge auf |#padRight] +| `random` | [gibt ein zufälliges Element eines Arrays oder Zeichen einer Zeichenkette zurück |#random] +| `repeat` | [Wiederholung einer Zeichenkette |#repeat] +| `replace` | [ersetzt Vorkommen einer gesuchten Zeichenkette |#replace] +| `replaceRE` | [ersetzt Vorkommen anhand eines regulären Ausdrucks |#replaceRE] +| `reverse` | [kehrt eine UTF-8 Zeichenkette oder ein Array um |#reverse] +| `slice` | [extrahiert einen Teil eines Arrays oder einer Zeichenkette |#slice] +| `sort` | [sortiert ein Array |#sort] +| `spaceless` | [entfernt Leerzeichen |#spaceless], ähnlich wie das [spaceless |tags] Tag +| `split` | [teilt eine Zeichenkette in ein Array anhand eines Trennzeichens |#explode] +| `strip` | [entfernt Leerzeichen |#spaceless] +| `stripHtml` | [entfernt HTML-Tags und konvertiert HTML-Entities in Zeichen |#stripHtml] +| `substr` | [gibt einen Teil einer Zeichenkette zurück |#substr] +| `trim` | [entfernt führende und abschließende Leerzeichen oder andere Zeichen |#trim] +| `translate` | [Übersetzung in andere Sprachen |#translate] +| `truncate` | [kürzt die Länge unter Beibehaltung von Wörtern |#truncate] +| `webalize` | [passt eine UTF-8 Zeichenkette in eine in URLs verwendete Form an |#webalize] .[table-latte-filters] -|## Buchstabenumbruch -| `capitalize` | [Kleinschreibung, der erste Buchstabe eines jeden Wortes wird großgeschrieben |#capitalize] -| `firstUpper` | [macht den ersten Buchstaben zu einem Großbuchstaben |#firstUpper] -| `lower` | [macht eine Zeichenfolge klein |#lower] -| `upper` | [macht eine Zeichenkette zu einem Großbuchstaben |#upper] +|## Groß-/Kleinschreibung +| `capitalize` | [Kleinbuchstaben, erste Buchstaben der Wörter groß |#capitalize] +| `firstUpper` | [konvertiert den ersten Buchstaben in einen Großbuchstaben |#firstUpper] +| `lower` | [konvertiert in Kleinbuchstaben |#lower] +| `upper` | [konvertiert in Großbuchstaben |#upper] .[table-latte-filters] -|## Rundung von Zahlen -| `ceil` | [rundet eine Zahl auf eine bestimmte Genauigkeit auf|#ceil] -| `floor` | [rundet eine Zahl auf eine bestimmte Genauigkeit ab |#floor] -| `round` | [rundet eine Zahl auf eine bestimmte Genauigkeit|#round] +|## Rundung +| `ceil` | [rundet eine Zahl auf eine bestimmte Genauigkeit auf |#ceil] +| `floor` | [rundet eine Zahl auf eine bestimmte Genauigkeit ab |#floor] +| `round` | [rundet eine Zahl auf eine bestimmte Genauigkeit |#round] .[table-latte-filters] |## Escaping -| `escapeUrl` | [gibt einen Parameter in der URL als Escapezeichen aus|#escapeUrl] -| `noescape` | [druckt eine Variable ohne Escaping |#noescape] -| `query` | [erzeugt eine Abfragezeichenfolge in der URL |#query] +| `escapeUrl` | [escapet einen Parameter in einer URL |#escapeUrl] +| `noescape` | [gibt eine Variable ohne Escaping aus |#noescape] +| `query` | [generiert einen Query-String in einer URL |#query] -Es gibt auch Escape-Filter für HTML (`escapeHtml` und `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) und iCalendar (`escapeICal`), die Latte dank [kontextsensitivem Escaping |safety-first#Context-aware escaping] selbst verwendet und die Sie nicht schreiben müssen. +Es gibt außerdem Escaping-Filter für HTML (`escapeHtml` und `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) und iCalendar (`escapeICal`), die Latte selbst dank [kontextsensitivem Escaping |safety-first#Context-aware escaping] verwendet und die Sie nicht explizit schreiben müssen. .[table-latte-filters] |## Sicherheit -| `checkUrl` | [säubert Zeichenketten für die Verwendung im href-Attribut |#checkUrl] -| `nocheck` | [verhindert automatische URL-Sanitisierung |#nocheck] +| `checkUrl` | [behandelt eine URL-Adresse gegen gefährliche Eingaben |#checkUrl] +| `nocheck` | [verhindert die automatische Behandlung einer URL-Adresse |#nocheck] -Latte der `src` und `href` Attribute [prüft automatisch |safety-first#link checking], so dass Sie den `checkUrl` Filter fast nicht verwenden müssen. +Latte [überprüft automatisch |safety-first#link checking] die Attribute `src` und `href`, sodass Sie den `checkUrl`-Filter fast nie verwenden müssen. .[note] -Alle eingebauten Filter arbeiten mit UTF-8 kodierten Zeichenketten. +Alle Standard-Filter sind für Zeichenketten in UTF-8-Kodierung ausgelegt. Verwendung .[#toc-usage] ======================== -Latte erlaubt den Aufruf von Filtern unter Verwendung der Pipe-Schreibweise (vorangestelltes Leerzeichen ist erlaubt): +Filter werden durch einen senkrechten Strich notiert (vor dem ein Leerzeichen stehen kann): ```latte

{$heading|upper}

``` -Filter können verkettet werden, in diesem Fall gelten sie in der Reihenfolge von links nach rechts: +Filter (in älteren Versionen Helper genannt) können verkettet werden und werden dann in der Reihenfolge von links nach rechts angewendet: ```latte

{$heading|lower|capitalize}

``` -Die Parameter werden durch Doppelpunkt oder Komma getrennt hinter den Filternamen gesetzt: +Parameter werden nach dem Filternamen durch Doppelpunkte oder Kommas getrennt angegeben: ```latte

{$heading|truncate:20,''}

``` -Filter können auf Ausdrücke angewendet werden: +Filter können auch auf Ausdrücke angewendet werden: ```latte {var $name = ($title|upper) . ($subtitle|lower)} @@ -108,7 +108,7 @@ $latte = new Latte\Engine; $latte->addFilter('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len)); ``` -Wir verwenden sie in einer Vorlage wie dieser: +Im Template wird es dann so aufgerufen: ```latte

{$text|shortify}

@@ -122,7 +122,7 @@ Filter .[#toc-filters] batch(int length, mixed item): array .[filter] ---------------------------------------------- -Filter, der die Auflistung von linearen Daten in Form einer Tabelle vereinfacht. Er gibt ein Array von Arrays mit der angegebenen Anzahl von Elementen zurück. Wenn Sie einen zweiten Parameter angeben, wird dieser verwendet, um fehlende Elemente in der letzten Zeile aufzufüllen. +Ein Filter, der die Ausgabe linearer Daten in Form einer Tabelle vereinfacht. Er gibt ein Array von Arrays mit der angegebenen Anzahl von Elementen zurück. Wenn Sie einen zweiten Parameter angeben, wird er verwendet, um fehlende Elemente in der letzten Zeile zu ergänzen. ```latte {var $items = ['a', 'b', 'c', 'd', 'e']} @@ -137,7 +137,7 @@ Filter, der die Auflistung von linearen Daten in Form einer Tabelle vereinfacht. ``` -Druckt: +Gibt aus: ```latte @@ -154,22 +154,22 @@ Druckt:
``` -Siehe auch [group |#group] und [iterateWhile-Tag |tags#iterateWhile]. +Siehe auch [#group] und das [iterateWhile |tags#iterateWhile] Tag. breakLines .[filter] -------------------- -Fügt HTML-Zeilenumbrüche vor allen Zeilenumbrüchen ein. +Fügt vor jedem Zeilenumbruchzeichen ein HTML-Tag `
` ein ```latte {var $s = "Text & with \n newline"} -{$s|breakLines} {* gibt "Text & with
\n newline" *} +{$s|breakLines} {* gibt "Text & with
\n newline" aus *} ``` bytes(int precision = 2) .[filter] ---------------------------------- -Formatiert die Größe in Bytes in eine für Menschen lesbare Form. Wenn das [Gebietsschema |develop#locale] festgelegt ist, werden die entsprechenden Dezimal- und Tausendertrennzeichen verwendet. +Formatiert die Größe in Bytes in eine menschenlesbare Form. Wenn [Ländereinstellungen |develop#locale] gesetzt sind, werden die entsprechenden Dezimal- und Tausendertrennzeichen verwendet. ```latte {$size|bytes} 0 B, 1.25 GB, … @@ -179,51 +179,51 @@ Formatiert die Größe in Bytes in eine für Menschen lesbare Form. Wenn das [Ge ceil(int precision = 0) .[filter] --------------------------------- -Rundet eine Zahl bis zu einer bestimmten Genauigkeit. +Rundet eine Zahl auf eine bestimmte Genauigkeit auf. ```latte -{=3.4|ceil} {* gibt 4 *} -{=135.22|ceil:1} {* gibt 135.3 *} -{=135.22|ceil:3} {* gibt 135.22 *} +{=3.4|ceil} {* gibt 4 aus *} +{=135.22|ceil:1} {* gibt 135.3 aus *} +{=135.22|ceil:3} {* gibt 135.22 aus *} ``` -Siehe auch [Stockwerk |#floor], [Runden |#round]. +Siehe auch [#floor], [#round]. capitalize .[filter] -------------------- -Gibt eine Version des Wertes in Großbuchstaben zurück. Die Wörter beginnen mit Großbuchstaben, alle übrigen Zeichen sind Kleinbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. +Wörter beginnen mit Großbuchstaben, alle verbleibenden Zeichen sind klein. Erfordert die PHP-Erweiterung `mbstring`. ```latte -{='i like LATTE'|capitalize} {* gibt 'I Like Latte' *} +{='i like LATTE'|capitalize} {* gibt 'I Like Latte' aus *} ``` -Siehe auch [firstUpper |#firstUpper], [lower |#lower], [upper |#upper]. +Siehe auch [#firstUpper], [#lower], [#upper]. checkUrl .[filter] ------------------ -Erzwingt URL-Sanitization. Sie prüft, ob die Variable eine Web-URL enthält (d. h. HTTP/HTTPS-Protokoll) und verhindert das Schreiben von Links, die ein Sicherheitsrisiko darstellen könnten. +Erzwingt die Behandlung einer URL-Adresse. Überprüft, ob die Variable eine Web-URL enthält (d.h. HTTP/HTTPS-Protokoll) und verhindert die Ausgabe von Links, die ein Sicherheitsrisiko darstellen können. ```latte {var $link = 'javascript:window.close()'} -checked -unchecked +geprüft +ungeprüft ``` -Druckt: +Gibt aus: ```latte -checked -unchecked +geprüft +ungeprüft ``` -Siehe auch [nocheck |#nocheck]. +Siehe auch [#nocheck]. clamp(int|float min, int|float max) .[filter] --------------------------------------------- -Gibt einen Wert zurück, der auf den einschließenden Bereich von min und max geklemmt ist. +Begrenzt einen Wert auf den angegebenen inklusiven Bereich von min und max. ```latte {$level|clamp: 0, 255} @@ -234,15 +234,15 @@ Existiert auch als [Funktion |functions#clamp]. dataStream(string mimetype = detect) .[filter] ---------------------------------------------- -Konvertiert den Inhalt in ein Daten-URI-Schema. Es kann verwendet werden, um Bilder in HTML oder CSS einzufügen, ohne dass externe Dateien verlinkt werden müssen. +Konvertiert den Inhalt in das Data URI-Schema. Damit können Bilder ohne die Notwendigkeit externer Dateien in HTML oder CSS eingebettet werden. -Nehmen wir an, ein Bild befindet sich in einer Variablen `$img = Image::fromFile('obrazek.gif')`, dann +Angenommen, wir haben ein Bild in der Variable `$img = Image::fromFile('bild.gif')`, dann ```latte ``` -Druckt zum Beispiel: +Gibt beispielsweise aus: ```latte {$name} ``` -Siehe auch [Abfrage |#query]. +Siehe auch [#query]. explode(string separator = '') .[filter] ---------------------------------------- -Teilt eine Zeichenkette durch den angegebenen Begrenzer und gibt ein Array von Zeichenketten zurück. Alias für `split`. +Teilt eine Zeichenkette anhand eines Trennzeichens in ein Array. Alias für `split`. ```latte -{='one,two,three'|explode:','} {* liefert ['one', 'two', 'three'] *} +{='one,two,three'|explode:','} {* gibt ['one', 'two', 'three'] zurück *} ``` Wenn das Trennzeichen eine leere Zeichenkette ist (Standardwert), wird die Eingabe in einzelne Zeichen aufgeteilt: ```latte -{='123'|explode} {* liefert ['1', '2', '3'] *} +{='123'|explode} {* gibt ['1', '2', '3'] zurück *} ``` Sie können auch den Alias `split` verwenden: ```latte -{='1,2,3'|split:','} {* liefert ['1', '2', '3'] *} +{='1,2,3'|split:','} {* gibt ['1', '2', '3'] zurück *} ``` -Siehe auch [implode |#implode]. +Siehe auch [#implode]. first .[filter] --------------- -Gibt das erste Element eines Arrays oder ein Zeichen einer Zeichenkette zurück: +Gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück: ```latte -{=[1, 2, 3, 4]|first} {* gibt 1 *} -{='abcd'|first} {* gibt 'a' *} +{=[1, 2, 3, 4]|first} {* gibt 1 aus *} +{='abcd'|first} {* gibt 'a' aus *} ``` -Siehe auch [last |#last], [random |#random]. +Siehe auch [#last], [#random]. floor(int precision = 0) .[filter] @@ -316,30 +316,30 @@ floor(int precision = 0) .[filter] Rundet eine Zahl auf eine bestimmte Genauigkeit ab. ```latte -{=3.5|floor} {* gibt 3 *} -{=135.79|floor:1} {* gibt 135.7 *} -{=135.79|floor:3} {* gibt 135.79 *} +{=3.5|floor} {* gibt 3 aus *} +{=135.79|floor:1} {* gibt 135.7 aus *} +{=135.79|floor:3} {* gibt 135.79 aus *} ``` -Siehe auch [ceil |#ceil], [round |#round]. +Siehe auch [#ceil], [#round]. firstUpper .[filter] -------------------- -Konvertiert den ersten Buchstaben eines Wertes in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. +Konvertiert den ersten Buchstaben in einen Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. ```latte -{='the latte'|firstUpper} {* gibt 'The latte' *} +{='the latte'|firstUpper} {* gibt 'The latte' aus *} ``` -Siehe auch [capitalize |#capitalize], [lower |#lower], [upper |#upper]. +Siehe auch [#capitalize], [#lower], [#upper]. group(string|int|\Closure by): array .[filter]{data-version:3.0.16} ------------------------------------------------------------------- -Der Filter gruppiert die Daten nach verschiedenen Kriterien. +Filter, der Daten nach verschiedenen Kriterien gruppiert. -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 [ausführliche Anleitung |cookbook/grouping]. +In diesem Beispiel werden die Tabellenzeilen 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 ($items|group: categoryId) as $categoryId => $categoryItems} @@ -351,28 +351,28 @@ In diesem Beispiel werden die Zeilen in der Tabelle nach der Spalte `categoryId` {/foreach} ``` -Siehe auch [Batch |#batch], die [Gruppenfunktion |functions#group] und das [iterateWhile-Tag |tags#iterateWhile]. +Siehe auch [#batch], die Funktion [group |functions#group] und das Tag [iterateWhile |tags#iterateWhile]. implode(string glue = '') .[filter] ----------------------------------- -Gibt eine Zeichenkette zurück, die die Verkettung der Zeichenketten im Array ist. Alias für `join`. +Gibt eine Zeichenkette zurück, die eine Verkettung der Elemente einer Sequenz ist. Alias für `join`. ```latte -{=[1, 2, 3]|implode} {* gibt '123' *} -{=[1, 2, 3]|implode:'|'} {* gibt '1|2|3' *} +{=[1, 2, 3]|implode} {* gibt '123' aus *} +{=[1, 2, 3]|implode:'|'} {* gibt '1|2|3' aus *} ``` -Sie können auch einen Alias `join` verwenden: +Sie können auch den Alias `join` verwenden: ```latte -{=[1, 2, 3]|join} {* gibt '123' *} +{=[1, 2, 3]|join} {* gibt '123' aus *} ``` indent(int level = 1, string char = "\t") .[filter] --------------------------------------------------- -Rückt einen Text von links um eine bestimmte Anzahl von Tabulatoren oder anderen Zeichen ein, die wir im zweiten optionalen Argument angeben. Leerzeilen werden nicht eingerückt. +Rückt Text von links um eine bestimmte Anzahl von Tabulatoren oder anderen Zeichen ein, die im zweiten Argument angegeben werden können. Leere Zeilen werden nicht eingerückt. ```latte
@@ -382,7 +382,7 @@ Rückt einen Text von links um eine bestimmte Anzahl von Tabulatoren oder andere
``` -Druckt: +Gibt aus: ```latte
@@ -393,24 +393,24 @@ Druckt: last .[filter] -------------- -Gibt das letzte Element eines Arrays oder ein Zeichen einer Zeichenkette zurück: +Gibt das letzte Element eines Arrays oder das letzte Zeichen einer Zeichenkette zurück: ```latte -{=[1, 2, 3, 4]|last} {* gibt 4 *} -{='abcd'|last} {* gibt 'd' *} +{=[1, 2, 3, 4]|last} {* gibt 4 aus *} +{='abcd'|last} {* gibt 'd' aus *} ``` -Siehe auch [first |#first], [random |#random]. +Siehe auch [#first], [#random]. length .[filter] ---------------- Gibt die Länge einer Zeichenkette oder eines Arrays zurück. -- bei Strings wird die Länge in UTF-8 Zeichen zurückgegeben -- für Arrays wird die Anzahl der Elemente zurückgegeben -- bei Objekten, die die Schnittstelle Countable implementieren, wird der Rückgabewert der Funktion count() verwendet -- für Objekte, die die Schnittstelle IteratorAggregate implementieren, wird der Rückgabewert von iterator_count() verwendet. +- für Zeichenketten gibt es die Länge in UTF-8-Zeichen zurück +- für Arrays gibt es die Anzahl der Elemente zurück +- für Objekte, die das Countable-Interface implementieren, verwendet es den Rückgabewert der count()-Methode +- für Objekte, die das IteratorAggregate-Interface implementieren, verwendet es den Rückgabewert der iterator_count()-Funktion ```latte @@ -422,28 +422,28 @@ Gibt die Länge einer Zeichenkette oder eines Arrays zurück. localDate(string format = null, string date = null, string time = null) .[filter] --------------------------------------------------------------------------------- -Formatiert Datum und Uhrzeit entsprechend dem [Gebietsschema |develop#locale], um eine konsistente und lokalisierte Anzeige von Zeitdaten in verschiedenen Sprachen und Regionen zu gewährleisten. Der Filter akzeptiert das Datum als UNIX-Zeitstempel, String oder `DateTimeInterface` Objekt. +Formatiert Datum und Uhrzeit gemäß den [Ländereinstellungen |develop#locale], was eine konsistente und lokalisierte Darstellung von Zeitangaben in verschiedenen Sprachen und Regionen gewährleistet. Der Filter akzeptiert ein Datum als UNIX-Timestamp, Zeichenkette oder Objekt vom Typ `DateTimeInterface`. ```latte -{$date|localDate} {* 15. dubna 2024 *} +{$date|localDate} {* 15. April 2024 *} {$date|format: yM} {* 4/2024 *} {$date|localDate: date: medium} {* 15. 4. 2024 *} ``` -Wenn Sie den Filter ohne Parameter verwenden, gibt er das Datum in der Langformatebene aus, wie weiter unten erläutert. +Wenn Sie den Filter ohne Parameter verwenden, wird das Datum auf der Ebene `long` ausgegeben, siehe unten. **a) Verwendung des Formats** -Der Parameter `format` beschreibt, welche Zeitkomponenten angezeigt werden sollen. Er verwendet Buchstabencodes, wobei die Anzahl der Wiederholungen die Breite der Ausgabe beeinflusst: +Der Parameter `format` beschreibt, welche Zeitkomponenten angezeigt werden sollen. Es verwendet Buchstabencodes dafür, deren Wiederholungsanzahl die Breite der Ausgabe beeinflusst: | Jahr | `y` / `yy` / `yyyy` | `2024` / `24` / `2024` | Monat | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `Aug` / `August` -| Tag | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `So` / `Sonntag` -| Stunde | `j` / `H` / `h` | bevorzugt / 24 Stunden / 12 Stunden -| Minute | `m` / `mm` | `5` / `05` (2-stellig, wenn mit Sekunden kombiniert) -| Sekunde | `s` / `ss` | `8` / `08` (2 Ziffern, wenn mit Minuten kombiniert) +| Tag | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `So` / `Sonntag` +| Stunde | `j` / `H` / `h` | bevorzugt / 24-Stunden / 12-Stunden +| Minute | `m` / `mm` | `5` / `05` (2 Ziffern in Kombination mit Sekunden) +| Sekunde | `s` / `ss` | `8` / `08` (2 Ziffern in Kombination mit Minuten) -Die Reihenfolge der Codes im Format spielt keine Rolle, da die Reihenfolge der Komponenten entsprechend den Konventionen des jeweiligen Gebietsschemas angezeigt wird. Daher ist das Format ortsunabhängig. Zum Beispiel gibt das Format `yyyyMMMMd` im Gebietsschema `en_US` `April 15, 2024` aus, während es im Gebietsschema `cs_CZ` `15. dubna 2024` ausgibt: +Die Reihenfolge der Codes im Format spielt keine Rolle, da die Reihenfolge der Komponenten gemäß den Konventionen der Ländereinstellungen ausgegeben wird. Das Format ist also unabhängig davon. Zum Beispiel wird das Format `yyyyMMMMd` in der Umgebung `en_US` als `April 15, 2024` ausgegeben, während es in der Umgebung `de_DE` als `15. April 2024` ausgegeben wird: | locale: | de-DE | en_US |--- @@ -456,9 +456,9 @@ Die Reihenfolge der Codes im Format spielt keine Rolle, da die Reihenfolge der K | `format: 'hm'` | 5:54 PM | 5:54 PM -**b) Verwendung voreingestellter Stile** +**b) Verwendung vordefinierter Stile** -Die Parameter `date` und `time` bestimmen den Detaillierungsgrad der Datums- und Zeitanzeige. Sie können aus mehreren Stufen wählen: `full`, `long`, `medium`, `short`. Sie können nur das Datum, nur die Uhrzeit oder beides anzeigen lassen: +Die Parameter `date` und `time` bestimmen, wie detailliert Datum und Uhrzeit ausgegeben werden sollen. Sie können aus mehreren Ebenen wählen: `full`, `long`, `medium`, `short`. Es ist möglich, nur das Datum, nur die Uhrzeit oder beides ausgeben zu lassen: | locale: | de-DE | en_US |--- @@ -473,52 +473,52 @@ Die Parameter `date` und `time` bestimmen den Detaillierungsgrad der Datums- und | `date: medium, time: short` | 23.01.1978, 08:30 | Jan 23, 1978, 8:30 AM | `date: long, time: short` | 23. Januar 1978 um 08:30 | January 23, 1978 at 8:30 AM -Für das Datum können Sie auch das Präfix `relative-` verwenden (z. B. `relative-short`), das für Daten, die kurz vor der Gegenwart liegen, `yesterday`, `today` oder `tomorrow` anzeigt; andernfalls erfolgt die Anzeige auf die übliche Weise. +Für das Datum können Sie außerdem das Präfix `relative-` verwenden (z.B. `relative-short`), das für Daten nahe der Gegenwart `gestern`, `heute` oder `morgen` anzeigt, andernfalls wird es auf die Standardweise ausgegeben. ```latte -{$date|localDate: date: relative-short} {* yesterday *} +{$date|localDate: date: relative-short} {* gestern *} ``` -Siehe auch [Datum |#date]. +Siehe auch [#date]. lower .[filter] --------------- -Konvertiert einen Wert in Kleinbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. +Konvertiert eine Zeichenkette in Kleinbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. ```latte -{='LATTE'|lower} {* gibt 'latte' *} +{='LATTE'|lower} {* gibt 'latte' aus *} ``` -Siehe auch [capitalize |#capitalize], [firstUpper |#firstUpper], [upper |#upper]. +Siehe auch [#capitalize], [#firstUpper], [#upper]. nocheck .[filter] ----------------- -Verhindert die automatische URL-Sanitization. Latte [prüft automatisch |safety-first#Link checking], ob die Variable eine Web-URL enthält (d.h. HTTP/HTTPS-Protokoll) und verhindert das Schreiben von Links, die ein Sicherheitsrisiko darstellen könnten. +Verhindert die automatische Behandlung einer URL-Adresse. Latte [überprüft automatisch |safety-first#Link checking], ob die Variable eine Web-URL enthält (d.h. HTTP/HTTPS-Protokoll) und verhindert die Ausgabe von Links, die ein Sicherheitsrisiko darstellen können. -Wenn der Link ein anderes Schema verwendet, z. B. `javascript:` oder `data:`, und Sie sich des Inhalts sicher sind, können Sie die Prüfung über `|nocheck` deaktivieren. +Wenn der Link ein anderes Schema verwendet, z.B. `javascript:` oder `data:`, und Sie sich seines Inhalts sicher sind, können Sie die Überprüfung mit `|nocheck` deaktivieren. ```latte {var $link = 'javascript:window.close()'} -checked -unchecked +geprüft +ungeprüft ``` -Drucke: +Gibt aus: ```latte -checked -unchecked +geprüft +ungeprüft ``` -Siehe auch [checkUrl |#checkUrl]. +Siehe auch [#checkUrl]. noescape .[filter] ------------------ -Deaktiviert das automatische Escaping. +Deaktiviert automatisches Escaping. ```latte {var $trustedHtmlString = 'hello'} @@ -526,7 +526,7 @@ Escaped: {$trustedHtmlString} Unescaped: {$trustedHtmlString|noescape} ``` -Druckt: +Gibt aus: ```latte Escaped: <b>hello</b> @@ -534,33 +534,33 @@ Unescaped: hello ``` .[warning] -Die missbräuchliche Verwendung des `noescape` Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn nur, wenn Sie **absolut sicher** sind, was Sie tun und dass die Zeichenfolge, die Sie drucken, aus einer vertrauenswürdigen Quelle stammt. +Falsche Verwendung des `noescape`-Filters kann zu XSS-Schwachstellen führen! Verwenden Sie ihn niemals, wenn Sie nicht **absolut sicher** sind, was Sie tun, und dass die ausgegebene Zeichenkette aus einer vertrauenswürdigen Quelle stammt. number(int decimals = 0, string decPoint = '.', string thousandsSep = ',') .[filter] ------------------------------------------------------------------------------------ -Formatiert eine Zahl mit einer bestimmten Anzahl von Dezimalstellen. Wenn das [Gebietsschema |develop#locale] festgelegt ist, werden die entsprechenden Dezimal- und Tausendertrennzeichen verwendet. +Formatiert eine Zahl auf eine bestimmte Anzahl von Dezimalstellen. Wenn [Ländereinstellungen |develop#locale] gesetzt sind, werden die entsprechenden Dezimal- und Tausendertrennzeichen verwendet. ```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 +{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] ------------------------------- -Mit dem Parameter `format` können Sie das Aussehen von Zahlen genau nach Ihren Bedürfnissen festlegen. Er erfordert ein festgelegtes [Gebietsschema |develop#locale]. Das Format besteht aus mehreren Sonderzeichen, deren vollständige Beschreibung in der Dokumentation "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns zu finden ist: +Der Parameter `format` ermöglicht es Ihnen, das Aussehen von Zahlen genau nach Ihren Bedürfnissen zu definieren. Dafür müssen [Ländereinstellungen |develop#locale] gesetzt sein. Das Format besteht aus mehreren speziellen Zeichen, deren vollständige Beschreibung Sie in der Dokumentation "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns finden: -- obligatorische Ziffer, wird immer angezeigt, auch wenn sie Null ist -- `#` optionale Ziffer, wird nur angezeigt, wenn die Zahl eine Ziffer an dieser Stelle hat -- `@` signifikante Ziffer, hilft bei der Anzeige der Zahl mit einer bestimmten Anzahl signifikanter Ziffern -- `.` markiert die Stelle, an der das Dezimaltrennzeichen stehen soll (Komma oder Punkt, je nach Gebietsschema) -- `,` wird verwendet, um Gruppen von Ziffern zu trennen, normalerweise Tausender +- `0` obligatorische Ziffer, wird immer angezeigt, auch wenn es eine Null ist +- `#` optionale Ziffer, wird nur angezeigt, wenn an dieser Stelle tatsächlich eine Zahl steht +- `@` signifikante Ziffer, hilft, eine Zahl mit einer bestimmten Anzahl gültiger Ziffern anzuzeigen +- `.` kennzeichnet, wo das Dezimalkomma (oder -punkt, je nach Land) sein soll +- `,` dient zur Trennung von Zifferngruppen, meist Tausender - `%` multipliziert die Zahl mit 100 und fügt das Prozentzeichen hinzu -Schauen wir uns einige Beispiele an. Im ersten Beispiel sind zwei Dezimalstellen obligatorisch, im zweiten sind sie optional. Das dritte Beispiel zeigt Auffüllungen mit Nullen auf beiden Seiten, und das vierte Beispiel zeigt nur die vorhandenen Ziffern an: +Schauen wir uns einige Beispiele an. Im ersten Beispiel sind zwei Dezimalstellen obligatorisch, im zweiten optional. Das dritte Beispiel zeigt das Auffüllen mit Nullen links und rechts, das vierte zeigt nur existierende Ziffern: ```latte {1234.5|number: '#,##0.00'} {* 1,234.50 *} @@ -569,7 +569,7 @@ Schauen wir uns einige Beispiele an. Im ersten Beispiel sind zwei Dezimalstellen {1.2 |number: '##.##'} {* 1.2 *} ``` -Signifikante Ziffern legen fest, wie viele Ziffern, unabhängig vom Dezimalpunkt, angezeigt werden sollen, wobei die Zahl gegebenenfalls gerundet wird: +Signifikante Ziffern bestimmen, wie viele Ziffern unabhängig vom Dezimalpunkt angezeigt werden sollen, wobei gerundet wird: ```latte {1234|number: '@@'} {* 1200 *} @@ -579,13 +579,13 @@ Signifikante Ziffern legen fest, wie viele Ziffern, unabhängig vom Dezimalpunkt {0.00123|number: '@@'} {* 0.0012 *} ``` -Eine einfache Möglichkeit, eine Zahl als Prozentsatz anzuzeigen. Die Zahl wird mit 100 multipliziert und das Zeichen `%` wird hinzugefügt: +Ein einfacher Weg, eine Zahl als Prozentsatz anzuzeigen. Die Zahl wird mit 100 multipliziert und das `%`-Zeichen wird hinzugefügt: ```latte {0.1234|number: '#.##%'} {* 12.34% *} ``` -Wir können ein unterschiedliches Format für positive und negative Zahlen definieren, die durch ein `;` Zeichen getrennt sind. Auf diese Weise können z. B. positive Zahlen mit einem `+` -Zeichen angezeigt werden: +Wir können unterschiedliche Formate für positive und negative Zahlen definieren, getrennt durch ein `;`-Zeichen. Auf diese Weise können wir zum Beispiel festlegen, dass positive Zahlen mit einem `+`-Zeichen angezeigt werden sollen: ```latte {42|number: '#.##;(#.##)'} {* 42 *} @@ -594,140 +594,140 @@ Wir können ein unterschiedliches Format für positive und negative Zahlen defin {-42|number: '+#.##;-#.##'} {* -42 *} ``` -Denken Sie daran, dass das tatsächliche Aussehen von Zahlen je nach den Einstellungen des Gebietsschemas variieren kann. In einigen Ländern wird zum Beispiel ein Komma anstelle eines Punktes als Dezimaltrennzeichen verwendet. Dieser Filter berücksichtigt dies automatisch, so dass Sie sich darüber keine Gedanken machen müssen. +Beachten Sie, dass das tatsächliche Aussehen der Zahlen je nach den Ländereinstellungen variieren kann. In einigen Ländern wird beispielsweise ein Komma statt eines Punkts als Dezimaltrennzeichen verwendet. Dieser Filter berücksichtigt dies automatisch, und Sie müssen sich um nichts kümmern. padLeft(int length, string pad = ' ') .[filter] ----------------------------------------------- -Füllt eine Zeichenkette bis zu einer bestimmten Länge mit einer anderen Zeichenkette von links auf. +Füllt eine Zeichenkette auf eine bestimmte Länge mit einer anderen Zeichenkette von links auf. ```latte -{='hello'|padLeft: 10, '123'} {* gibt '12312hello' *} +{='hello'|padLeft: 10, '123'} {* gibt '12312hello' aus *} ``` padRight(int length, string pad = ' ') .[filter] ------------------------------------------------ -Füllt eine Zeichenfolge auf eine bestimmte Länge mit einer anderen Zeichenfolge von rechts. +Füllt eine Zeichenkette auf eine bestimmte Länge mit einer anderen Zeichenkette von rechts auf. ```latte -{='hello'|padRight: 10, '123'} {* gibt 'hello12312' *} +{='hello'|padRight: 10, '123'} {* gibt 'hello12312' aus *} ``` -query .[filter] ----------------- -Erzeugt dynamisch eine Abfragezeichenfolge in der URL: +query .[filter] +--------------- +Generiert dynamisch einen Query-String in einer URL: ```latte -click -search +klicken +suchen ``` -Druckt: +Gibt aus: ```latte -click -search +klicken +suchen ``` -Tasten mit einem Wert von `null` werden ausgelassen. +Schlüssel mit dem Wert `null` werden weggelassen. -Siehe auch [escapeUrl |#escapeUrl]. +Siehe auch [#escapeUrl]. random .[filter] ---------------- -Gibt ein zufälliges Element eines Arrays oder ein Zeichen einer Zeichenkette zurück: +Gibt ein zufälliges Element eines Arrays oder ein zufälliges Zeichen einer Zeichenkette zurück: ```latte -{=[1, 2, 3, 4]|random} {* example output: 3 *} -{='abcd'|random} {* example output: 'b' *} +{=[1, 2, 3, 4]|random} {* gibt z.B.: 3 aus *} +{='abcd'|random} {* gibt z.B.: 'b' aus *} ``` -Siehe auch [first |#first], [last |#last]. +Siehe auch [#first], [#last]. repeat(int count) .[filter] --------------------------- -Wiederholt die Zeichenkette x-mal. +Wiederholt eine Zeichenkette x-mal. ```latte -{='hello'|repeat: 3} {* gibt 'hellohellohello' *} +{='hello'|repeat: 3} {* gibt 'hellohellohello' aus *} ``` replace(string|array search, string replace = '') .[filter] ----------------------------------------------------------- -Ersetzt alle Vorkommen der Suchzeichenfolge durch die Ersatzzeichenfolge. +Ersetzt alle Vorkommen der Suchzeichenkette durch die Ersatzzeichenkette. ```latte -{='hello world'|replace: 'world', 'friend'} {* gibt 'hello friend' *} +{='hello world'|replace: 'world', 'friend'} {* gibt 'hello friend' aus *} ``` -Es können mehrere Ersetzungen auf einmal vorgenommen werden: +Es können auch mehrere Ersetzungen auf einmal durchgeführt werden: ```latte -{='hello world'|replace: [h => l, l => h]} {* gibt 'lehho worhd' *} +{='hello world'|replace: [h => l, l => h]} {* gibt 'lehho worhd' aus *} ``` replaceRE(string pattern, string replace = '') .[filter] -------------------------------------------------------- -Ersetzt alle Vorkommen entsprechend dem regulären Ausdruck. +Führt eine Suche und Ersetzung mit regulären Ausdrücken durch. ```latte -{='hello world'|replaceRE: '/l.*/', 'l'} {* gibt 'hel' *} +{='hello world'|replaceRE: '/l.*/', 'l'} {* gibt 'hel' aus *} ``` reverse .[filter] ----------------- -Kehrt eine gegebene Zeichenkette oder ein gegebenes Array um. +Kehrt die gegebene Zeichenkette oder das Array um. ```latte {var $s = 'Nette'} -{$s|reverse} {* gibt 'etteN' *} +{$s|reverse} {* gibt 'etteN' aus *} {var $a = ['N', 'e', 't', 't', 'e']} -{$a|reverse} {* liefert ['e', 't', 't', 'e', 'N'] *} +{$a|reverse} {* gibt ['e', 't', 't', 'e', 'N'] zurück *} ``` round(int precision = 0) .[filter] ---------------------------------- -Rundet eine Zahl auf eine bestimmte Genauigkeit. +Rundet eine Zahl auf die angegebene Genauigkeit. ```latte -{=3.4|round} {* gibt 3 *} -{=3.5|round} {* gibt 4 *} -{=135.79|round:1} {* gibt 135.8 *} -{=135.79|round:3} {* gibt 135.79 *} +{=3.4|round} {* gibt 3 aus *} +{=3.5|round} {* gibt 4 aus *} +{=135.79|round:1} {* gibt 135.8 aus *} +{=135.79|round:3} {* gibt 135.79 aus *} ``` -Siehe auch [ceil |#ceil], [floor |#floor]. +Siehe auch [#ceil], [#floor]. slice(int start, int length = null, bool preserveKeys = false) .[filter] ------------------------------------------------------------------------ -Extrahiert einen Ausschnitt aus einem Array oder einer Zeichenkette. +Extrahiert einen Teil eines Arrays oder einer Zeichenkette. ```latte -{='hello'|slice: 1, 2} {* gibt 'el' *} -{=['a', 'b', 'c']|slice: 1, 2} {* gibt ['b', 'c'] *} +{='hello'|slice: 1, 2} {* gibt 'el' aus *} +{=['a', 'b', 'c']|slice: 1, 2} {* gibt ['b', 'c'] aus *} ``` -Der Slice-Filter funktioniert wie die PHP-Funktion `array_slice` für Arrays und `mb_substr` für Strings mit einem Fallback auf `iconv_substr` im UTF-8-Modus. +Der Filter funktioniert wie die PHP-Funktion `array_slice` für Arrays oder `mb_substr` für Zeichenketten mit Fallback auf die Funktion `iconv_substr` im UTF-8-Modus. -Wenn start nicht negativ ist, beginnt die Sequenz an diesem Anfang in der Variablen. Wenn start negativ ist, beginnt die Sequenz so weit vom Ende der Variablen entfernt. +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 diese Anzahl vom Ende verschoben. -Wenn length angegeben wird und positiv ist, wird die Sequenz bis zu dieser Anzahl von Elementen enthalten. Wenn die Variable kürzer als die Länge ist, werden nur die verfügbaren Elemente der Variablen angezeigt. Wenn length angegeben wird und negativ ist, endet die Sequenz so viele Elemente vor dem Ende der Variablen. Wird sie weggelassen, enthält die Sequenz alle Elemente vom Offset bis zum Ende der Variablen. +Wenn der Parameter length angegeben und positiv ist, enthält die Sequenz so viele Elemente. Wenn ein negativer length-Parameter an diese Funktion übergeben wird, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend an der Position start und endend an der Position, die um length Elemente vom Ende des Arrays entfernt ist. Wenn Sie diesen Parameter weglassen, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend an der Position start. -Filter ordnet die Schlüssel des Integer-Arrays standardmäßig neu an und setzt sie zurück. Dieses Verhalten kann geändert werden, indem preserveKeys auf true gesetzt wird. String-Schlüssel werden immer beibehalten, unabhängig von diesem Parameter. +Standardmäßig ändert der Filter die Reihenfolge und setzt die ganzzahligen Schlüssel des Arrays zurück. Dieses Verhalten kann geändert werden, indem preserveKeys auf true gesetzt wird. String-Schlüssel werden immer beibehalten, unabhängig von diesem Parameter. sort(?Closure comparison, string|int|\Closure|null by=null, string|int|\Closure|bool byKey=false) .[filter] ----------------------------------------------------------------------------------------------------------- -Der Filter sortiert Elemente eines Arrays oder Iterators unter Beibehaltung ihrer assoziativen Schlüssel. Wenn ein [Gebietsschema |develop#locale] festgelegt ist, folgt die Sortierung dessen Regeln, es sei denn, eine benutzerdefinierte Vergleichsfunktion ist angegeben. +Der Filter sortiert die Elemente eines Arrays oder Iterators und behält ihre assoziativen Schlüssel bei. Bei gesetzten [Ländereinstellungen |develop#locale] folgt die Sortierung deren Regeln, wenn keine eigene Vergleichsfunktion angegeben ist. ```latte {foreach ($names|sort) as $name} @@ -735,7 +735,7 @@ Der Filter sortiert Elemente eines Arrays oder Iterators unter Beibehaltung ihre {/foreach} ``` -Array in umgekehrter Reihenfolge sortiert. +Sortiertes Array in umgekehrter Reihenfolge: ```latte {foreach ($names|sort|reverse) as $name} @@ -743,13 +743,13 @@ Array in umgekehrter Reihenfolge sortiert. {/foreach} ``` -Sie können eine benutzerdefinierte Vergleichsfunktion für die Sortierung angeben (das Beispiel zeigt, wie Sie die Sortierung von der größten zur kleinsten umkehren können): +Sie können eine eigene Vergleichsfunktion für die Sortierung angeben (das Beispiel zeigt, wie die Sortierung von größter zu kleinster umgekehrt wird): ```latte {var $reverted = ($names|sort: fn($a, $b) => $b <=> $a)} ``` -Mit dem Filter `|sort` können Sie auch Elemente nach Schlüssel sortieren: +Der Filter `|sort` ermöglicht auch die Sortierung von Elementen nach Schlüsseln: ```latte {foreach ($names|sort: byKey: true) as $name} @@ -757,7 +757,7 @@ Mit dem Filter `|sort` können Sie auch Elemente nach Schlüssel sortieren: {/foreach} ``` -Wenn Sie eine Tabelle nach einer bestimmten Spalte sortieren müssen, können Sie den Parameter `by` verwenden. Der Wert `'name'` im Beispiel gibt an, dass die Sortierung nach `$row->name` oder `$row['name']`erfolgt, je nachdem, ob `$row` ein Array oder ein Objekt ist: +Wenn Sie eine Tabelle nach einer bestimmten Spalte sortieren müssen, können Sie den Parameter `by` verwenden. Der Wert `'name'` im Beispiel gibt an, dass nach `$item->name` oder `$item['name']` sortiert wird, je nachdem, ob `$item` ein Array oder ein Objekt ist: ```latte {foreach ($items|sort: by: 'name') as $item} @@ -765,7 +765,7 @@ Wenn Sie eine Tabelle nach einer bestimmten Spalte sortieren müssen, können Si {/foreach} ``` -Sie können auch eine Callback-Funktion definieren, die den Wert bestimmt, nach dem sortiert wird: +Sie können auch eine Callback-Funktion definieren, die den Wert bestimmt, nach dem sortiert werden soll: ```latte {foreach ($items|sort: by: fn($items) => $items->category->name) as $item} @@ -773,12 +773,12 @@ Sie können auch eine Callback-Funktion definieren, die den Wert bestimmt, nach {/foreach} ``` -Der Parameter `byKey` kann auf dieselbe Weise verwendet werden. +Der Parameter `byKey` kann auf die gleiche Weise verwendet werden. -spaceless .[filter] --------------------- -Entfernt unnötige Leerzeichen aus der Ausgabe. Sie können auch den Alias `strip` verwenden. +spaceless .[filter] +------------------- +Entfernt überflüssige Leerzeichen aus der Ausgabe. Sie können auch den Alias `strip` verwenden. ```latte {block |spaceless} @@ -788,7 +788,7 @@ Entfernt unnötige Leerzeichen aus der Ausgabe. Sie können auch den Alias `stri {/block} ``` -Druckt: +Gibt aus: ```latte
  • Hello
@@ -797,18 +797,18 @@ Druckt: stripHtml .[filter] ------------------- -Konvertiert HTML in einfachen Text. Das heißt, es werden HTML-Tags entfernt und HTML-Elemente in Text umgewandelt. +Konvertiert HTML in reinen Text. Das heißt, es entfernt HTML-Tags und konvertiert HTML-Entities in Text. ```latte -{='

one < two

'|stripHtml} {* gibt 'one < two' *} +{='

one < two

'|stripHtml} {* gibt 'one < two' aus *} ``` -Der resultierende reine Text kann natürlich Zeichen enthalten, die HTML-Tags darstellen, zum Beispiel wird `'<p>'|stripHtml` in `

`. Geben Sie den resultierenden Text niemals mit `|noescape` aus, da dies zu einer Sicherheitslücke führen kann. +Der resultierende reine Text kann natürlich Zeichen enthalten, die HTML-Tags darstellen, zum Beispiel wird `'<p>'|stripHtml` zu `

` konvertiert. Geben Sie den so erzeugten Text auf keinen Fall mit `|noescape` aus, da dies zu einer Sicherheitslücke führen kann. substr(int offset, int length = null) .[filter] ----------------------------------------------- -Extrahiert einen Ausschnitt aus einer Zeichenkette. Dieser Filter wurde durch einen [Slice-Filter |#slice] ersetzt. +Extrahiert einen Teil einer Zeichenkette. Dieser Filter wurde durch den Filter [#slice] ersetzt. ```latte {$string|substr: 1, 2} @@ -817,57 +817,57 @@ Extrahiert einen Ausschnitt aus einer Zeichenkette. Dieser Filter wurde durch ei translate(string message, ...args) .[filter] -------------------------------------------- -Er übersetzt Ausdrücke in andere Sprachen. Um den Filter verfügbar zu machen, müssen Sie den [Übersetzer ein richten|develop#TranslatorExtension]. Sie können auch die [Tags für die Übersetzung |tags#Translation] verwenden. +Übersetzt Ausdrücke in andere Sprachen. Damit der Filter verfügbar ist, muss ein [Übersetzer eingerichtet |develop#TranslatorExtension] sein. Sie können auch [Tags für Übersetzungen |tags#Translation] verwenden. ```latte -{='Baskter'|translate} +{='Cart'|translate} {$item|translate} ``` trim(string charlist = " \t\n\r\0\x0B\u{A0}") .[filter] ------------------------------------------------------- -Entfernen Sie führende und nachgestellte Zeichen, standardmäßig Leerzeichen. +Entfernt Leerzeichen (oder andere Zeichen) vom Anfang und Ende einer Zeichenkette. ```latte -{=' I like Latte. '|trim} {* gibt 'I like Latte.' *} -{=' I like Latte.'|trim: '.'} {* gibt ' I like Latte' *} +{=' I like Latte. '|trim} {* gibt 'I like Latte.' aus *} +{=' I like Latte.'|trim: '.'} {* gibt ' I like Latte' aus *} ``` truncate(int length, string append = '…') .[filter] --------------------------------------------------- -Kürzt eine Zeichenkette auf die maximal angegebene Länge, versucht aber, ganze Wörter zu erhalten. Wenn die Zeichenkette abgeschnitten ist, wird am Ende ein Auslassungszeichen hinzugefügt (dies kann durch den zweiten Parameter geändert werden). +Kürzt eine Zeichenkette auf die angegebene maximale Länge, wobei versucht wird, ganze Wörter zu erhalten. Wenn die Zeichenkette gekürzt wird, wird am Ende ein Auslassungszeichen hinzugefügt (kann mit dem zweiten Parameter geändert werden). ```latte {var $title = 'Hello, how are you?'} -{$title|truncate:5} {* Hell… *} -{$title|truncate:17} {* Hello, how are… *} -{$title|truncate:30} {* Hello, how are you? *} +{$title|truncate:5} {* Hell… *} +{$title|truncate:17} {* Hello, how are… *} +{$title|truncate:30} {* Hello, how are you? *} ``` upper .[filter] --------------- -Konvertiert einen Wert in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. +Konvertiert eine Zeichenkette in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`. ```latte -{='latte'|upper} {* gibt 'LATTE' *} +{='latte'|upper} {* gibt 'LATTE' aus *} ``` -Siehe auch [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower]. +Siehe auch [#capitalize], [#firstUpper], [#lower]. webalize .[filter] ------------------ -Konvertiert nach ASCII. +Konvertiert eine UTF-8-Zeichenkette in die in URLs verwendete Form. -Konvertiert Leerzeichen in Bindestriche. Entfernt Zeichen, die keine alphanumerischen Zeichen, Unterstriche oder Bindestriche sind. Konvertiert in Kleinbuchstaben. Entfernt auch führende und nachfolgende Leerzeichen. +Es wird in ASCII konvertiert. Konvertiert Leerzeichen in Bindestriche. Entfernt Zeichen, die nicht alphanumerisch, Unterstriche oder Bindestriche sind. Konvertiert in Kleinbuchstaben. Entfernt auch führende und abschließende Leerzeichen. ```latte -{var $s = 'Our 10. product'} -{$s|webalize} {* gibt 'our-10-product' *} +{var $s = 'Unser 10. Produkt'} +{$s|webalize} {* gibt 'unser-10-produkt' aus *} ``` .[caution] -Erfordert das Paket [nette/utils |utils:]. +Erfordert die Bibliothek [nette/utils |utils:]. diff --git a/latte/de/tags.texy b/latte/de/tags.texy index a6e13ee626..0fbefed3f3 100644 --- a/latte/de/tags.texy +++ b/latte/de/tags.texy @@ -2,167 +2,167 @@ Latte Tags ********** .[perex] -Zusammenfassung und Beschreibung aller in Latte integrierten Tags. +Eine Übersicht und Beschreibung aller Latte-Template-System-Tags, die standardmäßig zur Verfügung stehen. .[table-latte-tags language-latte] -|## Drucken -| `{$var}`, `{...}` oder `{=...}` | [druckt eine Variable oder einen Ausdruck mit Escapezeichen |#printing] -| `{$var\|filter}` | [druckt mit Filtern |#filters] -| `{l}` oder `{r}` | druckt `{` or `}` Zeichen +|## Ausgabe +| `{$var}`, `{...}` oder `{=...}` | [gibt eine escaped Variable oder einen Ausdruck aus|#Ausgabe] +| `{$var\|filter}` | [gibt mit Verwendung von Filtern aus|#Filter] +| `{l}` oder `{r}` | gibt das Zeichen `{` oder `}` aus .[table-latte-tags language-latte] |## Bedingungen -| `{if}`... `{elseif}`... `{else}`... `{/if}` | [Bedingung if |#if-elseif-else] -| `{ifset}`... `{elseifset}`... `{/ifset}` | [Bedingung ifset |#ifset-elseifset] -| `{ifchanged}`... `{/ifchanged}` | [Test, ob eine Änderung stattgefunden hat |#ifchanged] -| `{switch}` `{case}` `{default}` `{/switch}` | [Bedingung switch |#switch-case-default] -| `n:else` | [alternative Inhalte für Bedingungen |#n:else] +| `{if}` … `{elseif}` … `{else}` … `{/if}` | [if-Bedingung|#if-elseif-else] +| `{ifset}` … `{elseifset}` … `{/ifset}` | [ifset-Bedingung|#ifset-elseifset] +| `{ifchanged}` … `{/ifchanged}` | [Test, ob eine Änderung aufgetreten ist|#ifchanged] +| `{switch}` `{case}` `{default}` `{/switch}` | [switch-Bedingung|#switch-case-default] +| `n:else` | [alternativer Inhalt für Bedingungen|#n:else] .[table-latte-tags language-latte] |## Schleifen -| `{foreach}`... `{/foreach}` | [foreach |#foreach] -| `{for}`... `{/for}` | [for |#for] -| `{while}`... `{/while}` | [while |#while] -| `{continueIf $cond}` | [weiter zur nächsten Iteration |#continueif-skipif-breakif] -| `{skipIf $cond}` | [überspringt die aktuelle Schleifeniteration |#continueif-skipif-breakif] -| `{breakIf $cond}` | [bricht Schleife ab |#continueif-skipif-breakif] -| `{exitIf $cond}` | [vorzeitiges Beenden |#exitif] -| `{first}`... `{/first}` | [ist dies die erste Iteration? |#first-last-sep] -| `{last}`... `{/last}` | [ist es die letzte Iteration? |#first-last-sep] -| `{sep}`... `{/sep}` | [wird die nächste Iteration folgen? |#first-last-sep] -| `{iterateWhile}`... `{/iterateWhile}` | [strukturiert foreach |#iterateWhile] -| `$iterator` | [Spezielle Variable innerhalb der foreach-Schleife |#$iterator] +| `{foreach}` … `{/foreach}` | [#foreach] +| `{for}` … `{/for}` | [#for] +| `{while}` … `{/while}` | [#while] +| `{continueIf $cond}` | [mit der nächsten Iteration fortfahren|#continueif-skipif-breakif] +| `{skipIf $cond}` | [Iteration überspringen|#continueif-skipif-breakif] +| `{breakIf $cond}` | [Schleife abbrechen|#continueif-skipif-breakif] +| `{exitIf $cond}` | [vorzeitige Beendigung|#exitif] +| `{first}` … `{/first}` | [ist es der erste Durchlauf?|#first-last-sep] +| `{last}` … `{/last}` | [ist es der letzte Durchlauf?|#first-last-sep] +| `{sep}` … `{/sep}` | [wird noch ein Durchlauf folgen?|#first-last-sep] +| `{iterateWhile}` … `{/iterateWhile}` | [strukturiertes foreach|#iterateWhile] +| `$iterator` | [spezielle Variable innerhalb von foreach|#$iterator] .[table-latte-tags language-latte] -|## Einbindung anderer Vorlagen -| `{include 'file.latte'}` | [schließt eine Vorlage aus einer anderen Datei ein |#include] -| `{sandbox 'file.latte'}` | [Einfügen einer Vorlage im Sandbox-Modus |#sandbox] +|## Einbindung weiterer Templates +| `{include 'file.latte'}` | [lädt ein Template aus einer anderen Datei|#include] +| `{sandbox 'file.latte'}` | [lädt ein Template im Sandbox-Modus|#sandbox] .[table-latte-tags language-latte] -|## Blöcke, Layouts, Vererbung von Vorlagen -| `{block}` | [anonymer Block |#block] -| `{block blockname}` | [Blockdefinition |template-inheritance#blocks] -| `{define blockname}` | [Blockdefinition für zukünftige Verwendung |template-inheritance#definitions] -| `{include blockname}` | [druckt Block |template-inheritance#printing-blocks] -| `{include blockname from 'file.latte'}` | [druckt einen Block aus einer Datei |template-inheritance#printing-blocks] -| `{import 'file.latte'}` | [lädt Blöcke aus einer anderen Vorlage |template-inheritance#horizontal-reuse] -| `{layout 'file.latte'}` / `{extends}` | [gibt eine Layout-Datei an |template-inheritance#layout-inheritance] -| `{embed}`... `{/embed}` | [lädt die Vorlage oder den Block und ermöglicht das Überschreiben der Blöcke |template-inheritance#unit-inheritance] -| `{ifset blockname}`... `{/ifset}` | [Bedingung, wenn Block definiert ist |template-inheritance#checking-block-existence] +|## Blöcke, Layouts, Template-Vererbung +| `{block}` | [anonymer Block|#block] +| `{block blockname}` | [definiert einen Block|template-inheritance#blocks] +| `{define blockname}` | [definiert einen Block zur späteren Verwendung|template-inheritance#definitions] +| `{include blockname}` | [Darstellung eines Blocks|template-inheritance#printing-blocks] +| `{include blockname from 'file.latte'}` | [stellt einen Block aus einer Datei dar|template-inheritance#printing-blocks] +| `{import 'file.latte'}` | [lädt Blöcke aus einem Template|template-inheritance#horizontal-reuse] +| `{layout 'file.latte'}` / `{extends}` | [bestimmt die Layout-Datei|template-inheritance#layout-inheritance] +| `{embed}` … `{/embed}` | [lädt ein Template oder einen Block und ermöglicht das Überschreiben von Blöcken|template-inheritance#unit-inheritance] +| `{ifset blockname}` … `{/ifset}` | [Bedingung, ob ein Block existiert|template-inheritance#checking-block-existence] .[table-latte-tags language-latte] |## Ausnahmebehandlung -| `{try}`... `{else}`... `{/try}` | [Abfangen von Ausnahmen |#try] -| `{rollback}` | [verwirft try-Block |#rollback] +| `{try}` … `{else}` … `{/try}` | [Abfangen von Ausnahmen|#try] +| `{rollback}` | [Verwerfen eines try-Blocks|#rollback] .[table-latte-tags language-latte] |## Variablen -| `{var $foo = value}` | [Erstellung von Variablen |#var-default] -| `{default $foo = value}` | [Standardwert, wenn Variable nicht deklariert ist |#var-default] -| `{parameters}` | [deklariert Variablen, gibt einen Standardwert ein |#parameters] -| `{capture}`... `{/capture}` | [erfasst einen Abschnitt in einer Variablen |#capture] +| `{var $foo = value}` | [erstellt eine Variable|#var-default] +| `{default $foo = value}` | [erstellt eine Variable, wenn sie nicht existiert|#var-default] +| `{parameters}` | [deklariert Variablen, Typen und Standardwerte|#parameters] +| `{capture}` … `{/capture}` | [erfasst einen Block in eine Variable|#capture] .[table-latte-tags language-latte] |## Typen -| `{varType}` | [deklariert den Typ einer Variablen |type-system#varType] -| `{varPrint}` | [schlägt Variablentypen vor |type-system#varPrint] -| `{templateType}` | [deklariert Variablentypen mittels Klasse |type-system#templateType] -| `{templatePrint}` | [erzeugt Klasse mit Eigenschaften |type-system#templatePrint] +| `{varType}` | [deklariert den Typ einer Variable|type-system#varType] +| `{varPrint}` | [schlägt Typen für Variablen vor|type-system#varPrint] +| `{templateType}` | [deklariert Variablentypen basierend auf einer Klasse|type-system#templateType] +| `{templatePrint}` | [schlägt eine Klasse mit Variablentypen vor|type-system#templatePrint] .[table-latte-tags language-latte] -|## Übersetzung -| `{_string}` | [druckt übersetzt |#Translation] -| `{translate}`... `{/translate}` | [übersetzt den Inhalt |#Translation] +|## Übersetzungen +| `{_...}` | [gibt eine Übersetzung aus|#übersetzungen] +| `{translate}` … `{/translate}` | [übersetzt den Inhalt|#übersetzungen] .[table-latte-tags language-latte] -|## Andere -| `{contentType}` | [schaltet den Escaping-Modus um und sendet HTTP-Header |#contenttype] -| `{debugbreak}` | [setzt einen Haltepunkt im Code |#debugbreak] -| `{do}` | [wertet einen Ausdruck aus, ohne ihn zu drucken |#do] -| `{dump}` | [gibt Variablen in die Tracy Bar aus |#dump] -| `{php}` | [führt beliebigen PHP-Code aus |#php] -| `{spaceless}`... `{/spaceless}` | [entfernt unnötige Leerzeichen |#spaceless] -| `{syntax}` | [schaltet die Syntax während der Laufzeit um |#syntax] -| `{trace}` | [zeigt Stack-Trace |#trace] +|## Sonstiges +| `{contentType}` | [schaltet das Escaping um und sendet einen HTTP-Header|#contenttype] +| `{debugbreak}` | [platziert einen Breakpoint im Code|#debugbreak] +| `{do}` | [führt Code aus, gibt aber nichts aus|#do] +| `{dump}` | [dumpt Variablen in die Tracy Bar|#dump] +| `{php}` | [führt beliebigen PHP-Code aus|#php] +| `{spaceless}` … `{/spaceless}` | [entfernt überflüssige Leerzeichen|#spaceless] +| `{syntax}` | [Änderung der Syntax zur Laufzeit|#syntax] +| `{trace}` | [zeigt den Stack-Trace an|#trace] .[table-latte-tags language-latte] -|## HTML-Tag-Helfer -| `n:class` | [intelligentes Klassenattribut |#n:class] -| `n:attr` | [intelligente HTML-Attribute |#n:attr] -| `n:tag` | [Dynamischer Name des HTML-Elements |#n:tag] -| `n:ifcontent` | [Leeren HTML-Tag auslassen |#n:ifcontent] +|## Helfer für HTML-Codierer +| `n:class` | [dynamische Schreibweise des HTML-Attributs class|#n:class] +| `n:attr` | [dynamische Schreibweise beliebiger HTML-Attribute|#n:attr] +| `n:tag` | [dynamische Schreibweise des HTML-Element-Namens|#n:tag] +| `n:ifcontent` | [lässt einen leeren HTML-Tag aus|#n:ifcontent] .[table-latte-tags language-latte] -|## Nur in Nette Framework verfügbar -| `n:href` | [Link in `` HTML-Elementen |application:creating-links#In the Presenter Template] -| `{link}` | [gibt einen Link aus |application:creating-links#In the Presenter Template] -| `{plink}` | [druckt einen Link zu einem Presenter |application:creating-links#In the Presenter Template] -| `{control}` | [druckt eine Komponente |application:components#Rendering] -| `{snippet}`... `{/snippet}` | [ein Template-Snippet, das per AJAX gesendet werden kann |application:ajax#snippets-in-latte] -| `{snippetArea}` | [Schnipsel Umschlag |application:ajax#snippet-areas] -| `{cache}`... `{/cache}` | [zwischenspeichert einen Vorlagenabschnitt |caching:#caching-in-latte] +|## Nur im Nette Framework verfügbar +| `n:href` | [Link, der in HTML-Elementen `` verwendet wird|application:creating-links#In the Presenter Template] +| `{link}` | [gibt einen Link aus|application:creating-links#In the Presenter Template] +| `{plink}` | [gibt einen Link zu einem Presenter aus|application:creating-links#In the Presenter Template] +| `{control}` | [rendert eine Komponente|application:components#Rendering] +| `{snippet}` … `{/snippet}` | [ein Snippet, das per AJAX gesendet werden kann|application:ajax#snippets-in-latte] +| `{snippetArea}` | [Wrapper für Snippets|application:ajax#snippet-areas] +| `{cache}` … `{/cache}` | [cached einen Teil des Templates|caching:#caching-in-latte] .[table-latte-tags language-latte] |## Nur mit Nette Forms verfügbar -| `{form}`... `{/form}` | [druckt ein Formularelement |forms:rendering#form] -| `{label}`... `{/label}` | [druckt eine Formulareingabebezeichnung |forms:rendering#label-input] -| `{input}` | [druckt ein Formulareingabeelement |forms:rendering#label-input] -| `{inputError}` | [gibt eine Fehlermeldung für ein Formulareingabeelement aus |forms:rendering#inputError] -| `n:name` | [aktiviert ein HTML-Eingabeelement |forms:rendering#n:name] -| `{formContainer}`... `{/formContainer}` | [Darstellung des Formular-Containers |forms:rendering#special-cases] +| `{form}` … `{/form}` | [rendert Formular-Tags|forms:rendering#form] +| `{label}` … `{/label}` | [rendert ein Label für ein Formularelement|forms:rendering#label-input] +| `{input}` | [rendert ein Formularelement|forms:rendering#label-input] +| `{inputError}` | [gibt eine Fehlermeldung für ein Formularelement aus|forms:rendering#inputError] +| `n:name` | [aktiviert ein Formularelement|forms:rendering#n:name] +| `{formContainer}` … `{/formContainer}` | [Zeichnen eines Formular-Containers|forms:rendering#special-cases] -Drucken .[#toc-printing] +Ausgabe .[#toc-printing] ======================== `{$var}` `{...}` `{=...}` ------------------------- -Latte verwendet das Tag `{=...}`, um einen beliebigen Ausdruck in der Ausgabe auszugeben. Wenn der Ausdruck mit einer Variablen oder einem Funktionsaufruf beginnt, ist es nicht nötig, ein Gleichheitszeichen zu schreiben. Das bedeutet in der Praxis, dass es fast nie geschrieben werden muss: +In Latte wird das Tag `{=...}` verwendet, um einen beliebigen Ausdruck auszugeben. Latte legt Wert auf Ihren Komfort, daher ist es nicht nötig, das Gleichheitszeichen zu schreiben, wenn der Ausdruck mit einer Variable oder einem Funktionsaufruf beginnt. Das bedeutet in der Praxis, dass es fast nie notwendig ist, es zu schreiben: ```latte Name: {$name} {$surname}
-Age: {date('Y') - $birth}
+Alter: {date('Y') - $birth}
``` -Sie können alles, was Sie aus PHP kennen, als Ausdruck schreiben. Sie müssen nur keine neue Sprache lernen. Zum Beispiel: +Als Ausdruck können Sie alles schreiben, was Sie aus PHP kennen. Sie müssen einfach keine neue Sprache lernen. Zum Beispiel: ```latte {='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION} ``` -Bitte suchen Sie nicht nach einer Bedeutung in dem vorherigen Beispiel, aber wenn Sie eine finden, schreiben Sie uns :-) +Bitte suchen Sie in dem vorherigen Beispiel keinen Sinn, aber wenn Sie einen finden sollten, schreiben Sie uns :-) -Ausweichende Ausgabe .[#toc-escaping-output] --------------------------------------------- +Ausgabe escapen .[#toc-escaping-output] +--------------------------------------- -Was ist die wichtigste Aufgabe eines Template-Systems? Sicherheitslücken zu vermeiden. Und genau das tut Latte, wenn Sie etwas in die Ausgabe drucken. Es entschlüsselt automatisch alles: +Was ist die wichtigste Aufgabe eines Template-Systems? Sicherheitslücken zu verhindern. Und genau das macht Latte immer, wenn Sie etwas ausgeben. Es escaped es automatisch: ```latte -

{='one < two'}

{* prints: '

one < two

' *} +

{='one < two'}

{* gibt aus: '

one < two

' *} ``` -Um genau zu sein, verwendet Latte kontextabhängiges Escaping, eine so wichtige und einzigartige Funktion dass wir ihr [ein eigenes Kapitel |safety-first#context-aware-escaping] gewidmet haben. +Um genau zu sein, verwendet Latte kontextsensitives Escaping, was so wichtig und einzigartig ist, dass wir ihm [ein eigenes Kapitel|safety-first#context-aware-escaping] gewidmet haben. -Und wenn Sie HTML-codierte Inhalte aus einer vertrauenswürdigen Quelle drucken? Dann können Sie das Escaping einfach abschalten: +Und was ist, wenn Sie HTML-codierten Inhalt aus einer vertrauenswürdigen Quelle ausgeben? Dann kann das Escaping einfach deaktiviert werden: ```latte {$trustedHtmlString|noescape} ``` .[warning] -Der Missbrauch des `noescape`-Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn nur, wenn Sie **absolut sicher** sind, was Sie tun und dass die Zeichenfolge, die Sie ausgeben, aus einer vertrauenswürdigen Quelle stammt. +Eine falsche Verwendung des `noescape`-Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn niemals, wenn Sie sich nicht **absolut sicher** sind, was Sie tun, und dass die ausgegebene Zeichenkette aus einer vertrauenswürdigen Quelle stammt. -Drucken in JavaScript .[#toc-printing-in-javascript] +Ausgabe in JavaScript .[#toc-printing-in-javascript] ---------------------------------------------------- -Dank der kontextsensitiven Escape-Funktion ist es wunderbar einfach, Variablen innerhalb von JavaScript zu drucken, und Latte wird sie korrekt escapen. +Dank des kontextsensitiven Escapings ist es wunderbar einfach, Variablen innerhalb von JavaScript auszugeben, und Latte kümmert sich um das korrekte Escaping. -Die Variable muss keine Zeichenkette sein, es wird jeder Datentyp unterstützt, der dann als JSON kodiert wird: +Die Variable muss nicht unbedingt ein String sein, es wird jeder Datentyp unterstützt, der dann als JSON kodiert wird: ```latte {var $foo = ['hello', true, 1]} @@ -179,7 +179,7 @@ Erzeugt: ``` -Dies ist auch der Grund, warum **Variablen nicht in Anführungszeichen** gesetzt werden sollten: Latte fügt sie um Strings herum ein. Und wenn Sie eine String-Variable in einen anderen String einfügen wollen, verketten Sie sie einfach: +Das ist auch der Grund, warum **keine Anführungszeichen** um die Variable geschrieben werden: Latte fügt sie bei Strings selbst hinzu. Und wenn Sie eine String-Variable in einen anderen String einfügen möchten, verbinden Sie sie einfach: ```latte ``` @@ -195,13 +195,13 @@ Dies ist auch der Grund, warum **Variablen nicht in Anführungszeichen** gesetzt Filter .[#toc-filters] ---------------------- -Der gedruckte Ausdruck kann [durch Filter |syntax#filters] verändert werden. In diesem Beispiel wird die Zeichenkette beispielsweise in Großbuchstaben umgewandelt und auf maximal 30 Zeichen gekürzt: +Der ausgegebene Ausdruck kann durch einen [Filter|syntax#filters] modifiziert werden. So können wir zum Beispiel eine Zeichenkette in Großbuchstaben umwandeln und auf maximal 30 Zeichen kürzen: ```latte {$string|upper|truncate:30} ``` -Sie können auch Filter auf Teile eines Ausdrucks anwenden, wie folgt: +Filter können auch auf Teile eines Ausdrucks auf folgende Weise angewendet werden: ```latte {$left . ($middle|upper) . $right} @@ -215,60 +215,60 @@ Bedingungen .[#toc-conditions] `{if}` `{elseif}` `{else}` -------------------------- -Bedingungen verhalten sich genauso wie die entsprechenden PHP-Ausdrücke. Sie können die gleichen Ausdrücke verwenden, die Sie aus PHP kennen, Sie müssen keine neue Sprache lernen. +Bedingungen verhalten sich genauso wie ihre Pendants in PHP. Sie können in ihnen die gleichen Ausdrücke verwenden, die Sie aus PHP kennen, Sie müssen keine neue Sprache lernen. ```latte {if $product->inStock > Stock::Minimum} - In stock + Auf Lager {elseif $product->isOnWay()} - On the way + Unterwegs {else} - Not available + Nicht verfügbar {/if} ``` -Wie jedes Paar-Tag kann ein Paar von `{if} ... {/ if}` zum Beispiel als [n:attribute |syntax#n:attributes] geschrieben werden: +Wie jedes Paar-Tag kann auch das Paar `{if} ... {/if}` in Form eines [n:Attributs|syntax#n:attributes] geschrieben werden, zum Beispiel: ```latte -

In stock {$count} items

+

{$count} Artikel auf Lager

``` -Wussten Sie, dass Sie das Präfix `tag-` zu n:Attributen hinzufügen können? Dann wirkt sich die Bedingung nur auf die HTML-Tags aus und der Inhalt zwischen ihnen wird immer gedruckt: +Wussten Sie, dass Sie n:Attribute mit dem Präfix `tag-` versehen können? Dann bezieht sich die Bedingung nur auf die Ausgabe der HTML-Tags, und der Inhalt dazwischen wird immer ausgegeben: ```latte Hello -{* prints 'Hello' when $clickable is falsey *} -{* prints 'Hello' when $clickable is truthy *} +{* gibt 'Hello' aus, wenn $clickable falsch ist *} +{* gibt 'Hello' aus, wenn $clickable wahr ist *} ``` -Schön. +Göttlich. `n:else` .{data-version:3.0.11} ------------------------------- -Wenn Sie die Bedingung `{if} ... {/if}` in Form eines [n:-Attributs |syntax#n:attributes] schreiben, haben Sie die Möglichkeit, mit `n:else` eine alternative Verzweigung anzugeben: +Wenn Sie die Bedingung `{if} ... {/if}` in Form eines [n:Attributs|syntax#n:attributes] schreiben, haben Sie die Möglichkeit, eine alternative Verzweigung mit `n:else` anzugeben: ```latte -In stock {$count} items +{$count} Artikel auf Lager -not available +nicht verfügbar ``` -Das Attribut `n:else` kann auch in Verbindung mit [`n:ifset` |#ifset-elseifset], [`n:foreach` |#foreach], [`n:try` |#try], [`n:ifcontent` |#n:ifcontent], und [`n:ifchanged` |#ifchanged]. +Das Attribut `n:else` kann auch in Kombination mit [`n:ifset` |#ifset-elseifset], [`n:foreach` |#foreach], [`n:try` |#try], [`n:ifcontent` |#n:ifcontent] und [`n:ifchanged` |#ifchanged] verwendet werden. `{/if $cond}` ------------- -Sie werden vielleicht überrascht sein, dass der Ausdruck in der Bedingung `{if}` auch im End-Tag angegeben werden kann. Dies ist in Situationen nützlich, in denen wir den Wert der Bedingung noch nicht kennen, wenn das Tag geöffnet wird. Nennen wir es eine aufgeschobene Entscheidung. +Es mag Sie überraschen, dass der Ausdruck in der Bedingung `{if}` auch im schließenden Tag angegeben werden kann. Dies ist nützlich in Situationen, in denen wir beim Öffnen der Bedingung ihren Wert noch nicht kennen. Nennen wir es eine verzögerte Entscheidung. -Wir beginnen z. B. mit der Auflistung einer Tabelle mit Datensätzen aus der Datenbank und stellen erst nach Fertigstellung des Berichts fest, dass kein Datensatz in der Datenbank vorhanden war. Also setzen wir die Bedingung in das End-Tag `{/if}`, und wenn es keinen Datensatz gibt, wird nichts davon gedruckt: +Zum Beispiel beginnen wir mit der Ausgabe einer Tabelle mit Datensätzen aus der Datenbank und erst nach Abschluss der Ausgabe stellen wir fest, dass kein Datensatz in der Datenbank vorhanden war. Also setzen wir eine Bedingung in das schließende `{/if}`-Tag, und wenn kein Datensatz vorhanden ist, wird nichts davon ausgegeben: ```latte {if} -

Printing rows from the database

+

Ausgabe von Zeilen aus der Datenbank

{foreach $resultSet as $row} @@ -278,9 +278,9 @@ Wir beginnen z. B. mit der Auflistung einer Tabelle mit Datensätzen aus der Dat {/if isset($row)} ``` -Praktisch, nicht wahr? +Clever, nicht wahr? -Sie können auch `{else}` in der aufgeschobenen Bedingung verwenden, aber nicht `{elseif}`. +In einer verzögerten Bedingung kann auch `{else}` verwendet werden, aber nicht `{elseif}`. `{ifset}` `{elseifset}` @@ -289,7 +289,7 @@ Sie können auch `{else}` in der aufgeschobenen Bedingung verwenden, aber nicht .[note] Siehe auch [`{ifset block}` |template-inheritance#checking-block-existence] -Verwenden Sie die `{ifset $var}` Bedingung, um festzustellen, ob eine Variable (oder mehrere Variablen) existiert und einen Nicht-Null-Wert hat. Es ist eigentlich das Gleiche wie `if (isset($var))` in PHP. Wie jedes Paar-Tag kann es in der Form von [n:attribute |syntax#n:attributes] geschrieben werden, also zeigen wir es in einem Beispiel: +Mit der Bedingung `{ifset $var}` können wir überprüfen, ob eine Variable (oder mehrere Variablen) existiert und einen nicht-null-Wert hat. Es ist im Grunde dasselbe wie `if (isset($var))` in PHP. Wie jedes Paar-Tag kann es auch in Form eines [n:Attributs|syntax#n:attributes] geschrieben werden, also zeigen wir es als Beispiel: ```latte @@ -299,9 +299,9 @@ Verwenden Sie die `{ifset $var}` Bedingung, um festzustellen, ob eine Variable ( `{ifchanged}` ------------- -`{ifchanged}` prüft, ob sich der Wert einer Variablen seit der letzten Iteration in der Schleife (foreach, for oder while) geändert hat. +`{ifchanged}` überprüft, ob sich der Wert einer Variable seit der letzten Iteration in einer Schleife (foreach, for oder while) geändert hat. -Wenn wir eine oder mehrere Variablen im Tag angeben, wird geprüft, ob sich eine von ihnen geändert hat, und der Inhalt wird entsprechend ausgegeben. Im folgenden Beispiel wird beispielsweise bei der Auflistung von Namen jedes Mal der erste Buchstabe eines Namens als Überschrift ausgegeben, wenn er sich ändert: +Wenn wir eine oder mehrere Variablen im Tag angeben, wird überprüft, ob sich eine von ihnen geändert hat, und dementsprechend wird der Inhalt ausgegeben. Das folgende Beispiel gibt den ersten Buchstaben des Namens als Überschrift aus, jedes Mal wenn er sich bei der Ausgabe der Namen ändert: ```latte {foreach ($names|sort) as $name} @@ -311,7 +311,7 @@ Wenn wir eine oder mehrere Variablen im Tag angeben, wird geprüft, ob sich eine {/foreach} ``` -Wenn jedoch kein Argument angegeben wird, wird der gerenderte Inhalt selbst mit seinem vorherigen Zustand verglichen. Das bedeutet, dass wir im vorherigen Beispiel das Argument im Tag getrost weglassen können. Und natürlich können wir auch [n:attribute |syntax#n:attributes] verwenden: +Wenn wir jedoch kein Argument angeben, wird der gerenderte Inhalt im Vergleich zu seinem vorherigen Zustand überprüft. Das bedeutet, dass wir im vorherigen Beispiel das Argument im Tag weglassen können. Und natürlich können wir auch ein [n:Attribut|syntax#n:attributes] verwenden: ```latte {foreach ($names|sort) as $name} @@ -321,35 +321,35 @@ Wenn jedoch kein Argument angegeben wird, wird der gerenderte Inhalt selbst mit {/foreach} ``` -Sie können auch eine `{else}` Klausel innerhalb der `{ifchanged}` einfügen. +Innerhalb von `{ifchanged}` kann auch eine `{else}`-Klausel verwendet werden. `{switch}` `{case}` `{default}` ------------------------------- -Vergleicht den Wert mit mehreren Optionen. Dies ist ähnlich wie die `switch` Struktur, die Sie aus PHP kennen. Latte verbessert sie jedoch: +Vergleicht einen Wert mit mehreren Möglichkeiten. Es ist ähnlich wie die bedingte Anweisung `switch`, die Sie aus PHP kennen. Latte verbessert sie jedoch: -- verwendet einen strengen Vergleich (`===`) -- braucht kein `break` +- es verwendet einen strikten Vergleich (`===`) +- es benötigt kein `break` -Es ist also das exakte Äquivalent der `match` Struktur, die PHP 8.0 mitbringt. +Es ist also das genaue Äquivalent zur `match`-Struktur, die mit PHP 8.0 eingeführt wurde. ```latte {switch $transport} {case train} - By train + Mit dem Zug {case plane} - By plane + Mit dem Flugzeug {default} - Differently + Anderweitig {/switch} ``` -Die Klausel `{case}` kann mehrere durch Kommas getrennte Werte enthalten: +Die `{case}`-Klausel kann mehrere durch Kommas getrennte Werte enthalten: ```latte {switch $status} -{case $status::New}new item -{case $status::Sold, $status::Unknown}not available +{case $status::New}neuer Artikel +{case $status::Sold, $status::Unknown}nicht verfügbar {/switch} ``` @@ -357,13 +357,13 @@ Die Klausel `{case}` kann mehrere durch Kommas getrennte Werte enthalten: Schleifen .[#toc-loops] ======================= -In Latte stehen Ihnen alle Schleifen, die Sie aus PHP kennen, zur Verfügung: foreach, for und while. +In Latte finden Sie alle Schleifen, die Sie aus PHP kennen: foreach, for und while. `{foreach}` ----------- -Sie schreiben den Zyklus genau so wie in PHP: +Wir schreiben die Schleife genauso wie in PHP: ```latte {foreach $langs as $code => $lang} @@ -371,11 +371,11 @@ Sie schreiben den Zyklus genau so wie in PHP: {/foreach} ``` -Darüber hinaus hat er einige praktische Verbesserungen, über die wir jetzt sprechen werden. +Zusätzlich hat sie einige nützliche Funktionen, über die wir jetzt sprechen werden. -So stellt Latte zum Beispiel sicher, dass erstellte Variablen nicht versehentlich gleichnamige globale Variablen überschreiben. Das hilft Ihnen, wenn Sie davon ausgehen, dass `$lang` die aktuelle Sprache der Seite ist, und Sie nicht merken, dass `foreach $langs as $lang` diese Variable überschrieben hat. +Latte überprüft zum Beispiel, ob erstellte Variablen versehentlich globale Variablen mit demselben Namen überschreiben. Das rettet Situationen, in denen Sie davon ausgehen, dass `$lang` die aktuelle Sprache der Seite ist, und nicht bemerken, dass `foreach $langs as $lang` diese Variable überschrieben hat. -Die foreach-Schleife kann auch sehr elegant und sparsam mit [n:attribute |syntax#n:attributes] geschrieben werden: +Die foreach-Schleife kann auch sehr elegant und kompakt als [n:Attribut|syntax#n:attributes] geschrieben werden: ```latte
    @@ -383,7 +383,7 @@ Die foreach-Schleife kann auch sehr elegant und sparsam mit [n:attribute |syntax
``` -Wussten Sie, dass Sie n:attributes das Präfix `inner-` voranstellen können? Dann wird in der Schleife nur noch der innere Teil des Elements wiederholt: +Wussten Sie, dass Sie n:Attribute mit dem Präfix `inner-` versehen können? Dann wird nur der Inhalt des Elements in der Schleife wiederholt: ```latte
@@ -392,7 +392,7 @@ Wussten Sie, dass Sie n:attributes das Präfix `inner-` voranstellen können? Da
``` -Es wird also etwas gedruckt wie: +Dies wird also etwas wie folgendes ausgeben: ```latte
@@ -407,14 +407,14 @@ Es wird also etwas gedruckt wie: `{else}` .{toc: foreach-else} ----------------------------- -Die Schleife `foreach` kann eine optionale Klausel `{else}` enthalten, deren Text angezeigt wird, wenn das angegebene Feld leer ist: +Innerhalb einer `foreach`-Schleife kann eine `{else}`-Klausel angegeben werden, deren Inhalt angezeigt wird, wenn die Schleife leer ist: ```latte
    {foreach $people as $person}
  • {$person->name}
    • {else} -
  • Sorry, no users in this list
    • +
  • Leider sind in dieser Liste keine Benutzer
    • {/foreach}
``` @@ -423,17 +423,17 @@ Die Schleife `foreach` kann eine optionale Klausel `{else}` enthalten, deren Tex `$iterator` ----------- -Innerhalb der Schleife `foreach` wird die Variable `$iterator` initialisiert. Sie enthält wichtige Informationen über die aktuelle Schleife. +Innerhalb einer `foreach`-Schleife erstellt Latte eine Variable `$iterator`, mit der wir nützliche Informationen über die laufende Schleife abrufen können: -- `$iterator->first` - ist dies die erste Iteration? -- `$iterator->last` - ist dies die letzte Iteration? -- `$iterator->counter` - Iterationszähler, beginnt bei 1 -- `$iterator->counter0` - Iterationszähler, beginnt bei 0 -- `$iterator->odd` - Ist diese Iteration ungerade? -- `$iterator->even` - ist diese Iteration gerade? -- `$iterator->parent` - der Iterator, der den aktuellen Iterator umgibt -- `$iterator->nextValue` - das nächste Element in der Schleife -- `$iterator->nextKey` - der Schlüssel des nächsten Elements in der Schleife +- `$iterator->first` - ist dies der erste Durchlauf? +- `$iterator->last` - ist dies der letzte Durchlauf? +- `$iterator->counter` - der wievielte Durchlauf ist es, gezählt ab eins? +- `$iterator->counter0` - der wievielte Durchlauf ist es, gezählt ab null? +- `$iterator->odd` - ist dies ein ungerader Durchlauf? +- `$iterator->even` - ist dies ein gerader Durchlauf? +- `$iterator->parent` - der Iterator, der den aktuellen umgibt +- `$iterator->nextValue` - der nächste Eintrag in der Schleife +- `$iterator->nextKey` - der Schlüssel des nächsten Eintrags in der Schleife ```latte @@ -449,20 +449,20 @@ Innerhalb der Schleife `foreach` wird die Variable `$iterator` initialisiert. Si {/foreach} ``` -Die Latte ist schlau und `$iterator->last` funktioniert nicht nur für Arrays, sondern auch, wenn die Schleife über einen allgemeinen Iterator läuft, bei dem die Anzahl der Elemente nicht im Voraus bekannt ist. +Latte ist schlau und `$iterator->last` funktioniert nicht nur bei Arrays, sondern auch wenn die Schleife über einen allgemeinen Iterator läuft, bei dem die Anzahl der Elemente nicht im Voraus bekannt ist. `{first}` `{last}` `{sep}` -------------------------- -Diese Tags können innerhalb der Schleife `{foreach}` verwendet werden. Der Inhalt von `{first}` wird beim ersten Durchlauf gerendert. -Der Inhalt von `{last}` wird gerendert ... können Sie es erraten? Ja, für den letzten Durchlauf. Dies sind eigentlich Abkürzungen für `{if $iterator->first}` und `{if $iterator->last}`. +Diese Tags können innerhalb einer `{foreach}`-Schleife verwendet werden. Der Inhalt von `{first}` wird gerendert, wenn es sich um den ersten Durchlauf handelt. +Der Inhalt von `{last}` wird gerendert ... können Sie es erraten? Ja, wenn es sich um den letzten Durchlauf handelt. Es handelt sich eigentlich um Abkürzungen für `{if $iterator->first}` und `{if $iterator->last}`. -Die Tags können auch als [n:attributes |syntax#n:attributes] geschrieben werden: +Die Tags können auch elegant als [n:Attribute|syntax#n:attributes] verwendet werden: ```latte {foreach $rows as $row} - {first}

List of names

{/first} + {first}

Liste der Namen

{/first}

{$row->name}

@@ -470,21 +470,21 @@ Die Tags können auch als [n:attributes |syntax#n:attributes] geschrieben werden {/foreach} ``` -Der Inhalt von `{sep}` wird wiedergegeben, wenn es sich nicht um die letzte Iteration handelt, und eignet sich daher für die Ausgabe von Begrenzungszeichen, wie z. B. Kommas zwischen aufgelisteten Elementen: +Der Inhalt des `{sep}`-Tags wird gerendert, wenn der Durchlauf nicht der letzte ist. Es eignet sich also zum Rendern von Trennzeichen, zum Beispiel Kommas zwischen ausgegebenen Elementen: ```latte {foreach $items as $item} {$item} {sep}, {/sep} {/foreach} ``` -Das ist doch ziemlich praktisch, oder? +Das ist ziemlich praktisch, nicht wahr? `{iterateWhile}` ---------------- -Vereinfacht die Gruppierung von linearen Daten während der Iteration in einer foreach-Schleife durch Iteration in einer verschachtelten Schleife, bis eine Bedingung erfüllt ist. [Lesen Sie die ausführliche Anleitung |cookbook/grouping]. +Vereinfacht die Gruppierung linearer Daten während der Iteration in einer foreach-Schleife, indem die Iteration in einer verschachtelten Schleife durchgeführt wird, solange eine Bedingung erfüllt ist. [Lesen Sie die detaillierte Anleitung|cookbook/grouping]. -Sie kann auch `{first}` und `{last}` im obigen Beispiel elegant ersetzen: +Es kann auch elegant `{first}` und `{last}` im obigen Beispiel ersetzen: ```latte {foreach $rows as $row} @@ -501,21 +501,21 @@ Sie kann auch `{first}` und `{last}` im obigen Beispiel elegant ersetzen: {/foreach} ``` -Siehe auch [Batch- |filters#batch] und [Gruppenfilter |filters#group]. +Siehe auch die Filter [batch|filters#batch] und [group|filters#group]. `{for}` ------- -Wir schreiben den Zyklus genau so wie in PHP: +Wir schreiben die Schleife genauso wie in PHP: ```latte {for $i = 0; $i < 10; $i++} - Item #{$i} + Element {$i} {/for} ``` -Das Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden: +Das Tag kann auch als [n:Attribut|syntax#n:attributes] verwendet werden: ```latte

{$i}

@@ -525,7 +525,7 @@ Das Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden: `{while}` --------- -Auch hier schreiben wir den Zyklus genau so, wie in PHP: +Wir schreiben die Schleife wieder genauso wie in PHP: ```latte {while $row = $result->fetch()} @@ -533,7 +533,7 @@ Auch hier schreiben wir den Zyklus genau so, wie in PHP: {/while} ``` -Oder als [n:Attribut |syntax#n:attributes]: +Oder als [n:Attribut|syntax#n:attributes]: ```latte @@ -541,7 +541,7 @@ Oder als [n:Attribut |syntax#n:attributes]: ``` -Eine Variante mit einer Bedingung im End-Tag entspricht der do-while-Schleife in PHP: +Eine Variante mit der Bedingung im schließenden Tag ist ebenfalls möglich, die der do-while-Schleife in PHP entspricht: ```latte {while} @@ -553,7 +553,7 @@ Eine Variante mit einer Bedingung im End-Tag entspricht der do-while-Schleife in `{continueIf}` `{skipIf}` `{breakIf}` ------------------------------------- -Es gibt spezielle Tags, die Sie zur Steuerung jeder Schleife verwenden können - `{continueIf ?}` und `{breakIf ?}`, die zur nächsten Iteration springen bzw. die Schleife beenden, wenn die Bedingungen erfüllt sind: +Zur Steuerung jeder Schleife können die Tags `{continueIf ?}` und `{breakIf ?}` verwendet werden, die zum nächsten Element übergehen bzw. die Schleife beenden, wenn eine Bedingung erfüllt ist: ```latte {foreach $rows as $row} @@ -564,7 +564,7 @@ Es gibt spezielle Tags, die Sie zur Steuerung jeder Schleife verwenden können - ``` -Das Tag `{skipIf}` ist dem Tag `{continueIf}` sehr ähnlich, erhöht aber den Zähler nicht. So gibt es keine Löcher in der Nummerierung, wenn Sie `$iterator->counter` ausdrucken und einige Elemente überspringen. Auch die {else}-Klausel wird wiedergegeben, wenn Sie alle Elemente überspringen. +Das `{skipIf}`-Tag ist sehr ähnlich wie `{continueIf}`, erhöht aber nicht den Zähler `$iterator->counter`, so dass, wenn wir ihn ausgeben und gleichzeitig einige Elemente überspringen, keine Lücken in der Nummerierung entstehen. Außerdem wird die `{else}`-Klausel gerendert, wenn wir alle Elemente überspringen. ```latte
    @@ -572,7 +572,7 @@ Das Tag `{skipIf}` ist dem Tag `{continueIf}` sehr ähnlich, erhöht aber den Z {skipIf $person->age < 18}
  • {$iterator->counter}. {$person->name}
    • {else} -
  • Sorry, no adult users in this list
    • +
  • Leider gibt es keine Erwachsenen in dieser Liste
    • {/foreach}
``` @@ -581,20 +581,20 @@ Das Tag `{skipIf}` ist dem Tag `{continueIf}` sehr ähnlich, erhöht aber den Z `{exitIf}` .{data-version:3.0.5} -------------------------------- -Beendet das Rendering einer Vorlage oder eines Blocks, wenn eine Bedingung erfüllt ist (d. h. "early exit"). +Beendet das Rendern des Templates oder Blocks, wenn eine Bedingung erfüllt ist (sogenannter "early exit"). ```latte {exitIf !$messages} -

Messages

+

Nachrichten

{$message}
``` -Schablonen einbeziehen .[#toc-including-templates] -================================================== +Einbindung von Templates .[#toc-including-templates] +==================================================== `{include 'file.latte'}` .{toc: include} @@ -603,46 +603,46 @@ Schablonen einbeziehen .[#toc-including-templates] .[note] Siehe auch [`{include block}` |template-inheritance#printing-blocks] -Der `{include}` Tag lädt und rendert die angegebene Vorlage. In unserer Lieblingssprache PHP sieht das so aus: +Das `{include}`-Tag lädt und rendert das angegebene Template. Wenn wir in der Sprache unserer Lieblingssprache PHP sprechen würden, wäre es so etwas wie: ```php ``` -Eingebundene Templates haben keinen Zugriff auf die Variablen des aktiven Kontexts, aber sie haben Zugriff auf die globalen Variablen. +Eingebundene Templates haben keinen Zugriff auf die Variablen des aktiven Kontexts, sie haben nur Zugriff auf globale Variablen. -Sie können der eingefügten Vorlage auf folgende Weise Variablen übergeben: +Variablen können auf diese Weise an das eingebundene Template übergeben werden: ```latte {include 'template.latte', foo: 'bar', id: 123} ``` -Der Name der Vorlage kann ein beliebiger PHP-Ausdruck sein: +Der Name des Templates kann ein beliebiger PHP-Ausdruck sein: ```latte {include $someVar} {include $ajax ? 'ajax.latte' : 'not-ajax.latte'} ``` -Der eingefügte Inhalt kann durch [Filter |syntax#filters] verändert werden. Im folgenden Beispiel werden alle HTML-Elemente entfernt und die Groß- und Kleinschreibung angepasst: +Der eingebundene Inhalt kann mit [Filtern|syntax#Filters] modifiziert werden. Das folgende Beispiel entfernt das gesamte HTML und passt die Groß-/Kleinschreibung an: ```latte {include 'heading.latte' |stripHtml|capitalize} ``` -Die [Vorlagenvererbung |template inheritance] ist standardmäßig **nicht** daran beteiligt. Sie können zwar Block-Tags zu eingebundenen Vorlagen hinzufügen, diese ersetzen jedoch nicht die passenden Blöcke in der Vorlage, in die sie eingebunden sind. Betrachten Sie Includes als unabhängige und abgeschirmte Teile von Seiten oder Modulen. Dieses Verhalten kann mit dem Modifikator `with blocks` geändert werden: +Standardmäßig spielt die [Template-Vererbung|template-inheritance] in diesem Fall keine Rolle. Auch wenn wir in dem eingebundenen Template Blöcke verwenden können, werden die entsprechenden Blöcke in dem Template, in das eingebunden wird, nicht ersetzt. Denken Sie an eingebundene Templates als separate, abgeschirmte Teile von Seiten oder Modulen. Dieses Verhalten kann mit dem Modifikator `with blocks` geändert werden: ```latte {include 'template.latte' with blocks} ``` -Die Beziehung zwischen dem im Tag angegebenen Dateinamen und der Datei auf der Festplatte ist eine Sache des [Loaders |extending-latte#Loaders]. +Die Beziehung zwischen dem im Tag angegebenen Dateinamen und der Datei auf der Festplatte ist eine Angelegenheit des [Loaders|extending-latte#Loaders]. `{sandbox}` ----------- -Wenn Sie eine von einem Endbenutzer erstellte Vorlage einbinden, sollten Sie eine Sandbox verwenden (weitere Informationen finden Sie in der [Sandbox-Dokumentation |sandbox]): +Bei der Einbindung eines vom Endbenutzer erstellten Templates sollten Sie den Sandbox-Modus in Betracht ziehen (weitere Informationen finden Sie in der [Sandbox-Dokumentation |sandbox]): ```latte {sandbox 'untrusted.latte', level: 3, data: $menu} @@ -655,7 +655,7 @@ Wenn Sie eine von einem Endbenutzer erstellte Vorlage einbinden, sollten Sie ein .[note] Siehe auch [`{block name}` |template-inheritance#blocks] -Blöcke ohne Namen dienen dazu, [Filter |syntax#filters] auf einen Teil der Vorlage anzuwenden. Sie können zum Beispiel einen [Streifenfilter |filters#strip] anwenden, um überflüssige Leerzeichen zu entfernen: +Namenlose Blöcke dienen als Möglichkeit, [Filter|syntax#Filters] auf einen Teil des Templates anzuwenden. Zum Beispiel kann auf diese Weise der [strip|filters#strip]-Filter angewendet werden, der überflüssige Leerzeichen entfernt: ```latte {block|strip} @@ -666,16 +666,16 @@ Blöcke ohne Namen dienen dazu, [Filter |syntax#filters] auf einen Teil der Vorl ``` -Behandlung von Ausnahmen .[#toc-exception-handling] -=================================================== +Ausnahmebehandlung .[#toc-exception-handling] +============================================= `{try}` ------- -Diese Tags machen es extrem einfach, robuste Vorlagen zu erstellen. +Dank dieses Tags ist es extrem einfach, robuste Templates zu erstellen. -Wenn beim Rendern des `{try}` -Blocks eine Ausnahme auftritt, wird der gesamte Block verworfen und das Rendern danach fortgesetzt: +Wenn während des Renderns eines `{try}`-Blocks eine Ausnahme auftritt, wird der gesamte Block verworfen und das Rendering wird danach fortgesetzt: ```latte {try} @@ -687,7 +687,7 @@ Wenn beim Rendern des `{try}` -Blocks eine Ausnahme auftritt, wird der gesamte B {/try} ``` -Der Inhalt der optionalen Klausel `{else}` wird nur gerendert, wenn eine Ausnahme auftritt: +Der Inhalt in der optionalen `{else}`-Klausel wird nur gerendert, wenn eine Ausnahme auftritt: ```latte {try} @@ -697,11 +697,11 @@ Der Inhalt der optionalen Klausel `{else}` wird nur gerendert, wenn eine Ausnahm {/foreach} {else} -

Sorry, the tweets could not be loaded.

+

Es tut uns leid, die Tweets konnten nicht geladen werden.

{/try} ``` -Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden: +Das Tag kann auch als [n:Attribut|syntax#n:attributes] verwendet werden: ```latte
    @@ -709,13 +709,13 @@ Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden:
``` -Es ist auch möglich, [einen eigenen Exception-Handler |develop#exception handler] für z.B. die Protokollierung zu definieren: +Es ist auch möglich, einen eigenen [Handler für Ausnahmen|develop#exception handler] zu definieren, zum Beispiel für Logging-Zwecke. `{rollback}` ------------ -Der Block `{try}` kann auch manuell mit `{rollback}` angehalten und übersprungen werden. So müssen Sie nicht alle Eingabedaten im Voraus prüfen und können erst während des Renderings entscheiden, ob es sinnvoll ist, das Objekt zu rendern. +Ein `{try}`-Block kann auch manuell mit `{rollback}` gestoppt und übersprungen werden. Dadurch müssen Sie nicht alle Eingabedaten im Voraus überprüfen und können während des Renderings entscheiden, dass Sie das Objekt überhaupt nicht rendern möchten: ```latte {try} @@ -738,23 +738,23 @@ Variablen .[#toc-variables] `{var}` `{default}` ------------------- -Wir werden neue Variablen in der Vorlage mit dem Tag `{var}` erstellen: +Neue Variablen werden im Template mit dem Tag `{var}` erstellt: ```latte {var $name = 'John Smith'} {var $age = 27} -{* Mehrfache Deklaration *} +{* Mehrfachdeklaration *} {var $name = 'John Smith', $age = 27} ``` -Das Tag `{default}` funktioniert ähnlich, mit dem Unterschied, dass es Variablen nur dann anlegt, wenn sie nicht existieren: +Das Tag `{default}` funktioniert ähnlich, mit dem Unterschied, dass es Variablen nur dann erstellt, wenn sie nicht existieren: ```latte {default $lang = 'cs'} ``` -Sie können auch [Typen von Variablen |type-system] angeben. Im Moment sind sie informativ und Latte prüft sie nicht. +Sie können auch [Variablentypen|type-system] angeben. Diese sind derzeit informativ und werden von Latte nicht überprüft. ```latte {var string $name = $article->getTitle()} @@ -765,7 +765,7 @@ Sie können auch [Typen von Variablen |type-system] angeben. Im Moment sind sie `{parameters}` -------------- -So wie eine Funktion ihre Parameter deklariert, kann eine Vorlage ihre Variablen am Anfang deklarieren: +So wie eine Funktion ihre Parameter deklariert, kann auch ein Template am Anfang seine Variablen deklarieren: ```latte {parameters @@ -775,15 +775,15 @@ So wie eine Funktion ihre Parameter deklariert, kann eine Vorlage ihre Variablen } ``` -Die Variablen `$a` und `$b` ohne Standardwert haben automatisch den Standardwert `null`. Die deklarierten Typen sind immer noch informativ, und Latte überprüft sie nicht. +Variablen `$a` und `$b` ohne angegebenen Standardwert haben automatisch den Standardwert `null`. Die deklarierten Typen sind derzeit informativ und werden von Latte nicht überprüft. -Andere als die deklarierten Variablen werden nicht an die Vorlage übergeben. Dies ist ein Unterschied zum Tag `{default}`. +Andere als die deklarierten Variablen werden nicht in das Template übertragen. Dies unterscheidet es vom Tag `{default}`. `{capture}` ----------- -Mit dem Tag `{capture}` können Sie die Ausgabe in einer Variablen erfassen: +Erfasst die Ausgabe in eine Variable: ```latte {capture $var} @@ -792,10 +792,10 @@ Mit dem Tag `{capture}` können Sie die Ausgabe in einer Variablen erfassen: {/capture} -

Captured: {$var}

+

Erfasst: {$var}

``` -Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden, wie jeder paarweise Tag: +Das Tag kann, wie jedes Paar-Tag, auch als [n:Attribut|syntax#n:Attribute] geschrieben werden: ```latte
    @@ -803,17 +803,17 @@ Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden, wie
``` -Die HTML-Ausgabe wird in der Variablen `$var` als `Latte\Runtime\Html` -Objekt gespeichert, um [unerwünschtes Escaping |develop#disabling-auto-escaping-of-variable] beim Drucken [zu vermeiden |develop#disabling-auto-escaping-of-variable]. +Die HTML-Ausgabe wird in der Variable `$var` als `Latte\Runtime\Html`-Objekt gespeichert, um [unerwünschtes Escaping |develop#disabling-auto-escaping-of-variable] beim Ausgeben zu verhindern. -Andere .[#toc-others] -===================== +Sonstiges .[#toc-others] +======================== `{contentType}` --------------- -Verwenden Sie das Tag, um anzugeben, welche Art von Inhalt die Vorlage darstellt. Die Optionen sind: +Mit diesem Tag geben Sie an, welchen Inhaltstyp das Template darstellt. Die Optionen sind: - `html` (Standardtyp) - `xml` @@ -822,16 +822,16 @@ Verwenden Sie das Tag, um anzugeben, welche Art von Inhalt die Vorlage darstellt - `calendar` (iCal) - `text` -Die Verwendung dieses Befehls ist wichtig, weil er die [kontextabhängige Escape-Funktion |safety-first#context-aware-escaping] einstellt und nur dann kann Latte korrekt escapen. Zum Beispiel schaltet `{contentType xml}` in den XML-Modus, `{contentType text}` schaltet das Escapen komplett ab. +Seine Verwendung ist wichtig, da es das [kontextsensitive Escaping |safety-first#context-aware-escaping] festlegt und nur so richtig escapen kann. Zum Beispiel schaltet `{contentType xml}` in den XML-Modus um, `{contentType text}` schaltet das Escaping komplett aus. -Handelt es sich bei dem Parameter um einen MIME-Typ mit vollem Funktionsumfang, wie z. B. `application/xml`, so wird auch ein HTTP-Header `Content-Type` an den Browser gesendet: +Wenn der Parameter ein vollständiger MIME-Typ ist, wie zum Beispiel `application/xml`, wird zusätzlich der HTTP-Header `Content-Type` an den Browser gesendet: ```latte {contentType application/xml} - RSS feed + RSS-Feed ... @@ -843,19 +843,19 @@ Handelt es sich bei dem Parameter um einen MIME-Typ mit vollem Funktionsumfang, `{debugbreak}` -------------- -Gibt die Stelle an, an der die Codeausführung unterbrochen wird. Sie wird zu Debugging-Zwecken verwendet, damit der Programmierer die Laufzeitumgebung überprüfen und sicherstellen kann, dass der Code wie erwartet ausgeführt wird. Er unterstützt [Xdebug |https://xdebug.org]. Zusätzlich können Sie eine Bedingung angeben, unter der der Code unterbrochen werden soll. +Markiert eine Stelle, an der die Programmausführung angehalten und der Debugger gestartet wird, damit der Programmierer die Laufzeitumgebung inspizieren und überprüfen kann, ob das Programm wie erwartet funktioniert. Es unterstützt [Xdebug |https://xdebug.org/]. Eine Bedingung kann hinzugefügt werden, die bestimmt, wann das Programm angehalten werden soll. ```latte -{debugbreak} {* bricht das Programm *} +{debugbreak} {* hält das Programm an *} -{debugbreak $counter == 1} {* bricht das Programm ab, wenn die Bedingung erfüllt ist *} +{debugbreak $counter == 1} {* hält das Programm an, wenn die Bedingung erfüllt ist *} ``` `{do}` ------ -Führt den PHP-Code aus und gibt nichts aus. Wie bei allen anderen Tags ist der PHP-Code ein einzelner Ausdruck, siehe [PHP-Einschränkungen |syntax#PHP Limitations in Latte]. +Führt PHP-Code aus und gibt nichts aus. Wie bei allen anderen Tags mit PHP-Code handelt es sich um einen einzelnen Ausdruck, siehe [PHP-Einschränkungen |syntax#PHP Limitations in Latte]. ```latte {do $num++} @@ -868,80 +868,80 @@ Führt den PHP-Code aus und gibt nichts aus. Wie bei allen anderen Tags ist der Gibt eine Variable oder den aktuellen Kontext aus. ```latte -{dump $name} {* gibt die Variable $name aus *} +{dump $name} {* Gibt die Variable $name aus *} -{dump} {* gibt alle definierten Variablen aus *} +{dump} {* Gibt alle aktuell definierten Variablen aus *} ``` .[caution] -Erfordert das Paket [Tracy |tracy:]. +Erfordert die [Tracy|tracy:]-Bibliothek. `{php}` ------- -Ermöglicht die Ausführung von beliebigem PHP-Code. Das Tag muss mit der Erweiterung [RawPhpExtension |develop#RawPhpExtension] aktiviert werden. +Ermöglicht die Ausführung beliebigen PHP-Codes. Das Tag muss durch die [RawPhpExtension |develop#RawPhpExtension] aktiviert werden. `{spaceless}` ------------- -Entfernt unnötige Leerzeichen. Ähnlich wie der [raumlose |filters#spaceless] Filter. +Entfernt überflüssige Leerzeichen aus der Ausgabe. Funktioniert ähnlich wie der Filter [spaceless|filters#spaceless]. ```latte {spaceless}
    -
  • Hello
    • +
  • Hallo
{/spaceless} ``` -Ausgaben: +Erzeugt ```latte -
  • Hello
+
  • Hallo
``` -Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden: +Das Tag kann auch als [n:Attribut|syntax#n:attributes] geschrieben werden. `{syntax}` ---------- -Latten-Tags müssen nicht nur in geschweifte Klammern eingeschlossen werden. Sie können ein anderes Trennzeichen wählen, auch zur Laufzeit. Dies geschieht durch `{syntax…}`, wobei der Parameter sein kann: +Latte-Tags müssen nicht nur durch einfache geschweifte Klammern begrenzt sein. Wir können auch einen anderen Begrenzer wählen, sogar zur Laufzeit. Dafür wird `{syntax …}` verwendet, wobei als Parameter angegeben werden kann: - double: `{{...}}` -- off: deaktiviert die Latte-Tags vollständig +- off: schaltet die Verarbeitung von Latte-Tags komplett aus -Mit der Notation n:attribute können wir Latte nur für einen JavaScript-Block deaktivieren: +Mit Hilfe von n:Attributen kann Latte zum Beispiel nur für einen JavaScript-Block ausgeschaltet werden: ```latte ``` -Latte kann sehr bequem innerhalb von JavaScript verwendet werden, man sollte nur Konstrukte wie in diesem Beispiel vermeiden, bei denen der Buchstabe unmittelbar auf `{` folgt, siehe [Latte innerhalb von JavaScript oder CSS |recipes#Latte inside JavaScript or CSS]. +Latte kann sehr bequem auch innerhalb von JavaScript verwendet werden, man muss nur Konstruktionen wie in diesem Beispiel vermeiden, bei denen direkt nach `{` ein Buchstabe folgt, siehe [Latte innerhalb von JavaScript oder CSS|recipes#Latte inside JavaScript or CSS]. -Wenn Sie Latte mit dem `{syntax off}` (d.h. Tag, nicht das n:-Attribut) ausschalten, werden alle Tags bis zu `{/syntax}` strikt ignoriert. +Wenn Sie Latte mit `{syntax off}` ausschalten (d.h. mit einem Tag, nicht mit einem n:Attribut), wird es konsequent alle Tags bis `{/syntax}` ignorieren. {trace} ------- -Wirft eine `Latte\RuntimeException` Exception, deren Stack-Trace im Sinne der Templates ist. Anstatt Funktionen und Methoden aufzurufen, werden also Blöcke aufgerufen und Vorlagen eingefügt. Wenn Sie ein Tool zur übersichtlichen Darstellung von geworfenen Ausnahmen wie [Tracy |tracy:] verwenden, sehen Sie deutlich den Aufrufstapel, einschließlich aller übergebenen Argumente. +Wirft eine `Latte\RuntimeException`, deren Stack-Trace im Geiste der Templates ist. Anstelle von Funktions- und Methodenaufrufen enthält er also Blockaufrufe und Template-Einbindungen. Wenn Sie ein Tool zur übersichtlichen Anzeige von geworfenen Ausnahmen verwenden, wie zum Beispiel [Tracy|tracy:], wird Ihnen der Call Stack einschließlich aller übergebenen Argumente übersichtlich angezeigt. -HTML-Tag-Hilfsmittel .[#toc-html-tag-helpers] -============================================= +Helfer für HTML-Codierer .[#toc-html-tag-helpers] +================================================= n:class ------- -Dank `n:class` ist es sehr einfach, das HTML-Attribut `class` genau so zu generieren, wie Sie es brauchen. +Dank `n:class` können Sie sehr einfach das HTML-Attribut `class` genau nach Ihren Vorstellungen generieren. -Beispiel: Ich möchte, dass das aktive Element die Klasse `active` hat: +Beispiel: Ich brauche, dass das aktive Element die Klasse `active` hat: ```latte {foreach $items as $item} @@ -949,7 +949,7 @@ Beispiel: Ich möchte, dass das aktive Element die Klasse `active` hat: {/foreach} ``` -Außerdem muss das erste Element die Klassen `first` und `main` haben: +Und weiter, dass das erste Element die Klassen `first` und `main` hat: ```latte {foreach $items as $item} @@ -957,7 +957,7 @@ Außerdem muss das erste Element die Klassen `first` und `main` haben: {/foreach} ``` -Und alle Elemente sollten die Klasse `list-item` haben: +Und alle Elemente sollen die Klasse `list-item` haben: ```latte {foreach $items as $item} @@ -965,13 +965,13 @@ Und alle Elemente sollten die Klasse `list-item` haben: {/foreach} ``` -Verblüffend einfach, nicht wahr? +Unglaublich einfach, nicht wahr? n:attr ------ -Das Attribut `n:attr` kann beliebige HTML-Attribute mit der gleichen Eleganz wie [n:class |#n:class] erzeugen. +Das Attribut `n:attr` kann mit der gleichen Eleganz wie [n:class|#n:class] beliebige HTML-Attribute generieren. ```latte {foreach $data as $item} @@ -979,7 +979,7 @@ Das Attribut `n:attr` kann beliebige HTML-Attribute mit der gleichen Eleganz wie {/foreach} ``` -Abhängig von den zurückgegebenen Werten zeigt es z. B: +Abhängig von den zurückgegebenen Werten wird zum Beispiel Folgendes ausgegeben: ```latte @@ -993,25 +993,25 @@ Abhängig von den zurückgegebenen Werten zeigt es z. B: n:tag ----- -Das Attribut `n:tag` kann den Namen eines HTML-Elements dynamisch ändern. +Das Attribut `n:tag` kann den Namen des HTML-Elements dynamisch ändern. ```latte

{$title}

``` -Wenn `$heading === null`, wird das `

` Tag ohne Änderung gedruckt. Andernfalls wird der Elementname in den Wert der Variablen geändert, so dass für `$heading === 'h3'` geschrieben wird: +Wenn `$heading === null` ist, wird der Tag `

` unverändert ausgegeben. Andernfalls wird der Name des Elements auf den Wert der Variable geändert, so dass für `$heading === 'h3'` Folgendes ausgegeben wird: ```latte

...

``` -Da es sich bei Latte um ein sicheres Templating-System handelt, wird überprüft, ob der neue Tag-Name gültig ist und keine unerwünschten oder bösartigen Werte enthält. +Da Latte ein sicheres Template-System ist, überprüft es, ob der neue Tag-Name gültig ist und keine unerwünschten oder schädlichen Werte enthält. n:ifcontent ----------- -Verhindert, dass ein leeres HTML-Element gedruckt wird, d.h. ein Element, das nichts als Leerraum enthält. +Verhindert, dass ein leeres HTML-Element ausgegeben wird, d.h. ein Element, das nichts außer Leerzeichen enthält. ```latte
@@ -1019,7 +1019,7 @@ Verhindert, dass ein leeres HTML-Element gedruckt wird, d.h. ein Element, das ni
``` -Abhängig von den Werten der Variablen `$error` wird dies gedruckt: +Gibt abhängig vom Wert der Variable `$error` aus: ```latte {* $error = '' *} @@ -1033,10 +1033,10 @@ Abhängig von den Werten der Variablen `$error` wird dies gedruckt: ``` -Übersetzung .[#toc-translation] -=============================== +Übersetzungen .[#toc-translation] +================================= -Damit die Übersetzungs-Tags funktionieren, müssen Sie den [Übersetzer ein richten|develop#TranslatorExtension]. Sie können auch den [`translate` |filters#translate] Filter für die Übersetzung verwenden. +Damit die Übersetzungs-Tags funktionieren, muss der [Übersetzer aktiviert werden|develop#TranslatorExtension]. Für Übersetzungen können Sie auch den Filter [`translate`|filters#translate] verwenden. `{_...}` @@ -1045,30 +1045,30 @@ Damit die Übersetzungs-Tags funktionieren, müssen Sie den [Übersetzer ein ric Übersetzt Werte in andere Sprachen. ```latte -{_'Basket'} +{_'Warenkorb'} {_$item} ``` -Es können auch andere Parameter an den Übersetzer übergeben werden: +Dem Übersetzer können auch weitere Parameter übergeben werden: ```latte -{_'Basket', domain: order} +{_'Warenkorb', domain: order} ``` `{translate}` ------------- -Překládá části šablony: +Übersetzt Teile des Templates: ```latte -

{translate}Order{/translate}

+

{translate}Bestellung{/translate}

{translate domain: order}Lorem ipsum ...{/translate} ``` -Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden, um das Innere des Elements zu übersetzen: +Das Tag kann auch als [n:Attribut|syntax#n:attributes] geschrieben werden, um den Inhalt des Elements zu übersetzen: ```latte -

Order

+

Bestellung

``` From b0de7ecef7a47b14222f0dfd594c4adff514788f Mon Sep 17 00:00:00 2001 From: David Grudl Date: Wed, 4 Sep 2024 21:36:48 +0200 Subject: [PATCH 07/23] latte improved --- .../cs/lets-create-contact-form.texy | 2 +- .../how-to-write-sql-queries-in-latte.texy | 32 ++- latte/cs/cookbook/migration-from-php.texy | 28 +- latte/cs/cookbook/migration-from-twig.texy | 40 ++- latte/cs/cookbook/passing-variables.texy | 28 +- latte/cs/creating-extension.texy | 78 +++--- latte/cs/develop.texy | 71 +++-- latte/cs/extending-latte.texy | 96 ++++--- latte/cs/filters.texy | 261 +++++++++--------- latte/cs/functions.texy | 52 ++-- latte/cs/recipes.texy | 69 +++-- latte/cs/safety-first.texy | 178 ++++++------ latte/cs/sandbox.texy | 67 ++++- latte/cs/syntax.texy | 106 +++---- latte/cs/tags.texy | 159 ++++++----- latte/cs/template-inheritance.texy | 220 ++++++++------- latte/cs/type-system.texy | 35 ++- 17 files changed, 827 insertions(+), 695 deletions(-) diff --git a/best-practices/cs/lets-create-contact-form.texy b/best-practices/cs/lets-create-contact-form.texy index 80503acf55..aa24fb819f 100644 --- a/best-practices/cs/lets-create-contact-form.texy +++ b/best-practices/cs/lets-create-contact-form.texy @@ -131,7 +131,7 @@ Zatím se odesílá prostý textový email obsahující pouze zprávu odeslanou ``` -Zbývá upravit `ContactFacade`, aby tuto šablonu používal. V konstruktoru si vyžádáme třídu `LatteFactory`, která umí vyrobit objekt `Latte\Engine`, tedy [vykreslovač Latte šablon |latte:develop#jak-vykreslit-sablonu]. Pomocí metody `renderToString()` šablonu vykreslíme do souboru, prvním parametrem je cesta k šabloně a druhým jsou proměnné. +Zbývá upravit `ContactFacade`, aby tuto šablonu používal. V konstruktoru si vyžádáme třídu `LatteFactory`, která umí vyrobit objekt `Latte\Engine`, tedy [vykreslovač Latte šablon |latte:develop#vykresleni-sablony]. Pomocí metody `renderToString()` šablonu vykreslíme do souboru, prvním parametrem je cesta k šabloně a druhým jsou proměnné. ```php namespace App\Model; diff --git a/latte/cs/cookbook/how-to-write-sql-queries-in-latte.texy b/latte/cs/cookbook/how-to-write-sql-queries-in-latte.texy index bdfc0feedc..07fb5dec84 100644 --- a/latte/cs/cookbook/how-to-write-sql-queries-in-latte.texy +++ b/latte/cs/cookbook/how-to-write-sql-queries-in-latte.texy @@ -2,9 +2,9 @@ Jak psát SQL queries v Latte? ***************************** .[perex] -Latte se může hodit i pro generování opravdu složitých SQL dotazů. +Latte může být užitečným nástrojem i pro generování komplexních SQL dotazů, což zvyšuje jejich čitelnost a udržovatelnost. -Pokud vytvoření SQL dotazu obsahuje řadu podmínek a proměnných, může být opravdu přehlednější ho napsat v Latte. Velmi jednoduchý příklad: +Když SQL dotaz obsahuje mnoho podmínek a proměnných, může být jeho zápis v Latte přehlednější a flexibilnější. Zde je jednoduchý příklad demonstrující tuto výhodu: ```latte SELECT users.* FROM users @@ -14,8 +14,13 @@ SELECT users.* FROM users WHERE groups.name = 'Admins' {ifset $country} AND country.name = {$country} {/ifset} ``` -Pomocí `$latte->setContentType()` řekneme Latte, aby k obsahu přistupovalo jako k prostému textu (nikoliv jako k HTML) a dále -připravíme escapovací funkci, která bude řetězce escapovat přímo databázovým driverem: +Pro správné fungování je třeba provést několik kroků: + +1. Nastavení typu obsahu: pomocí `$latte->setContentType()` informujeme Latte, že obsah má být zpracován jako prostý text, nikoliv jako HTML. + +2. Definice escapovací funkce: vytvoříme vlastní escapovací funkci, která bude řetězce escapovat přímo pomocí databázového driveru. Tím zajistíme bezpečnost proti SQL injection. + +Zde je ukázka implementace těchto kroků: ```php $db = new PDO(/* ... */); @@ -31,13 +36,28 @@ $latte->addFilter('escape', fn($val) => match (true) { }); ``` -Použití by vypadalo takto: +Tato escapovací funkce zajišťuje správné ošetření různých datových typů: +- Řetězce jsou escapovány pomocí metody `quote()` databázového driveru. +- Čísla (celá i s plovoucí desetinnou čárkou) jsou převedena na řetězce. +- Booleovské hodnoty jsou převedeny na '1' nebo '0'. +- Null hodnoty jsou převedeny na 'NULL'. +- Pro nepodporované typy je vyhozena výjimka. + +Použití v praxi by pak vypadalo takto: ```php $sql = $latte->renderToString('query.sql.latte', ['country' => $country]); $result = $db->query($sql); ``` -*Uvedený příklad vyžaduje Latte v3.0.5 nebo vyšší.* +Tento přístup umožňuje: +1. Dynamické sestavování SQL dotazů s využitím logiky Latte. +2. Bezpečné vkládání proměnných do dotazu díky vlastní escapovací funkci. +3. Lepší čitelnost a udržovatelnost komplexních SQL dotazů. + +.[note] +Tento příklad vyžaduje Latte ve verzi 3.0.5 nebo novější. + +Využití Latte pro generování SQL dotazů může výrazně zjednodušit práci s komplexními dotazy, zejména v situacích, kdy se dotaz dynamicky mění na základě různých podmínek. Zároveň tento přístup pomáhá udržet kód čistý a snadno upravitelný. {{leftbar: /@left-menu}} diff --git a/latte/cs/cookbook/migration-from-php.texy b/latte/cs/cookbook/migration-from-php.texy index f17181af91..2bec5df959 100644 --- a/latte/cs/cookbook/migration-from-php.texy +++ b/latte/cs/cookbook/migration-from-php.texy @@ -2,27 +2,30 @@ Migrace z PHP do Latte ********************** .[perex] -Převádíte starý projekt napsaný v čistém PHP do Latte? Máme pro vás nástroj, které vám migraci usnadní. [Vyzkoušejte jej online |https://php2latte.nette.org]. +Převádíte starší projekt napsaný v čistém PHP na Latte? Máme pro vás nástroj, který tento proces výrazně zjednoduší. [Vyzkoušejte jej online |https://php2latte.nette.org]. -Nástroj si můžete stáhnout z [GitHubu|https://github.com/nette/latte-tools] nebo nainstalovat pomocí Composeru: +Tento užitečný nástroj můžete získat dvěma způsoby: + +1. Stáhnout z [GitHubu|https://github.com/nette/latte-tools] +2. Nainstalovat pomocí Composeru: ```shell composer create-project latte/tools ``` -Převodník nepoužívá jednoduché záměny pomocí regulárních výrazů, naopak využívá přímo PHP parser, takže si poradí s jakkoliv složitou syntaxí. +Na rozdíl od jednoduchých nástrojů využívajících regulární výrazy, tento převodník používá sofistikovaný PHP parser. Díky tomu si poradí i s komplexní PHP syntaxí. -K převodu z PHP do Latte slouží skript `php-to-latte.php`: +Pro převod z PHP do Latte použijte skript `php-to-latte.php`: ```shell php-to-latte.php input.php [output.latte] ``` -Příklad -------- +Příklad použití +--------------- -Vstupní soubor může vypadat třeba takto (jde o část kódu fóra PunBB): +Podívejme se na konkrétní příklad. Níže je ukázka vstupního PHP souboru (část kódu fóra PunBB): ```php

@@ -48,7 +51,7 @@ foreach ($result as $cur_group) {
``` -Vygeneruje tuto šablonu: +Po zpracování nástrojem získáme následující Latte šablonu: ```latte

{$lang_common['User list']}

@@ -69,4 +72,13 @@ Vygeneruje tuto šablonu: ``` +Hlavní výhody tohoto převodu: + +1. **Čistší syntaxe**: Latte šablona je čitelnější a snáze udržovatelná. +2. **Automatické escapování**: Latte automaticky escapuje výstup, čímž zvyšuje bezpečnost (např. `htmlspecialchars()` již není potřeba). +3. **Lepší struktura**: Latte tagy (`{foreach}`, `{if}`) jasně oddělují logiku od prezentace. +4. **Zjednodušení**: Odstraňuje nutnost explicitního výpisu pomocí `echo`. + +Tento nástroj významně urychluje a zjednodušuje proces migrace z PHP na Latte, což vám umožní rychleji modernizovat vaše projekty a využít všech výhod, které Latte nabízí. + {{leftbar: /@left-menu}} diff --git a/latte/cs/cookbook/migration-from-twig.texy b/latte/cs/cookbook/migration-from-twig.texy index 4ded46f341..8a7fb5bd9c 100644 --- a/latte/cs/cookbook/migration-from-twig.texy +++ b/latte/cs/cookbook/migration-from-twig.texy @@ -2,37 +2,40 @@ Migrace z Twigu do Latte ************************ .[perex] -Převádíte projekt napsaný v Twigu do modernějšího Latte? Máme pro vás nástroj, které vám migraci usnadní. [Vyzkoušejte jej online |https://twig2latte.nette.org]. +Převádíte projekt z Twigu na modernější a mnohem bezpečnější Latte? Máme pro vás nástroj, který tento proces výrazně zjednoduší. [Vyzkoušejte jej online |https://twig2latte.nette.org]. -Nástroj si můžete stáhnout z [GitHubu|https://github.com/nette/latte-tools] nebo nainstalovat pomocí Composeru: +Tento užitečný nástroj je dostupný dvěma způsoby: + +1. Stažením z [GitHubu|https://github.com/nette/latte-tools] +2. Instalací pomocí Composeru: ```shell composer create-project latte/tools ``` -Převodník nepoužívá jednoduché záměny pomocí regulárních výrazů, naopak využívá přímo Twig parser, takže si poradí s jakkoliv složitou syntaxí. +Na rozdíl od jednoduchých nástrojů využívajících regulární výrazy, tento převodník používá sofistikovaný Twig parser. Díky tomu si poradí i s komplexní Twig syntaxí. -K převodu z Twigu do Latte slouží skript `twig-to-latte.php`: +Pro převod z Twigu do Latte použijte skript `twig-to-latte.php`: ```shell twig-to-latte.php input.twig.html [output.latte] ``` -Konverze --------- +Konverze a její specifika +------------------------- -Převod předpokládá ruční úpravu výsledku, protože konverzi nelze provést jednoznačně. Twig používá tečkovou syntax, kde `{{ a.b }}` může znamenat `$a->b`, `$a['b']` nebo `$a->getB()`, což nelze rozlišit při kompilaci. Převaděč proto vše převádí na `$a->b`. +Je důležité poznamenat, že převod může vyžadovat ruční úpravy výsledku. Důvodem je, že některé konstrukce v Twigu nelze jednoznačně převést do Latte. Například, Twig používá tečkovou syntax, kde `{{ a.b }}` může znamenat `$a->b`, `$a['b']` nebo `$a->getB()`. Tento rozdíl nelze rozlišit při kompilaci, proto převaděč vše převádí na `$a->b`. -Některé funkce, filtry nebo tagy nemají obdobu v Latte, nebo se mohou chovat mírně jinak. +Některé funkce, filtry nebo tagy v Twigu nemají přímou obdobu v Latte, nebo se mohou chovat mírně odlišně. To je další důvod, proč může být potřeba ruční úprava po automatickém převodu. -Příklad -------- +Příklad použití +--------------- -Vstupní soubor může vypadat třeba takto: +Podívejme se na konkrétní příklad. Níže je ukázka vstupního Twig souboru: -```latte +```twig {% use "blocks.twig" %} @@ -54,7 +57,7 @@ Vstupní soubor může vypadat třeba takto: ``` -Po konverzi do Latte získáme tuto šablonu: +Po konverzi do Latte získáme následující šablonu: ```latte {import 'blocks.latte'} @@ -78,4 +81,15 @@ Po konverzi do Latte získáme tuto šablonu: ``` +Hlavní rozdíly a výhody po převodu: + +1. **Změna syntaxe**: Twig používá `{% ... %}` pro logiku a `{{ ... }}` pro výpis, zatímco Latte používá jednotnou `{ ... }` syntaxi +2. **Bloky**: `{% block ... %}` se mění na `{block ...}` +3. **Cykly**: `{% for ... %}` se převádí na `{foreach ...}` +4. **Podmínky**: `{% if ... %}` zůstává podobné, ale používá se `{if ...}`. +5. **Přístup k proměnným**: Tečková notace `item.caption` se mění na objektovou notaci `$item->caption` +6. **Import**: `{% use ... %}` se mění na `{import ...}` + +Tento nástroj významně urychluje a zjednodušuje proces migrace z Twigu na Latte. Umožňuje vám rychle modernizovat vaše projekty a využít všech výhod, které Latte nabízí, včetně jeho výkonu a flexibilnity. Nezapomeňte však po automatickém převodu zkontrolovat a případně upravit výsledný kód, aby plně odpovídal vašim potřebám a specifikům vašeho projektu. + {{leftbar: /@left-menu}} diff --git a/latte/cs/cookbook/passing-variables.texy b/latte/cs/cookbook/passing-variables.texy index b4840427c2..7bb477af7a 100644 --- a/latte/cs/cookbook/passing-variables.texy +++ b/latte/cs/cookbook/passing-variables.texy @@ -1,14 +1,14 @@ Předávání proměnných napříč šablonami ************************************* -Tento průvodce vám vysvětlí, jak se proměnné předávají mezi šablonami v Latte pomocí různých tagů jako `{include}`, `{import}`, `{embed}`, `{layout}`, `{sandbox}` a dalších. Dozvíte se také, jak pracovat s proměnnými v tagu `{block}` a `{define}`, a k čemu slouží značka `{parameters}`. +Tento průvodce objasňuje, jak se v Latte předávají proměnné mezi šablonami pomocí různých tagů jako `{include}`, `{import}`, `{embed}`, `{layout}`, `{sandbox}` a dalších. Dozvíte se také, jak pracovat s proměnnými v tagu `{block}` a `{define}`, a k čemu slouží značka `{parameters}`. Typy proměnných --------------- -Proměnné v Latte můžeme rozdělit do tří kategorií podle toho, jak a kde jsou definovány: +V Latte rozlišujeme tři kategorie proměnných podle jejich definice a dostupnosti: -**Vstupní proměnné** jsou ty, které jsou do šablony předávány zvenčí, například z PHP skriptu nebo pomocí tagu jako `{include}`. +**Vstupní proměnné** jsou předávány do šablony zvenčí, typicky z PHP skriptu nebo pomocí tagů jako `{include}`. ```php $latte->render('template.latte', ['userName' => 'Jan', 'userAge' => 30]); @@ -45,7 +45,7 @@ Tag `{block}` se používá k definování opakovaně použitelných bloků kód `{define}` ---------- -Tag `{define}` slouží k vytváření bloků, které se renderují až po jejich zavolání pomocí `{include}`. Proměnné dostupné uvnitř těchto bloků závisí na tom, zda jsou v definici uvedeny parametry. Pokud ano, přístup mají jen k těmto parametrům. Pokud ne, přístup mají ke všem vstupním proměnným šablony, ve které jsou bloky definovány. +Tag `{define}` vytváří bloky, které se renderují až po jejich explicitním zavolání pomocí `{include}`. Dostupnost proměnných uvnitř těchto bloků závisí na přítomnosti parametrů v definici. S parametry mají bloky přístup pouze k těmto parametrům. Bez parametrů mají přístup ke všem vstupním proměnným šablony, ve které jsou definovány. ```latte {define hello} @@ -60,7 +60,7 @@ Tag `{define}` slouží k vytváření bloků, které se renderují až po jejic `{parameters}` -------------- -Tag `{parameters}` slouží k explicitní deklaraci očekávaných vstupních proměnných na začátku šablony. Tímto způsobem lze snadno dokumentovat očekávané proměnné a jejich datové typy. Také je možné definovat výchozí hodnoty. +Tag `{parameters}` slouží k explicitní deklaraci očekávaných vstupních proměnných na začátku šablony. Tímto způsobem lze efektivně dokumentovat očekávané proměnné a jejich datové typy. Umožňuje také definovat výchozí hodnoty. ```latte {parameters int $age, string $name = 'neznámé'} @@ -70,7 +70,7 @@ Tag `{parameters}` slouží k explicitní deklaraci očekávaných vstupních pr `{include file}` ---------------- -Tag `{include file}` slouží k vložení celé šablony. Této šabloně se předávají jak vstupní proměnné šablony, ve které je značka použita, tak proměnné v ní explicitně definované. Cílová šablona ale může rozsah omezit pomocí `{parameters}`. +Tag `{include file}` vkládá celou šablonu. Do vkládané šablony se předávají vstupní proměnné šablony, ve které je značka použita, spolu s explicitně definovanými proměnnými. Cílová šablona může omezit rozsah přijímaných proměnných pomocí `{parameters}`. ```latte {include 'profile.latte', userId: $user->id} @@ -79,7 +79,7 @@ Tag `{include file}` slouží k vložení celé šablony. Této šabloně se př `{include block}` ----------------- -Když vkládáte blok definovaný ve stejné šabloně, předávají se do něj všechny okolní a explicitně definované proměnné: +Při vkládání bloku definovaného ve stejné šabloně se do něj předávají všechny okolní a explicitně definované proměnné: ```latte {define blockName} @@ -90,9 +90,9 @@ Když vkládáte blok definovaný ve stejné šabloně, předávají se do něj {include blockName} ``` -V tomto příkladu se proměnné `$name` a `$age` předají do bloku `blockName`. Stejným způsobem se chová i `{include parent}`. +V tomto příkladu jsou proměnné `$name` a `$age` předány do bloku `blockName`. Stejně se chová i `{include parent}`. -Při vkládání bloku z jiné šablony jsou předávány pouze vstupní proměnné a explicitně definované. Okolní proměnné nejsou automaticky dostupné. +Při vkládání bloku z jiné šablony se předávají pouze vstupní proměnné a explicitně definované proměnné. Okolní proměnné nejsou automaticky dostupné. ```latte {include blockInOtherTemplate, name: $name, age: $age} @@ -101,7 +101,7 @@ Při vkládání bloku z jiné šablony jsou předávány pouze vstupní proměn `{layout}` nebo `{extends}` --------------------------- -Tyto tagy definují layout, do kterého se předávají vstupní proměnné podřízené šablony a dále proměnné vytvořené v kódu před bloky: +Tyto tagy definují layout, do kterého se předávají vstupní proměnné podřízené šablony a proměnné vytvořené v kódu před bloky: ```latte {layout 'layout.latte'} @@ -134,7 +134,7 @@ Naopak v blocích uvnitř `{embed}` je přístup ke všem okolním proměnným: {var $name = 'Jan'} {embed 'menu.latte', items: $menuItems} {block foo} - {$nam} + {$name} {/block} {/embed} ``` @@ -142,7 +142,7 @@ Naopak v blocích uvnitř `{embed}` je přístup ke všem okolním proměnným: `{import}` ---------- -Tag `{import}` se využívá pro načítání bloků z jiných šablon. Přenáší se jak vstupní, tak explicitně deklarované proměnné do importovaných bloků. +Tag `{import}` se používá pro načítání bloků z jiných šablon. Do importovaných bloků se předávají jak vstupní, tak explicitně deklarované proměnné. ```latte {import 'buttons.latte'} @@ -151,11 +151,13 @@ Tag `{import}` se využívá pro načítání bloků z jiných šablon. Přená `{sandbox}` ----------- -Tag `{sandbox}` izoluje šablonu pro bezpečné zpracování. Proměnné jsou předávány výhradně explicitně. +Tag `{sandbox}` izoluje šablonu pro bezpečné zpracování. Proměnné jsou předávány výhradně explicitně, což zvyšuje kontrolu nad daty vstupujícími do izolovaného prostředí. ```latte {sandbox 'secure.latte', data: $secureData} ``` +Tento mechanismus umožňuje přesnou kontrolu nad tím, jaká data jsou dostupná v izolované šabloně, což je užitečné pro zpracování potenciálně nebezpečného obsahu. + {{leftbar: /@left-menu}} diff --git a/latte/cs/creating-extension.texy b/latte/cs/creating-extension.texy index 24ff44bc2a..7608d85ebc 100644 --- a/latte/cs/creating-extension.texy +++ b/latte/cs/creating-extension.texy @@ -2,25 +2,24 @@ Vytváříme Extension ******************* .[perex] -Tzv. rozšíření je opakovatelně použitelná třída, která může definovat vlastní značky, filtry, funkce, providery, atd. +Rozšíření (extension) je znovupoužitelná třída, která může definovat vlastní značky, filtry, funkce, providery a další prvky pro Latte. Vytváříme je, když chceme své úpravy Latte použít v různých projektech nebo je sdílet s komunitou. -Rozšíření vytváříme tehdy, pokud chceme své úpravy Latte znovu použít v různých projektech nebo je sdílet s ostatními. -Je užitečné vytvářet rozšíření i pro každý webový projekt, které bude obsahovat všechny specifické značky a filtry, které chcete v šablonách projektu využívat. +Rozšíření je užitečné vytvořit i pro každý webový projekt. Může obsahovat všechny specifické značky a filtry, které chcete v šablonách projektu využívat. Třída rozšíření =============== -Rozšíření je třída dědící od [api:Latte\Extension]. Do Latte se registruje pomocí `addExtension()` (případně [konfiguračním souborem |application:configuration#Šablony Latte]): +Rozšíření je třída dědící od [api:Latte\Extension]. Do Latte se registruje pomocí `addExtension()` nebo [konfiguračním souborem |application:configuration#Šablony Latte]: ```php $latte = new Latte\Engine; $latte->addExtension(new MyLatteExtension); ``` -Pokud zaregistrujete vícero rozšíření a ty definují stejně pojmenované tagy, filtry nebo funkce, vyhrává poslední přidané rozšíření. Z toho také plyne, že vaše rozšíření mohou přepisovat nativní značky/filtry/funkce. +Pokud zaregistrujete více rozšíření definujících stejně pojmenované tagy, filtry nebo funkce, platí poslední přidané. To znamená, že vaše rozšíření může přepisovat nativní značky/filtry/funkce. -Kdykoliv v třídě provedete změnu a není vypnutý auto-refresh, Latte automaticky překompiluje vaše šablony. +Kdykoliv provedete změnu ve třídě rozšíření a není vypnutý auto-refresh, Latte automaticky překompiluje vaše šablony. Třída může implementovat kteroukoliv z následujících metod: @@ -76,11 +75,13 @@ abstract class Extension Pro představu, jak rozšíření vypadá, se podívejte na vestavěné "CoreExtension":https://github.com/nette/latte/blob/master/src/Latte/Essential/CoreExtension.php. +Nyní si podrobněji rozebereme jednotlivé metody: + beforeCompile(Latte\Engine $engine): void .[method] --------------------------------------------------- -Volá se před kompilací šablony. Metodu lze využít např. pro inicializace související s kompilací. +Tato metoda se volá před kompilací šablony. Můžete ji využít například pro inicializace související s kompilací. getTags(): array .[method] @@ -102,18 +103,18 @@ public function getTags(): array Značka `n:baz` představuje ryzí n:atribut, tj. jde o značku, kterou lze zapisovat pouze jako atribut. -V případě značek `foo` a `bar` Latte samo rozezná, zda jsou párové, a pokud ano, bude je možné automaticky zapisovat i pomocí n:atributů, včetně variant s prefixy `n:inner-foo` a `n:tag-foo`. +Latte automaticky rozpozná, zda jsou značky `foo` a `bar` párové. Pokud ano, bude je možné zapisovat i pomocí n:atributů, včetně variant s prefixy `n:inner-foo` a `n:tag-foo`. -Pořadí provádění takovýchto n:atributů je dáno jejich pořadím v poli vráceném `getTags()`. Tedy `n:foo` se provede vždy před `n:bar`, i kdyby byly atributy v HTML značce uvedeny v opačném pořadí jako `
`. +Pořadí provádění n:atributů je dáno jejich pořadím v poli vráceném `getTags()`. Tedy `n:foo` se provede vždy před `n:bar`, i kdyby byly atributy v HTML značce uvedeny v opačném pořadí. -Pokud potřebujete stanovit pořadí n:atributů napříč více rozšířeními, použijte pomocnou metodu `order()`, kde parametr `before` a nebo `after` určuje, před nebo za kterými značkami se daná značka zařadí. +Pro stanovení pořadí n:atributů napříč více rozšířeními použijte pomocnou metodu `order()`. Parametry `before` a `after` určují, před nebo za kterými značkami se daná značka zařadí: ```php public function getTags(): array { return [ - 'foo' => self::order([FooNode::class, 'create'], before: 'bar')] - 'bar' => self::order([BarNode::class, 'create'], after: ['block', 'snippet'])] + 'foo' => self::order([FooNode::class, 'create'], before: 'bar'), + 'bar' => self::order([BarNode::class, 'create'], after: ['block', 'snippet']), ]; } ``` @@ -122,7 +123,7 @@ public function getTags(): array getPasses(): array .[method] ---------------------------- -Volá se při kompilaci šablony. Vrací asociativní pole *název pass => callable*, což jsou funkce představující tzv. [#průchody kompilátoru], které procházejí a modifikujou AST. +Volá se při kompilaci šablony. Vrací asociativní pole *název pass => callable*, což jsou funkce představující tzv. [#průchody kompilátoru], které procházejí a modifikují AST. Opět je možné využít pomocnou metodu `order()`. Hodnotou parametrů `before` nebo `after` může být `'*'` s významem před/za všemi. @@ -141,7 +142,7 @@ public function getPasses(): array beforeRender(Latte\Engine $engine): void .[method] -------------------------------------------------- -Volá se před každým vykreslením šablony. Metodu lze využít např. pro inicializaci proměnných používaných při vykreslování. +Volá se před každým vykreslením šablony. Metodu lze využít například pro inicializaci proměnných používaných při vykreslování. getFilters(): array .[method] @@ -181,7 +182,7 @@ public function getFunctions(): array getProviders(): array .[method] ------------------------------- -Volá se před vykreslením šablony. Vrací pole tzv. providers, což jsou zpravidla objekty, které za běhu využívají tagy. Přistupují k nim přes `$this->global->...`. +Volá se před vykreslením šablony. Vrací pole tzv. providerů, což jsou zpravidla objekty, které za běhu využívají tagy. Přistupují k nim přes `$this->global->...`. ```php public function getProviders(): array @@ -198,7 +199,7 @@ public function getProviders(): array getCacheKey(Latte\Engine $engine): mixed .[method] -------------------------------------------------- -Volá se před vykreslením šablony. Vrácená hodnota se stane součástí klíče, jehož hash je obsažen v názvu souboru se zkompilovanou šablonou. Tedy pro různé vrácené hodnoty Latte vygeneruje různé soubory v cache. +Volá se před vykreslením šablony. Vrácená hodnota se stane součástí klíče, jehož hash je obsažen v názvu souboru se zkompilovanou šablonou. Pro různé vrácené hodnoty tedy Latte vygeneruje různé soubory v cache. Jak Latte funguje? @@ -208,20 +209,19 @@ Pro pochopení toho, jak definovat vlastní tagy nebo compiler passes, je nezbyt Kompilace šablon v Latte probíhá zjednodušeně takto: -- Nejprve **lexer** tokenizuje zdrojový kód šablony na malé části (tokeny) pro snadnější zpracování. -- Poté **parser** převede proud tokenů na smysluplný strom uzlů (abstraktní syntaktický strom, AST). -- Nakonec překladač **vygeneruje** z AST třídu PHP, která vykresluje šablonu, a uloží ji do cache. +1. **Lexer** tokenizuje zdrojový kód šablony na menší části (tokeny) pro snadnější zpracování. +2. **Parser** převede proud tokenů na smysluplný strom uzlů (abstraktní syntaktický strom, AST). +3. **Překladač** vygeneruje z AST třídu PHP, která vykresluje šablonu, a uloží ji do cache. Ve skutečnosti je kompilace o něco složitější. Latte **má dva** lexery a parsery: jeden pro HTML šablonu a druhý pro PHP-like kód uvnitř tagů. A také parsování neprobíhá až po tokenizaci, ale lexer i parser běží paralelně ve dvou "vláknech" a koordinují se. Je to raketová věda :-) -Dále své parsovací rutiny mají i všechny tagy. Když parser narazí na tag, zavolá jeho parsovací funkci (vrací je [Extension::getTags()|#getTags]). -Jejich úkolem je naparsovat argumenty značky a v případě párových značek i vnitřní obsah. Vrací *uzel*, který se stane součástí AST. Podrobně v části [#Parsovací funkce tagu]. +Každý tag má svou parsovací rutinu. Když parser narazí na tag, zavolá jeho parsovací funkci (vrací je [Extension::getTags()|#getTags]). Jejich úkolem je naparsovat argumenty značky a v případě párových značek i vnitřní obsah. Vrací *uzel*, který se stane součástí AST. Podrobně v části [#Parsovací funkce tagu]. -Když parser dokončí práci, máme kompletní AST reprezentující šablonu. Kořenovým uzlem je `Latte\Compiler\Nodes\TemplateNode`. Jednotlivé uzly uvnitř stromu pak reprezentují nejen tagy, ale i HTML elementy, jejich atributy, všechny výrazy použité uvnitř značek atd. +Po dokončení parsování máme kompletní AST reprezentující šablonu. Kořenovým uzlem je `Latte\Compiler\Nodes\TemplateNode`. Jednotlivé uzly uvnitř stromu reprezentují nejen tagy, ale i HTML elementy, jejich atributy, všechny výrazy použité uvnitř značek atd. Poté přicházejí na řadu tzv. [#Průchody kompilátoru], což jsou funkce (vrací je [Extension::getPasses()|#getPasses]), které modifikují AST. -Celý proces od načtení obsahu šablony přes parsování až po vygenerování výsledného souboru se dá sekvenčně vykonat tímto kódem, se kterým můžete experimentovat a dumpovat si jednotlivé mezikroky: +Celý proces od načtení obsahu šablony přes parsování až po vygenerování výsledného souboru můžete sekvenčně vykonat tímto kódem: ```php $latte = new Latte\Engine; @@ -285,19 +285,21 @@ Vlastní tagy K definování nové značky jsou zapotřebí tři kroky: -- definování [#parsovací funkce tagu] (zodpovědná za parsování tagu do uzlu) -- vytvoření třídy uzlu (zodpovědné za [#generování PHP kódu] a [#procházení AST]) -- registrace tagu pomocí [Extension::getTags()|#getTags] +1. Definování [#parsovací funkce tagu] (zodpovědná za parsování tagu do uzlu) +2. Vytvoření třídy uzlu (zodpovědné za [#generování PHP kódu] a [#procházení AST]) +3. Registrace tagu pomocí [Extension::getTags()|#getTags] Parsovací funkce tagu --------------------- -Parsování tagů ma na starosti jeho parsovací funkce (ta, kterou vrací [Extension::getTags()|#getTags]). Jejím úkolem je naparsovat a zkontrolovat případné argumenty uvnitř značky (k tomu využívá TagParser). -A dále, pokud je značka párová, požádá TemplateParser o naparsování a vrácení vnitřního obsahu. -Funkce vytvoří a vrátí uzel, který je zpravidla potomkem `Latte\Compiler\Nodes\StatementNode`, a ten se stane součástí AST. +Parsování tagů má na starosti jeho parsovací funkce (ta, kterou vrací [Extension::getTags()|#getTags]). Jejím úkolem je: + +1. Naparsovat a zkontrolovat případné argumenty uvnitř značky (k tomu využívá TagParser). +2. Pokud je značka párová, požádat TemplateParser o naparsování a vrácení vnitřního obsahu. +3. Vytvořit a vrátit uzel, který je zpravidla potomkem `Latte\Compiler\Nodes\StatementNode`, a který se stane součástí AST. -Pro každý uzel si vytváříme třídu, což uděláme teď hned a parsovací funkci do ní elegantně umístíme jako statickou továrnu. Jako příklad si zkusíme vytvořit známý tag `{foreach}`: +Pro každý uzel vytváříme třídu a parsovací funkci do ní umístíme jako statickou továrnu. Jako příklad si vytvoříme známý tag `{foreach}`: ```php use Latte\Compiler\Nodes\StatementNode; @@ -338,7 +340,7 @@ a dále nízkoúrovňový [api:Latte\Compiler\TokenStream] operující přímo s - `$tag->parser->stream->consume(...): Token` - `$tag->parser->stream->tryConsume(...): ?Token` -Latte drobnými způsoby rozšiřuje syntaxi PHP, například o modifikátory, zkrácené ternání operátory, nebo umožňuje jednoduché alfanumerické řetězce psát bez uvozovek. Proto používáme termím *PHP-like* místo PHP. Tudíž metoda `parseExpression()` naparsuje např. `foo` jako `'foo'`. +Latte mírně rozšiřuje syntaxi PHP, například o modifikátory, zkrácené ternání operátory, nebo umožňuje jednoduché alfanumerické řetězce psát bez uvozovek. Proto používáme termín *PHP-like* místo PHP. Metoda `parseExpression()` tedy naparsuje např. `foo` jako `'foo'`. Vedle toho *unquoted-řetězec* je speciálním případem řetězce, který také nemusí být v uvozovkách, ale zároveň nemusí být ani alfanumerický. Jde třeba o cestu k souboru ve značce `{include ../file.latte}`. K jeho naparsování slouží metoda `parseUnquotedStringOrExpression()`. .[note] @@ -416,7 +418,7 @@ Každý uzel musí implementovat metodu `print()`. Vrací PHP kód vykreslujíc Metoda `format(string $mask, ...$args)` akceptuje v masce tyto placeholdery: - `%node` vypisuje Node -- `%dump` vyexporuje hodnotu do PHP +- `%dump` vyexportuje hodnotu do PHP - `%raw` vloží přímo text bez jakékoliv transformace - `%args` vypíše ArrayNode jako argumenty volání funkce - `%line` vypíše komentář s číslem řádku @@ -474,7 +476,7 @@ Všimněte si, že `getIterator()` vrací reference. Právě díky tomu mohou *n .[warning] Pokud má uzel poduzly, je nezbytné tuto metodu implementovat a všechny poduzly zpřístupnit. Jinak by mohla vzniknout bezpečnostní díra. Například režim sandboxu by nebyl schopen kontrolovat poduzly a zajistit, aby v nich nebyly volány nepovolené konstrukce. -Protože klíčové slovo `yield` musí být přítomno v těle metody i pokud nemá žádné podřízené uzly, zapište ji takto: +Pokud uzel nemá žádné poduzly, implementujte metodu takto: ```php public function &getIterator(): \Generator @@ -498,7 +500,7 @@ Pokud vytváříte nový tag pro Latte, je žádoucí, abyste pro něj vytvořil $node = new AuxiliaryNode( // tělo metody print(): fn(PrintContext $context, $argNode) => $context->format('myFunc(%node)', $argNode), - // uzly zpřístupnění přes getIterator() a také předané do metody print(): + // uzly zpřístupněné přes getIterator() a také předané do metody print(): [$argNode], ); ``` @@ -544,9 +546,9 @@ $ast = (new NodeTraverser)->traverse( ); ``` -Modul AST může snadno obsahovat tisíce uzlů a procházení všech uzlů může být pomalé. V některých případech je možné se úplnému procházení vyhnout. +AST může snadno obsahovat tisíce uzlů a procházení všech uzlů může být časově náročné. V některých případech je možné se úplnému procházení vyhnout. -Pokud ve stromu hledáte všechny uzly `Html\ElementNode`, pak víte, že jakmile jednou uvidíte uzel `Php\ExpressionNode`, nemá smysl kontrolovat také všechny jeho podřízené uzly, protože HTML nemůže být uvnitř ve výrazech. V takovém případě můžete traverseru přikázat, aby do uzlu třídy neprováděl rekurzi: +Pokud ve stromu hledáte všechny uzly `Html\ElementNode`, pak víte, že jakmile jednou uvidíte uzel `Php\ExpressionNode`, nemá smysl kontrolovat také všechny jeho podřízené uzly, protože HTML nemůže být uvnitř výrazů. V takovém případě můžete traverseru přikázat, aby do uzlu třídy neprováděl rekurzi: ```php $ast = (new NodeTraverser)->traverse( @@ -578,7 +580,7 @@ $ast = (new NodeTraverser)->traverse( Pomocníci pro uzly ------------------ -Třída [api:Latte\Compiler\NodeHelpers] poskytuje některé metody, které mohou najít uzly AST, které buď splňují určitou podmínku atd. Několik příkladů: +Třída [api:Latte\Compiler\NodeHelpers] poskytuje některé metody, které mohou najít uzly AST, které splňují určitou podmínku atd. Několik příkladů: ```php use Latte\Compiler\NodeHelpers; @@ -595,3 +597,5 @@ $value = NodeHelpers::toValue($node); // převede statický textový uzel na řetězec $text = NodeHelpers::toText($node); ``` + +Tímto způsobem můžete efektivně procházet a manipulovat s AST stromem ve vašich rozšířeních pro Latte. diff --git a/latte/cs/develop.texy b/latte/cs/develop.texy index 19e8f2d33a..db494d990c 100644 --- a/latte/cs/develop.texy +++ b/latte/cs/develop.texy @@ -5,7 +5,7 @@ Vývojářské postupy Instalace ========= -Nejlepší způsob, jak nainstalovat Latte, je pomocí Composeru: +Nejlepší způsob instalace Latte je pomocí Composeru: ```shell composer require latte/latte @@ -18,22 +18,22 @@ Podporované verze PHP (platí pro poslední setinkové verze Latte): | Latte 3.0 | PHP 8.0 – 8.2 -Jak vykreslit šablonu -===================== +Vykreslení šablony +================== Jak vykreslit šablonu? Stačí k tomu tento jednoduchý kód: ```php $latte = new Latte\Engine; -// adresář pro cache +// nastavení adresáře pro cache $latte->setTempDirectory('/path/to/tempdir'); $params = [ /* proměnné šablony */ ]; -// or $params = new TemplateParameters(/* ... */); +// nebo $params = new TemplateParameters(/* ... */); -// kresli na výstup +// vykreslení na výstup $latte->render('template.latte', $params); -// kresli do proměnné +// vykreslení do proměnné $output = $latte->renderToString('template.latte', $params); ``` @@ -46,23 +46,21 @@ Ukázky použití najdete také v repozitáři [Latte examples |https://github.c Výkon a cache ============= -Šablony v Latte jsou nesmírně rychlé, Latte je totiž kompiluje přímo do PHP kódu a ukládá do cache na disk. Nemají tedy žádnou režii navíc oproti šablonám psaným v čistém PHP. +Šablony v Latte jsou extrémně rychlé, protože se kompilují přímo do PHP kódu a ukládají do cache na disk. Nemají tedy žádnou režii navíc oproti šablonám psaným v čistém PHP. -Cache se automaticky regeneruje pokaždé, když změníte zdrojový soubor. Během vývoje si tedy pohodlně editujete šablony v Latte a změny okamžitě vidíte v prohlížeči. Tuto funkci můžete v produkčním prostředí vypnout a ušetřit tím malinko výkonu: +Cache se automaticky regeneruje při změně zdrojového souboru. Během vývoje tedy pohodlně editujete šablony v Latte a změny okamžitě vidíte v prohlížeči. Pro mírné zvýšení výkonu v produkčním prostředí můžete automatickou regeneraci vypnout: ```php $latte->setAutoRefresh(false); ``` -Při nasazení na produkčním serveru může prvotní vygenerování cache, zejména u rozsáhlejších aplikací, pochopitelně chviličku trvat. Latte má vestavěnou prevenci před "cache stampede":https://en.wikipedia.org/wiki/Cache_stampede. -Jde o situaci, kdy se sejde větší počet souběžných požadavků, které spustí Latte, a protože cache ještě neexistuje, začaly by ji všechny generovat současně. Což by neúměrně zatížilo server. -Latte je chytré a při více souběžných požadavcích generuje cache pouze první vlákno, ostatní čekají a následně ji využíjí. +Při nasazení na produkční server může prvotní vygenerování cache, zejména u rozsáhlých aplikací, chvíli trvat. Latte má vestavěnou prevenci proti "cache stampede":https://en.wikipedia.org/wiki/Cache_stampede, což je situace, kdy velký počet souběžných požadavků spustí generování cache současně, což by mohlo přetížit server. Latte tento problém řeší chytře - při více souběžných požadavcích generuje cache pouze první vlákno, zatímco ostatní čekají a následně využijí vytvořenou cache. Parametry jako třída ==================== -Lepší než předávat proměnné do šablony jako pole je vytvořit si třídu. Získáte tak [typově bezpečný zápis|type-system], [příjemné napovídání v IDE|recipes#Editory a IDE] a cestu pro [registraci filtrů|extending-latte#Filtry pomocí třídy] a [funkcí|extending-latte#Funkce pomocí třídy]. +Místo předávání proměnných do šablony jako pole je lepší vytvořit si třídu. Získáte tak [typově bezpečný zápis|type-system], [příjemné napovídání v IDE|recipes#Editory a IDE] a možnost [registrace filtrů|extending-latte#Filtry pomocí třídy] a [funkcí|extending-latte#Funkce pomocí třídy]. ```php class MailTemplateParameters @@ -89,9 +87,9 @@ $latte->render('mail.latte', new MailTemplateParameters( Vypnutí auto-escapování proměnné ================================ -Pokud proměnná obsahuje řetězec v HTML, můžete ji označit tak, aby ji Latte automaticky (a tedy dvojitě) neescapovalo. Vyhnete se tak potřebě uvádět v šabloně `|noescape`. +Pokud proměnná obsahuje HTML řetězec, můžete ji označit tak, aby ji Latte automaticky (a tedy dvojitě) neescapovalo. Tím se vyhnete potřebě uvádět v šabloně `|noescape`. -Nejjednodušší cestou je řetězec zabalit do objektu `Latte\Runtime\Html`: +Nejjednodušší způsob je zabalit řetězec do objektu `Latte\Runtime\Html`: ```php $params = [ @@ -99,10 +97,10 @@ $params = [ ]; ``` -Latte dále neescapuje všechny objekty, které implementují rozhraní `Latte\HtmlStringable`. Můžete si tak vytvořit vlastní třídu, jejíž metoda `__toString()` bude vracet HTML kód, který se nebude automaticky escapovat: +Latte také neescapuje objekty implementující rozhraní `Latte\HtmlStringable`. Můžete si vytvořit vlastní třídu, jejíž metoda `__toString()` bude vracet HTML kód, který se nebude automaticky escapovat: ```php -class Emphasis extends Latte\HtmlStringable +class Emphasis implements Latte\HtmlStringable { public function __construct( private string $str, @@ -127,16 +125,14 @@ Metoda `__toString` musí vracet korektní HTML a zajistit escapování parametr Jak rozšířit Latte o filtry, značky atd. ======================================== -Jak do Latte přidat vlastní filtr, funkci, značku atd? O tom pojednává kapitola [rozšiřujeme Latte |extending-latte]. +Informace o přidávání vlastních filtrů, funkcí, značek atd. najdete v kapitole [rozšiřujeme Latte |extending-latte]. Pokud chcete své úpravy znovu použít v různých projektech nebo je sdílet s ostatními, měli byste [vytvořit rozšíření |creating-extension]. -Libovolný kód v šabloně `{php ...}` .{toc: RawPhpExtension} -=========================================================== +Libovolný PHP kód v šabloně `{php ...}` .{toc: RawPhpExtension} +=============================================================== -Uvnitř značky [`{do}`|tags#do] lze zapisovat pouze PHP výrazy, nemůžete tak třeba vložit konstrukce jako `if ... else` nebo statementy ukončené středníkem. - -Můžete si však zaregistrovat rozšíření `RawPhpExtension`, které přidává značku `{php ...}`. Pomocí té lze vkládat jakýkoliv PHP kód. Nevztahují se na něj žádná pravidla sandbox režimu, použití je tedy na zodpovědnost autora šablony. +Zatímco uvnitř značky [`{do}`|tags#do] lze zapisovat pouze PHP výrazy, rozšíření `RawPhpExtension` přidává značku `{php ...}`, která umožňuje vkládat jakýkoliv PHP kód. Použití je na zodpovědnost autora šablony, protože se na ni nevztahují pravidla sandbox režimu. ```php $latte->addExtension(new Latte\Essential\RawPhpExtension); @@ -146,12 +142,10 @@ $latte->addExtension(new Latte\Essential\RawPhpExtension); Kontrola vygenerovaného kódu .{data-version:3.0.7} ================================================== -Latte kompiluje šablony do PHP kódu. Samozřejmě dbá na to, aby vygenerovaný kód byl syntakticky validní. Nicméně při použítí rozšíření třetích stran nebo `RawPhpExtension` nemůže Latte zaručit správnost vygenerovaného souboru. -Také lze v PHP zapsat kód, který je sice syntakticky správný, ale je zakázaný (například přiřazení hodnoty do proměnné `$this`) a způsobí PHP Compile Error. +Latte kompiluje šablony do PHP kódu a dbá na jeho syntaktickou správnost. Nicméně při použití rozšíření třetích stran nebo `RawPhpExtension` nemůže Latte zaručit korektnost vygenerovaného souboru. V PHP lze také zapsat kód, který je syntakticky správný, ale zakázaný (například přiřazení hodnoty do `$this`) a způsobí PHP Compile Error. Pokud takovou operaci zapíšete v šabloně, dostane se i do vygenerovaného PHP kódu. Jelikož v PHP existují na dvě stovky různých zakázaných operací, nemá Latte ambici je odhalovat. Upozorní na ně až samotné PHP při vykreslení, což obvykle ničemu nevadí. -Jsou ale situace, kdy chcete vědět už v době kompilace šablony, že žádný PHP Compile Error neobsahuje. Zejména tehdy, pokud šablony mohou editovat uživatelé, nebo používáte [Sandbox]. V takovém případě si nechte šablony kontrolovat už v době kompilace. -Tuto funkčnost zapnete metodou `Engine::enablePhpLint()`. Jelikož ke kontrole potřebuje volat binárku PHP, cestu k ní předejte jako parametr: +Pokud chcete odhalit tyto problémy už v době kompilace šablony, zejména pokud šablony mohou editovat uživatelé nebo používáte [Sandbox], můžete zapnout kontrolu pomocí `Engine::enablePhpLint()`. Ke kontrole je potřeba volat binárku PHP, jejíž cestu předáte jako parametr: ```php $latte = new Latte\Engine; @@ -185,7 +179,7 @@ Vyžaduje PHP rozšíření `intl`. Nastavení v Latte neovlivňuje globální n Striktní režim .{data-version:3.0.8} ==================================== -Ve striktním režimu parsování Latte kontroluje, zda nechybí uzavírací HTML značky a také zakazuje používání proměnné `$this`. Zapnete jej takto: +Ve striktním režimu parsování Latte kontroluje, zda nechybí uzavírací HTML značky a zakazuje používání proměnné `$this`. Zapnete jej takto: ```php $latte = new Latte\Engine; @@ -203,7 +197,7 @@ $latte->setStrictTypes(); Překládání v šablonách .{toc: TranslatorExtension} ================================================== -Pomocí rozšíření `TranslatorExtension` přidáte do šablony značky [`{_...}`|tags#_], [`{translate}`|tags#translate] a filtr [`translate`|filters#translate]. Slouží k překládání hodnot nebo částí šablony do jiných jazyků. Jako parametr uvedeme metodu (PHP callable) provádějící překlad: +Rozšíření `TranslatorExtension` přidává do šablony značky [`{_...}`|tags#_], [`{translate}`|tags#translate] a filtr [`translate`|filters#translate] pro překládání hodnot nebo částí šablony do jiných jazyků. Jako parametr uvedeme metodu provádějící překlad: ```php class MyTranslator @@ -249,7 +243,7 @@ public function translate(string $original, ...$params): string Debuggování a Tracy =================== -Latte se vám snaží vývoj co nejvíce zpříjemnit. Přímo pro účely debugování existuje trojice značek [`{dump}`|tags#dump], [`{debugbreak}`|tags#debugbreak] a [`{trace}`|tags#trace]. +Latte se vám snaží vývoj co nejvíce zpříjemnit. Nabízí několik nástrojů pro debugování, včetně značek [`{dump}`|tags#dump], [`{debugbreak}`|tags#debugbreak] a [`{trace}`|tags#trace]. Největší komfort získáte, když ještě si nainstalujete skvělý [ladicí nástroj Tracy|tracy:] a aktivujete doplněk pro Latte: @@ -267,13 +261,13 @@ Zároveň v pravém dolním rohu v tzv. Tracy Baru se objeví záložka pro Latt [* latte-debugging.webp *] -Jelikož Latte kompiluje šablony do přehledného PHP kódu, můžete je pohodlně ve svém IDE krokovat. +Jelikož Latte kompiluje šablony do přehledného PHP kódu, můžete je pohodlně krokovat ve svém IDE. Linter: validace syntaxe šablon .{toc: Linter} ============================================== -Projít všechny šablony a zkontrolovat, zda neobsahují syntaktické chyby, vám pomůže nástroj Linter. Spouští se z konzole: +Pro kontrolu syntaxe všech šablon můžete použít nástroj Linter, který se spouští z konzole: ```shell vendor/bin/latte-lint @@ -281,31 +275,30 @@ vendor/bin/latte-lint Parametrem `--strict` aktivujete [striktní režim|#striktní režim]. -Pokud používáte vlastní značky, vytvořte si také vlastní verzi Linteru, např. `custom-latte-lint`: +Pokud používáte vlastní značky, vytvořte si vlastní verzi Linteru, např. `custom-latte-lint`: ```php #!/usr/bin/env php getEngine(); -// tady přidejte jednotlivá svá rozšíření +// zde přidejte svá rozšíření $latte->addExtension(/* ... */); $ok = $linter->scanDirectory($path); exit($ok ? 0 : 1); ``` -Alternativně můžete vlastní objekt `Latte\Engine` předat do Linteru: +Alternativně můžete předat vlastní objekt `Latte\Engine` do Linteru: ```php $latte = new Latte\Engine; -// tady nakonfigurujeme objekt $latte +// zde nakonfigurujeme objekt $latte $linter = new Latte\Tools\Linter(engine: $latte); ``` @@ -313,7 +306,7 @@ $linter = new Latte\Tools\Linter(engine: $latte); Načítání šablon z řetězce ========================= -Potřebujete načítat šablony z řetězců místo souborů, třeba pro účely testování? Pomůže vám [StringLoader|extending-latte#stringloader]: +Pro načítání šablon z řetězců, například pro účely testování, můžete použít [StringLoader|extending-latte#stringloader]: ```php $latte->setLoader(new Latte\Loaders\StringLoader([ @@ -359,4 +352,4 @@ $latte = new Latte\Engine; $latte->addProvider('coreParentFinder', $finder); ``` -Pokud šablona nemá mít layout, oznámí to značkou `{layout none}`. +Pokud šablona nemá mít layout, použije se značka `{layout none}`. diff --git a/latte/cs/extending-latte.texy b/latte/cs/extending-latte.texy index 15442df8e8..3a4089c0aa 100644 --- a/latte/cs/extending-latte.texy +++ b/latte/cs/extending-latte.texy @@ -2,74 +2,76 @@ Rozšiřujeme Latte ***************** .[perex] -Latte je velmi flexibilní a lze jej rozšířit mnoha způsoby: můžete přidat vlastní filtry, funkce, značky, loadery atd. Ukážeme si jak na to. +Latte je mimořádně flexibilní šablonovací systém, který můžete přizpůsobit svým potřebám mnoha způsoby. Ať už potřebujete přidat vlastní filtry, funkce, značky nebo změnit způsob načítání šablon, Latte vám to umožní. Pojďme se podívat, jak na to. -Tato kapitola popisuje jednotlivé cesty rozšiřování Latte. Pokud chcete své úpravy znovu použít v různých projektech nebo je sdílet s ostatními, měli byste [vytvořit tzv. rozšíření |creating-extension]. +Tato kapitola vás provede různými metodami rozšíření Latte. Pokud plánujete své rozšíření použít ve více projektech nebo ho sdílet s komunitou, doporučujeme vytvořit [samostatné rozšíření |creating-extension]. Kolik cest vede do Říma? ======================== -Protože některé způsoby rozšíření Latte mohou splývat, zkusíme si nejprve vysvětlit rozdíly mezi nimi. Jako příklad se pokusíme implementovat generátor *Lorem ipsum*, kterému předáme počet slov, jenž má vygenerovat. +Jelikož některé způsoby rozšíření Latte mohou být podobné, pojďme si nejprve objasnit rozdíly mezi nimi. Jako příklad implementujeme generátor textu *Lorem ipsum*, kterému předáme požadovaný počet slov. -Hlavní konstrukcí jazyka Latte je značka (tag). Generátor můžeme implementovat rozšířením jazyka Latte o nový tag: +Základním stavebním kamenem jazyka Latte je značka (tag). Generátor bychom mohli implementovat jako novou značku: ```latte {lipsum 40} ``` +Tato značka by fungovala dobře, ale nemusí být dostatečně flexibilní, protože ji nelze použít ve výrazech. Mimochodem, v praxi je potřeba vytvářet nové značky jen zřídka, což je dobrá zpráva, protože jde o složitější způsob rozšíření. -Tag bude skvěle fungovat. Nicméně generátor v podobě tagu nemusí být dostatečně flexibilní, protože jej nelze použít ve výrazu. Mimochodem v praxi potřebujete tagy vytvářet jen zřídka; a to je dobrá zpráva, protože tagy jsou složitějším způsobem rozšíření. - -Dobrá, zkusme místo tagu vytvořit filtr: +Zkusme místo značky vytvořit filtr: ```latte {=40|lipsum} ``` -Opět validní možnost. Ale filtr by měl předanou hodnotu transformovat na něco jiného. Zde hodnotu `40`, která udává počet vygenerovaných slov, používáme jako argument filtru, nikoli jako hodnotu, kterou chceme transformovat. +To je také platná možnost. Avšak filtr by měl typicky transformovat předanou hodnotu. V tomto případě hodnotu `40`, která určuje počet generovaných slov, používáme jako argument filtru, nikoli jako hodnotu k transformaci. -Tak zkusíme použít funkci: +Pojďme tedy zkusit funkci: ```latte {lipsum(40)} ``` -To je ono! Pro tento konkrétní příklad je vytvoření funkce ideálním způsobem rozšíření. Můžete ji volat kdekoli, kde je akceptován výraz, například: +To je ono! Pro tento konkrétní případ je vytvoření funkce ideálním způsobem rozšíření. Můžete ji volat kdekoli, kde je povolen výraz, například: ```latte {var $text = lipsum(40)} ``` +Tento příklad ukazuje, že výběr správného způsobu rozšíření závisí na konkrétním použití. Nyní se pojďme podívat na jednotlivé metody podrobněji. + Filtry ====== -Filtr vytvoříme zaregistrováním jeho názvu a libovolného PHP callable, třeba funkce: +Filtry jsou mocné nástroje pro transformaci dat přímo v šabloně. Vytvořit vlastní filtr je jednoduché: ```php $latte = new Latte\Engine; -$latte->addFilter('shortify', fn(string $s) => mb_substr($s, 0, 10)); // zkrátí text na 10 písmen +$latte->addFilter('shortify', fn(string $s) => mb_substr($s, 0, 10)); // zkrátí text na 10 znaků ``` -V tomto případě by bylo šikovnější, kdyby filtr přijímal další parametr: +V tomto případě by bylo užitečné, kdyby filtr přijímal další parametr: ```php $latte->addFilter('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len)); ``` -V šabloně se potom volá takto: +V šabloně se pak volá takto: ```latte

{$text|shortify}

{$text|shortify:100}

``` -Jak vidíte, funkce obdrží levou stranu filtru před pipe `|` jako první argument a argumenty předané filtru za `:` jako další argumenty. +Všimněte si, že: +- První argument filtru je vždy hodnota nalevo od `|` +- Další argumenty se předávají za dvojtečkou +- Filtry mohou mít libovolný počet argumentů, včetně volitelných -Funkce představující filtr může samozřejmě přijímat libovolný počet parametrů, podporovány jsou i variadic parametry. - -Pokud filtr vrací řetězec v HTML, můžete jej označit tak, aby jej Latte automaticky (a tedy dvojitě) neescapovalo. Vyhnete se tak potřebě uvádět v šabloně `|noescape`. -Nejjednodušší cestou je řetězec zabalit do objektu `Latte\Runtime\Html`, druhou cestu představují [Kontextové filtry|#Kontextové filtry]. +Pokud filtr vrací řetězec v HTML, můžete jej označit tak, aby jej Latte automaticky (a tedy dvojitě) neescapovalo. Tím se vyhnete nutnosti používat v šabloně `|noescape`. +Nejjednodušší způsob je obalit řetězec do objektu `Latte\Runtime\Html`, alternativou jsou [Kontextové filtry|#Kontextové filtry]. ```php $latte->addFilter('money', fn(float $amount) => new Latte\Runtime\Html("$amount Kč")); @@ -82,19 +84,19 @@ Filtr musí v takovém případě zajistit správné escapování dat. Filtry pomocí třídy ------------------- -Druhým způsobem definice filtru je [využití třídy|develop#Parametry jako třída]. Vytvoříme metodu s atributem `TemplateFilter`: +Alternativním způsobem definice filtru je [využití třídy|develop#Parametry jako třída]. Vytvoříme metodu s atributem `TemplateFilter`: ```php class TemplateParameters { public function __construct( - // parameters + // parametry ) {} #[Latte\Attributes\TemplateFilter] public function shortify(string $s, int $len = 10): string { - return mb_substr($s, 0, $len); + return mb_substr($s, 0, $len) . (mb_strlen($s) > $len ? '...' : ''); } } @@ -102,11 +104,13 @@ $params = new TemplateParameters(/* ... */); $latte->render('template.latte', $params); ``` +Tento přístup je zvláště užitečný, když máte více filtrů nebo když filtry potřebují přístup ke sdíleným zdrojům. + Zavaděč filtrů -------------- -Místo registrace jednotlivých filtrů lze vytvořit tzv. zavaděč, což je funkce, které se zavolá s názvem filtru jako argumentem a vrátí jeho PHP callable, nebo null. +Místo registrace jednotlivých filtrů lze vytvořit tzv. zavaděč. Jde o funkci, která se volá s názvem filtru jako argumentem a vrací jeho PHP callable, nebo null. ```php $latte->addFilterLoader([new Filters, 'load']); @@ -131,11 +135,13 @@ class Filters } ``` +Tento přístup umožňuje dynamicky načítat filtry podle potřeby, což může být užitečné v rozsáhlých aplikacích. + Kontextové filtry ----------------- -Kontextový filtr je takový, který v prvním parametru přijímá objekt [api:Latte\Runtime\FilterInfo] a teprve po něm následují další parametry jako u klasických filtrů. Registruje se stejný způsobem, Latte samo rozpozná, že filtr je kontextový: +Kontextové filtry jsou speciální typ filtrů, které mají přístup k dodatečným informacím o kontextu, ve kterém jsou použity: ```php use Latte\Runtime\FilterInfo; @@ -147,13 +153,13 @@ $latte->addFilter('foo', function (FilterInfo $info, string $str): string { Kontextové filtry mohou zjišťovat a měnit content-type, který obdrží v proměnné `$info->contentType`. Pokud se filtr volá klasicky nad proměnnou (např. `{$var|foo}`), bude `$info->contentType` obsahovat null. -Filtr by měl nejprve ověřit, zda content-type vstupního řetězce podporuje. A může ho také změnit. Příklad filtru, který přijímá text (nebo null) a vrací HTML: +Filtr by měl nejprve ověřit, zda podporuje content-type vstupního řetězce. Může ho také změnit. Příklad filtru, který přijímá text (nebo null) a vrací HTML: ```php use Latte\Runtime\FilterInfo; $latte->addFilter('money', function (FilterInfo $info, float $amount): string { - // nejprve oveříme, zda je vstupem content-type text + // nejprve ověříme, zda je vstupem content-type text if (!in_array($info->contentType, [null, ContentType::Text])) { throw new Exception("Filter |money used in incompatible content type $info->contentType."); } @@ -173,9 +179,9 @@ Všechny filtry, které se používají nad [bloky|tags#block] (např. jako `{bl Funkce ====== -V Latte lze standardně používat všechny nativní funkce z PHP, pokud to nezakáže sandbox. Ale zároveň si můžete definovat funkce vlastní. Mohou přepsat funkce nativní. +V Latte lze standardně používat všechny nativní funkce PHP, pokud to nezakáže sandbox. Zároveň si můžete definovat vlastní funkce, které mohou přepsat i nativní funkce. -Funkci vytvoříme zaregistrováním jejího názvu a libovolného PHP callable: +Funkci vytvoříme registrací jejího názvu a libovolného PHP callable: ```php $latte = new Latte\Engine; @@ -184,7 +190,7 @@ $latte->addFunction('random', function (...$args) { }); ``` -Použití je pak stejné, jako když voláte PHP funkci: +Použití je pak stejné jako při volání PHP funkce: ```latte {random(jablko, pomeranč, citron)} // vypíše například: jablko @@ -194,13 +200,13 @@ Použití je pak stejné, jako když voláte PHP funkci: Funkce pomocí třídy ------------------- -Druhým způsobem definice funkce je [využití třídy|develop#Parametry jako třída]. Vytvoříme metodu s atributem `TemplateFunction`: +Alternativním způsobem definice funkce je [využití třídy|develop#Parametry jako třída]. Vytvoříme metodu s atributem `TemplateFunction`: ```php class TemplateParameters { public function __construct( - // parameters + // parametry ) {} #[Latte\Attributes\TemplateFunction] @@ -214,17 +220,19 @@ $params = new TemplateParameters(/* ... */); $latte->render('template.latte', $params); ``` +Tento přístup je užitečný pro organizaci souvisejících funkcí a sdílení zdrojů mezi nimi. + Loadery ======= -Loadery jsou zodpovědné za načítání šablon ze zdroje, například ze souborového systému. Nastaví se metodou `setLoader()`: +Loadery jsou zodpovědné za načítání šablon ze zdroje, například ze souborového systému. Nastavují se metodou `setLoader()`: ```php $latte->setLoader(new MyLoader); ``` -Vestavěné loadery jsou tyto: +Latte nabízí tyto vestavěné loadery: FileLoader @@ -232,7 +240,7 @@ FileLoader Výchozí loader. Načítá šablony ze souborového systému. -Přístup k souborům je možné omezit nastavením základního adresáře: +Přístup k souborům lze omezit nastavením základního adresáře: ```php $latte->setLoader(new Latte\Loaders\FileLoader($templateDir)); @@ -243,7 +251,7 @@ $latte->render('test.latte'); StringLoader ------------ -Načítá šablony z řetězců. Tento loader je velmi užitečný pro testování. Lze jej také použít pro malé projekty, kde může mít smysl ukládat všechny šablony do jediného souboru PHP. +Načítá šablony z řetězců. Tento loader je velmi užitečný pro testování. Lze jej také použít pro menší projekty, kde může být výhodné ukládat všechny šablony do jediného PHP souboru. ```php $latte->setLoader(new Latte\Loaders\StringLoader([ @@ -272,20 +280,20 @@ Loader je třída, která implementuje rozhraní [api:Latte\Loader]. Tagy (makra) ============ -Jednou z nejzajímavějších funkcí šablonovacího jádra je možnost definovat nové jazykové konstrukce pomocí značek. Je to také složitější funkčnost a je třeba pochopit, jak Latte interně funguje. +Jednou z nejzajímavějších funkcí šablonovacího jádra je možnost definovat nové jazykové konstrukce pomocí značek. Je to také složitější funkcionalita a vyžaduje pochopení vnitřního fungování Latte. -Většinou však značka není potřeba: -- pokud by měla generovat nějaký výstup, použijte místo ní [funkci|#funkce] -- pokud měla upravovat nějaký vstup a vracet ho, použijte místo toho [filtr|#filtry] -- pokud měla upravovat oblast textu, obalte jej značkou [`{block}`|tags#block] a použijte [filtr|#Kontextové filtry] -- pokud neměla nic vypisovat, ale pouze volat funkci, zavolejte ji pomocí [`{do}`|tags#do] +Ve většině případů však značka není potřeba: +- pokud má generovat nějaký výstup, použijte místo ní [funkci|#funkce] +- pokud má upravovat nějaký vstup a vracet ho, použijte [filtr|#filtry] +- pokud má upravovat oblast textu, obalte jej značkou [`{block}`|tags#block] a použijte [filtr|#Kontextové filtry] +- pokud nemá nic vypisovat, ale pouze volat funkci, použijte [`{do}`|tags#do] -Pokud přesto chcete vytvořit tag, skvěle! Vše podstatné najdete v kapitole [Vytváříme Extension|creating-extension]. +Pokud se přesto rozhodnete vytvořit tag, skvělé! Vše potřebné najdete v kapitole [Vytváříme Extension|creating-extension]. Průchody kompilátoru ==================== -Průchody kompilátoru jsou funkce, které modifikují AST nebo sbírají v nich informace. V Latte je takto implementován například sandbox: projde všechny uzly AST, najde volání funkcí a metod a nahradí je za jím kontrolované volání. +Průchody kompilátoru jsou funkce, které modifikují AST (abstraktní syntaktický strom) nebo z něj sbírají informace. V Latte je takto implementován například sandbox: projde všechny uzly AST, najde volání funkcí a metod a nahradí je za kontrolovaná volání. -Stejně jako v případě značek se jedná o složitější funkcionalitu a je potřeba pochopit, jak funguje Latte pod kapotou. Vše podstatné najdete v kapitole [Vytváříme Extension|creating-extension]. +Stejně jako v případě značek se jedná o složitější funkcionalitu, která vyžaduje pochopení vnitřního fungování Latte. Vše potřebné najdete v kapitole [Vytváříme Extension|creating-extension]. diff --git a/latte/cs/filters.texy b/latte/cs/filters.texy index 0fa1e5a14e..a480d9c021 100644 --- a/latte/cs/filters.texy +++ b/latte/cs/filters.texy @@ -2,113 +2,111 @@ Latte filtry ************ .[perex] -V šablonách můžeme používat funkce, které pomáhají upravit nebo přeformátovat data do výsledné podoby. Říkáme jim *filtry*. +Filtry v šablonách Latte pomáhají upravit nebo přeformátovat data do požadované podoby .[table-latte-filters] |## Transformace -| `batch` | [výpis lineárních dat do tabulky |#batch] -| `breakLines` | [Před konce řádku přidá HTML odřádkování |#breakLines] +| `batch` | [rozdělí lineární data do bloků |#batch] +| `breakLines` | [přidá HTML odřádkování za konce řádků |#breakLines] | `bytes` | [formátuje velikost v bajtech |#bytes] -| `clamp` | [ohraničí hodnotu do daného rozsahu |#clamp] -| `dataStream` | [konverze pro Data URI protokol |#datastream] -| `date` | [formátuje datum a čas|#date] +| `clamp` | [omezí hodnotu do daného rozsahu |#clamp] +| `dataStream` | [převede data do formátu Data URI |#datastream] +| `date` | [formátuje datum a čas |#date] | `explode` | [rozdělí řetězec na pole podle oddělovače |#explode] -| `first` | [vrací první prvek pole nebo znak řetězce |#first] -| `group` | [seskupí data podle různých kritérií |#group] +| `first` | [vrátí první prvek pole nebo znak řetězce |#first] +| `group` | [seskupí data podle zadaných kritérií |#group] | `implode` | [spojí pole do řetězce |#implode] -| `indent` | [odsadí text zleva o daný počet tabulátorů |#indent] +| `indent` | [odsadí text zleva |#indent] | `join` | [spojí pole do řetězce |#implode] -| `last` | [vrací poslední prvek pole nebo znak řetězce |#last] -| `length` | [vrací délku řetězce ve znacích nebo pole |#length] -| `localDate` | [formátuje datum a čas podle národního prostředí|#localDate] +| `last` | [vrátí poslední prvek pole nebo znak řetězce |#last] +| `length` | [vrátí délku řetězce nebo počet prvků pole |#length] +| `localDate` | [formátuje datum a čas podle národního prostředí |#localDate] | `number` | [formátuje číslo |#number] | `padLeft` | [doplní řetězec zleva na požadovanou délku |#padLeft] | `padRight` | [doplní řetězec zprava na požadovanou délku |#padRight] -| `random` | [vrací náhodný prvek pole nebo znak řetězce |#random] -| `repeat` | [opakování řetězce |#repeat] -| `replace` | [zamění výskyty hledaného řetězce |#replace] -| `replaceRE` | [zamění výskyty dle regulárního výrazu |#replaceRE] -| `reverse` | [obrátí UTF‑8 řetězec nebo pole |#reverse] +| `random` | [vrátí náhodný prvek pole nebo znak řetězce |#random] +| `repeat` | [opakuje řetězec |#repeat] +| `replace` | [nahradí výskyty hledaného řetězce |#replace] +| `replaceRE` | [nahradí výskyty podle regulárního výrazu |#replaceRE] +| `reverse` | [obrátí pořadí znaků v řetězci nebo prvků v poli |#reverse] | `slice` | [extrahuje část pole nebo řetězce |#slice] | `sort` | [seřadí pole |#sort] -| `spaceless` | [odstraní bílé místo |#spaceless], podobně jako značka [spaceless |tags] tag +| `spaceless` | [odstraní nadbytečné bílé znaky |#spaceless] | `split` | [rozdělí řetězec na pole podle oddělovače |#explode] -| `strip` | [odstraní bílé místo |#spaceless] -| `stripHtml` | [odstraní HTML značky a HTML entity převede na znaky |#stripHtml] +| `strip` | [odstraní nadbytečné bílé znaky |#spaceless] +| `stripHtml` | [odstraní HTML značky a převede entity na znaky |#stripHtml] | `substr` | [vrátí část řetězce |#substr] -| `trim` | [odstraní počáteční a koncové mezery či jiné znaky |#trim] -| `translate` | [překlad do jiných jazyků |#translate] -| `truncate` | [zkrátí délku se zachováním slov |#truncate] -| `webalize` | [upraví UTF‑8 řetězec do tvaru používaného v URL |#webalize] +| `trim` | [odstraní bílé znaky na začátku a konci řetězce |#trim] +| `translate` | [přeloží text do jiného jazyka |#translate] +| `truncate` | [zkrátí text na danou délku se zachováním slov |#truncate] +| `webalize` | [upraví řetězec pro použití v URL |#webalize] .[table-latte-filters] |## Velikost písmen -| `capitalize` | [malá písmena, první písmeno ve slovech velké |#capitalize] +| `capitalize` | [převede první písmeno každého slova na velké |#capitalize] | `firstUpper` | [převede první písmeno na velké |#firstUpper] -| `lower` | [převede na malá písmena |#lower] -| `upper` | [převede na velká písmena |#upper] +| `lower` | [převede text na malá písmena |#lower] +| `upper` | [převede text na velká písmena |#upper] .[table-latte-filters] |## Zaokrouhlování -| `ceil` | [zaokrouhlí číslo nahoru na danou přesnost |#ceil] -| `floor` | [zaokrouhlí číslo dolů na danou přesnost |#floor] -| `round` | [zaokrouhlí číslo na danou přesnost |#round] +| `ceil` | [zaokrouhlí číslo nahoru |#ceil] +| `floor` | [zaokrouhlí číslo dolů |#floor] +| `round` | [zaokrouhlí číslo |#round] .[table-latte-filters] |## Escapování | `escapeUrl` | [escapuje parametr v URL |#escapeUrl] -| `noescape` | [vypíše proměnnou bez escapování |#noescape] +| `noescape` | [vypne automatické escapování |#noescape] | `query` | [generuje query string v URL |#query] -Dále existují escapovací filtry pro HTML (`escapeHtml` a `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) a iCalendar (`escapeICal`), které Latte používá samo díky [kontextově sensitivnímu escapování|safety-first#Kontextově sensitivní escapování] a nemusíte je zapisovat. +Latte automaticky používá escapovací filtry pro HTML (`escapeHtml` a `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) a iCalendar (`escapeICal`) díky [kontextově sensitivnímu escapování|safety-first#Kontextově sensitivní escapování]. Tyto filtry není třeba explicitně zapisovat. .[table-latte-filters] |## Bezpečnost -| `checkUrl` | [ošetří URL adresu od nebezpečných vstupů |#checkUrl] -| `nocheck` | [předejde automatickému ošetření URL adresy |#nocheck] - -Latte atributy `src` a `href` [kontroluje automaticky |safety-first#Kontrola odkazů], takže filtr `checkUrl` téměř nemusíte používat. +| `checkUrl` | [zkontroluje a případně upraví URL adresu |#checkUrl] +| `nocheck` | [vypne automatickou kontrolu URL adresy |#nocheck] .[note] -Všechny výchozí filtry jsou určeny pro řetězce v kódování UTF‑8. +Všechny výchozí filtry jsou navrženy pro práci s řetězci v kódování UTF-8. Použití ======= -Filtry se zapisují za svislítko (může být před ním mezera): +Filtry se aplikují pomocí svislítka za proměnnou nebo výrazem: ```latte

{$heading|upper}

``` -Filtry (ve starších verzích helpery) lze zřetězit a poté se aplikují v pořadí od levého k pravému: +Filtry lze řetězit, v takovém případě se aplikují zleva doprava: ```latte

{$heading|lower|capitalize}

``` -Parametry se zadávají za jménem filtru oddělené dvojtečkami nebo čárkami: +Parametry filtrů se zadávají za dvojtečkou: ```latte

{$heading|truncate:20,''}

``` -Filtry lze aplikovat i na výraz: +Filtry lze použít i na výrazy: ```latte -{var $name = ($title|upper) . ($subtitle|lower)} +{var $name = ($title|upper) . ($subtitle|lower)} ``` -[Vlastní filtry|extending-latte#filtry] lze registrovat tímto způsobem: +[Vlastní filtry|extending-latte#filtry] se registrují následovně: ```php $latte = new Latte\Engine; $latte->addFilter('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len)); ``` -V šabloně se potom volá takto: +V šabloně se pak volají stejně jako vestavěné filtry: ```latte

{$text|shortify}

@@ -122,7 +120,7 @@ Filtry batch(int length, mixed item): array .[filter] ---------------------------------------------- -Filtr, který zjednodušuje výpis lineárních dat do podoby tabulky. Vrací pole polí se zadaným počtem položek. Pokud zadáte druhý parametr, použije se k doplnění chybějících položek na posledním řádku. +Filtr `batch` usnadňuje výpis lineárních dat do tabulkové struktury. Vrací pole polí s požadovaným počtem položek. Pokud zadáte druhý parametr, použije se k doplnění chybějících položek v posledním řádku. ```latte {var $items = ['a', 'b', 'c', 'd', 'e']} @@ -137,7 +135,7 @@ Filtr, který zjednodušuje výpis lineárních dat do podoby tabulky. Vrací po
``` -Vypíše: +Výstup: ```latte @@ -159,7 +157,7 @@ Viz také [#group] a značka [iterateWhile|tags#iterateWhile]. breakLines .[filter] -------------------- -Přidává před každý znak nového řádku HTML značku `
` +Filtr `breakLines` vkládá HTML značku `
` před každý znak nového řádku. ```latte {var $s = "Text & with \n newline"} @@ -169,17 +167,19 @@ Přidává před každý znak nového řádku HTML značku `
` bytes(int precision = 2) .[filter] ---------------------------------- -Formátuje velikost v bajtech do lidsky čitelné podoby. Pokud je nastavené [národní prostředí |develop#locale], použijí se odpovídající oddělovače desetinných míst a tisíců. +Filtr `bytes` formátuje velikost v bajtech do lidsky čitelné podoby. Pokud je nastaveno [národní prostředí |develop#locale], použijí se odpovídající oddělovače desetinných míst a tisíců. ```latte {$size|bytes} 0 B, 1.25 GB, … {$size|bytes:0} 10 B, 1 GB, … ``` +Viz také [#number]. + ceil(int precision = 0) .[filter] --------------------------------- -Zaokrouhlí číslo nahoru na danou přesnost. +Filtr `ceil` zaokrouhlí číslo nahoru na danou přesnost. ```latte {=3.4|ceil} {* vypíše 4 *} @@ -192,7 +192,7 @@ Viz také [#floor], [#round]. capitalize .[filter] -------------------- -Slova budou začínat velkými písmeny, všechny zbývající znaky budou malá. Vyžaduje PHP rozšíření `mbstring`. +Filtr `capitalize` upraví text tak, že první písmeno každého slova bude velké a zbývající malá. Vyžaduje PHP rozšíření `mbstring`. ```latte {='i like LATTE'|capitalize} {* vypíše 'I Like Latte' *} @@ -203,7 +203,7 @@ Viz také [#firstUpper], [#lower], [#upper]. checkUrl .[filter] ------------------ -Vynutí ošetření URL adresy. Kontroluje, zda proměnná obsahuje webovou URL (tj. protokol HTTP/HTTPS) a předchází vypsání odkazů, které mohou představovat bezpečnostní riziko. +Filtr `checkUrl` zajistí kontrolu a případné ošetření URL adresy. Ověří, zda proměnná obsahuje webovou URL (tj. protokol HTTP/HTTPS) a zabrání vypsání odkazů, které by mohly představovat bezpečnostní riziko. ```latte {var $link = 'javascript:window.close()'} @@ -211,38 +211,40 @@ Vynutí ošetření URL adresy. Kontroluje, zda proměnná obsahuje webovou URL nekontrolované ``` -Vypíše: +Výstup: ```latte kontrolovanénekontrolované ``` +Latte automaticky [kontroluje atributy |safety-first#Kontrola odkazů] `src` a `href`, takže filtr `checkUrl` většinou není nutné explicitně uvádět. + Viz také [#nocheck]. clamp(int|float min, int|float max) .[filter] --------------------------------------------- -Ohraničí hodnotu do daného inkluzivního rozsahu min a max. +Filtr `clamp` omezí hodnotu do zadaného inkluzivního rozsahu min a max. ```latte {$level|clamp: 0, 255} ``` -Existuje také jako [funkce|functions#clamp]. +K dispozici je také jako [funkce|functions#clamp]. dataStream(string mimetype = detect) .[filter] ---------------------------------------------- -Konvertuje obsah do data URI scheme. Pomocí něj lze do HTML nebo CSS vkládat obrázky bez nutnosti linkovat externí soubory. +Filtr `dataStream` konvertuje obsah do schématu data URI. To umožňuje vkládat obrázky přímo do HTML nebo CSS bez nutnosti odkazovat na externí soubory. -Mějme v proměnné obrázek `$img = Image::fromFile('obrazek.gif')`, poté +Pokud máme v proměnné obrázek `$img = Image::fromFile('obrazek.gif')`, potom ```latte ``` -Vypíše například: +vypíše například: ```latte {$name} @@ -278,13 +280,13 @@ Viz také [#query]. explode(string separator = '') .[filter] ---------------------------------------- -Rozdělí řetězec na pole podle oddělovače. Alias pro `split`. +Filtr `explode` rozdělí řetězec na pole podle zadaného oddělovače. Je to alias pro `split`. ```latte {='one,two,three'|explode:','} {* vrací ['one', 'two', 'three'] *} ``` -Pokud je oddělovač prázdný řetězec (výchozí hodnota), bude vstup rozdělen na jednotlivé znaky: +Pokud je oddělovač prázdný řetězec (výchozí hodnota), vstup se rozdělí na jednotlivé znaky: ```latte {='123'|explode} {* vrací ['1', '2', '3'] *} @@ -301,7 +303,7 @@ Viz také [#implode]. first .[filter] --------------- -Vrací první prvek pole nebo znak řetězce: +Filtr `first` vrací první prvek pole nebo první znak řetězce: ```latte {=[1, 2, 3, 4]|first} {* vypíše 1 *} @@ -313,7 +315,7 @@ Viz také [#last], [#random]. floor(int precision = 0) .[filter] ---------------------------------- -Zaokrouhlí číslo dolů na danou přesnost. +Filtr `floor` zaokrouhlí číslo dolů na danou přesnost. ```latte {=3.5|floor} {* vypíše 3 *} @@ -326,7 +328,7 @@ Viz také [#ceil], [#round]. firstUpper .[filter] -------------------- -Převede první písmeno na velká. Vyžaduje PHP rozšíření `mbstring`. +Filtr `firstUpper` převede první písmeno na velké. Vyžaduje PHP rozšíření `mbstring`. ```latte {='the latte'|firstUpper} {* vypíše 'The latte' *} @@ -337,7 +339,7 @@ Viz také [#capitalize], [#lower], [#upper]. group(string|int|\Closure by): array .[filter]{data-version:3.0.16} ------------------------------------------------------------------- -Filtr seskupí data podle různých kritérií. +Filtr `group` umožňuje seskupit data podle různých kritérií. V tomto příkladu se řádky v tabulce seskupují podle sloupce `categoryId`. Výstupem je pole polí, kde klíčem je hodnota ve sloupci `categoryId`. [Přečtěte si podrobný návod|cookbook/grouping]. @@ -356,7 +358,7 @@ Viz také [#batch], funkce [group|functions#group] a značka [iterateWhile|tags# implode(string glue = '') .[filter] ----------------------------------- -Vrátí řetězec, který je zřetězením položek sekvence. Alias pro `join`. +Filtr `implode` spojí prvky pole do řetězce. Je to alias pro `join`. ```latte {=[1, 2, 3]|implode} {* vypíše '123' *} @@ -372,7 +374,7 @@ Můžete také použít alias `join`: indent(int level = 1, string char = "\t") .[filter] --------------------------------------------------- -Odsadí text zleva o daný počet tabulátorů nebo jiných znaků, které můžeme uvést ve druhém argumentu. Prázdné řádky nejsou odsazeny. +Filtr `indent` odsadí text zleva o zadaný počet tabulátorů nebo jiných znaků. Prázdné řádky nejsou odsazeny. ```latte
@@ -382,7 +384,7 @@ Odsadí text zleva o daný počet tabulátorů nebo jiných znaků, které můž
``` -Vypíše: +Výstup: ```latte
@@ -393,7 +395,7 @@ Vypíše: last .[filter] -------------- -Vrací poslední prvek pole nebo znak řetězce: +Filtr `last` vrací poslední prvek pole nebo poslední znak řetězce: ```latte {=[1, 2, 3, 4]|last} {* vypíše 4 *} @@ -405,13 +407,12 @@ Viz také [#first], [#random]. length .[filter] ---------------- -Vrátí délku řetězce nebo pole. - -- pro řetězce vrátí délku v UTF‑8 znacích -- pro pole vrátí počet položek -- pro objekty, které implementují rozhraní Countable, použije návratovou hodnotu metody count() -- pro objekty, které implementují rozhraní IteratorAggregate, použije návratovou hodnotu funkce iterator_count() +Filtr `length` vrátí délku řetězce nebo počet prvků v poli. +- pro řetězce vrátí počet unicode znaků +- pro pole vrátí počet prvků +- pro objekty implementující rozhraní Countable použije návratovou hodnotu metody count() +- pro objekty implementující rozhraní IteratorAggregate použije návratovou hodnotu funkce iterator_count() ```latte {if ($users|length) > 10} @@ -422,7 +423,7 @@ Vrátí délku řetězce nebo pole. localDate(string format = null, string date = null, string time = null) .[filter] --------------------------------------------------------------------------------- -Formátuje datum a čas podle [národního prostředí |develop#locale], což zajišťuje konzistentní a lokalizované zobrazení časových údajů napříč různými jazyky a regiony. Filtr přijímá datum jako UNIX timestamp, řetězec nebo objekt typu `DateTimeInterface`. +Filtr `localDate` formátuje datum a čas podle [národního prostředí |develop#locale]. To zajišťuje konzistentní a lokalizované zobrazení časových údajů napříč různými jazyky a regiony. Filtr přijímá datum jako UNIX timestamp, řetězec nebo objekt typu `DateTimeInterface`. ```latte {$date|localDate} {* 15. dubna 2024 *} @@ -430,20 +431,20 @@ Formátuje datum a čas podle [národního prostředí |develop#locale], což za {$date|localDate: date: medium} {* 15. 4. 2024 *} ``` -Pokud použijete filtr bez parametrů, vypíše se datum v úrovní `long`, viz dále. +Bez parametrů se datum vypíše v úrovni `long` (viz dále). **a) použití formátu** -Parametr `format` popisuje, které časové složky se mají zobrazit. Používá pro ně písmenné kódy, jejichž počet opakování ovlivňuje šířku výstupu: +Parametr `format` definuje, které časové složky se mají zobrazit. Používá písmena jako kódy, jejichž počet opakování ovlivňuje šířku výstupu: | rok | `y` / `yy` / `yyyy` | `2024` / `24` / `2024` | měsíc | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `srp` / `srpen` | den | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `ne` / `neděle` -| hodina | `j` / `H` / `h` | preferovaný / 24hodinový / 12hodinový +| hodina | `j` / `H` / `h` | preferovaná / 24hodinová / 12hodinová | minuta | `m` / `mm` | `5` / `05` (2 číslice v kombinaci se sekundami) | sekunda | `s` / `ss` | `8` / `08` (2 číslice v kombinaci s minutami) -Na pořadí kódů ve formátu nezáleží, protože pořadí složek se vypíše podle zvyklostí národního prostředí. Formát je tedy na něm nezávislý. Například formát `yyyyMMMMd` v postředí `en_US` vypíše `April 15, 2024`, zatímco v prostředí `cs_CZ` vypíše `15. dubna 2024`: +Pořadí kódů ve formátu nemá vliv na pořadí složek ve výstupu, protože to se řídí zvyklostmi národního prostředí. Formát je tedy na něm nezávislý. Například formát `yyyyMMMMd` v prostředí `en_US` vypíše `April 15, 2024`, zatímco v prostředí `cs_CZ` vypíše `15. dubna 2024`: | locale: | cs_CZ | en_US |--- @@ -458,7 +459,7 @@ Na pořadí kódů ve formátu nezáleží, protože pořadí složek se vypíš **b) použití přednastavených stylů** -Parametry `date` a `time` určují, jak podrobně se má datum a čas vypsat. Můžete si vybrat z několika úrovní: `full`, `long`, `medium`, `short`. Lze nechat vypsat jen datum, jen čas, nebo obojí: +Parametry `date` a `time` určují úroveň podrobnosti pro výpis data a času. K dispozici jsou úrovně: `full`, `long`, `medium`, `short`. Můžete nechat vypsat jen datum, jen čas, nebo obojí: | locale: | cs_CZ | en_US |--- @@ -473,7 +474,7 @@ Parametry `date` a `time` určují, jak podrobně se má datum a čas vypsat. M | `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 -U data lze navíc použít prefix `relative-` (např. `relative-short`), který pro data blízká současnosti zobrazí `včera`, `dnes` nebo `zítra`, jinak se vypíše standardním způsobem. +Pro datum lze použít prefix `relative-` (např. `relative-short`), který pro data blízká současnosti zobrazí `včera`, `dnes` nebo `zítra`, jinak se vypíše standardním způsobem. ```latte {$date|localDate: date: relative-short} {* včera *} @@ -484,7 +485,7 @@ Viz také [#date]. lower .[filter] --------------- -Převede řetězec na malá písmena. Vyžaduje PHP rozšíření `mbstring`. +Filtr `lower` převede řetězec na malá písmena. Vyžaduje PHP rozšíření `mbstring`. ```latte {='LATTE'|lower} {* vypíše 'latte' *} @@ -495,9 +496,9 @@ Viz také [#capitalize], [#firstUpper], [#upper]. nocheck .[filter] ----------------- -Předejde automatickému ošetření URL adresy. Latte [automaticky kontroluje|safety-first#Kontrola odkazů], zda proměnná obsahuje webovou URL (tj. protokol HTTP/HTTPS) a předchází vypsání odkazů, které mohou představovat bezpečnostní riziko. +Filtr `nocheck` vypne automatickou kontrolu URL adresy. Latte standardně [kontroluje |safety-first#Kontrola odkazů], zda proměnná obsahuje webovou URL (tj. protokol HTTP/HTTPS) a brání vypsání potenciálně nebezpečných odkazů. -Pokud odkaz používá jiné schéma, např. `javascript:` nebo `data:`, a jste si jistí jeho obsahem, můžete kontrolu vypnout pomoci `|nocheck`. +Pokud odkaz používá jiné schéma, např. `javascript:` nebo `data:`, a jste si jisti jeho obsahem, můžete kontrolu vypnout pomocí `|nocheck`. ```latte {var $link = 'javascript:window.close()'} @@ -506,7 +507,7 @@ Pokud odkaz používá jiné schéma, např. `javascript:` nebo `data:`, a jste nekontrolované ``` -Vypíše: +Výstup: ```latte kontrolované @@ -518,7 +519,7 @@ Viz také [#checkUrl]. noescape .[filter] ------------------ -Zakáže automatické escapování. +Filtr `noescape` vypne automatické escapování. ```latte {var $trustedHtmlString = 'hello'} @@ -526,7 +527,7 @@ Escapovaný: {$trustedHtmlString} Neescapovaný: {$trustedHtmlString|noescape} ``` -Vypíše: +Výstup: ```latte Escapovaný: <b>hello</b> @@ -534,12 +535,12 @@ Neescapovaný: hello ``` .[warning] -Špatné použití filtru `noescape` může vést ke vzniku zranitelnosti XSS! Nikdy jej nepoužívejte, pokud si nejste **zcela jisti** co děláte, a že vypisovaný řetězec pochází z důvěryhodného zdroje. +Nesprávné použití filtru `noescape` může vést ke zranitelnosti XSS! Používejte jej pouze tehdy, když si jste **naprosto jisti**, že vypisovaný řetězec pochází z důvěryhodného zdroje. number(int decimals = 0, string decPoint = '.', string thousandsSep = ',') .[filter] ------------------------------------------------------------------------------------ -Formátuje číslo na určitý počet desetinných míst. Pokud je nastavené [národní prostředí |develop#locale], použijí se odpovídající oddělovače desetinných míst a tisíců. +Filtr `number` formátuje číslo na zadaný počet desetinných míst. Pokud je nastaveno [národní prostředí |develop#locale], použijí se odpovídající oddělovače desetinných míst a tisíců. ```latte {1234.20|number} 1,234 @@ -551,16 +552,16 @@ Formátuje číslo na určitý počet desetinných míst. Pokud je nastavené [n number(string format) .[filter] ------------------------------- -Parametr `format` umožňuje definovat vzhled čísel přesně podle vašich potřeb. K tomu je potřeba mít nastavené [národní prostředí |develop#locale]. Formát se skládá z několika speciálních znaků, jejichž kompletní popis najdete v dokumentaci "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns: +Parametr `format` umožňuje přesně definovat vzhled čísel podle vašich potřeb. K tomu je nutné mít nastavené [národní prostředí |develop#locale]. Formát se skládá z několika speciálních znaků, jejichž kompletní popis najdete v dokumentaci "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns: - `0` povinná číslice, vždy se zobrazí, i kdyby to byla nula - `#` volitelná číslice, zobrazí se jen tehdy, pokud na tomto místě číslo skutečně je - `@` významná číslice, pomáhá zobrazit číslo s určitým počtem platných číslic -- `.` označuje, kde má být desetinná čárka (nebo tečka, podle země) +- `.` označuje pozici desetinné čárky (nebo tečky, podle země) - `,` slouží k oddělení skupin číslic, nejčastěji tisíců - `%` číslo vynásobí 100× a přidá znak procenta -Pojďme se podívat na příklady. V prvním příkladu jsou dvě desetinná místa povinná, ve druhém volitelná. Třetí příklad ukazuje doplnění nulami zleva i zprava, čtvrtý zobrazuje jen existující číslice: +Podívejme se na příklady. V prvním příkladu jsou dvě desetinná místa povinná, ve druhém volitelná. Třetí příklad ukazuje doplnění nulami zleva i zprava, čtvrtý zobrazuje jen existující číslice: ```latte {1234.5|number: '#,##0.00'} {* 1,234.50 *} @@ -569,7 +570,7 @@ Pojďme se podívat na příklady. V prvním příkladu jsou dvě desetinná mí {1.2 |number: '##.##'} {* 1.2 *} ``` -Významné číslice určují, kolik číslic bez ohledu na desetinou čárku má být zobrazeno, přičemž se zaokrouhluje: +Významné číslice určují, kolik číslic bez ohledu na desetinnou čárku má být zobrazeno, přičemž dochází k zaokrouhlování: ```latte {1234|number: '@@'} {* 1200 *} @@ -585,7 +586,7 @@ Snadný způsob, jak zobrazit číslo jako procenta. Číslo se vynásobí 100× {0.1234|number: '#.##%'} {* 12.34% *} ``` -Můžeme definovat odlišný formát pro kladná a záporná čísla, odděluje je znak `;`. Tímto způsobem lze například nastavit, že kladná čísla se mají zobrazovat se znaménkem `+`: +Můžeme definovat odlišný formát pro kladná a záporná čísla, oddělené znakem `;`. Tímto způsobem lze například nastavit, že kladná čísla se mají zobrazovat se znaménkem `+`: ```latte {42|number: '#.##;(#.##)'} {* 42 *} @@ -594,12 +595,12 @@ Můžeme definovat odlišný formát pro kladná a záporná čísla, odděluje {-42|number: '+#.##;-#.##'} {* -42 *} ``` -Pamatujte, že skutečný vzhled čísel se může lišit podle nastavení země. Například v některých zemích se používá čárka místo tečky jako oddělovač desetinných míst. Tento filtr to automaticky zohlední a nemusíte se o nic starat. +Nezapomeňte, že skutečný vzhled čísel se může lišit podle nastavení země. Například v některých zemích se používá čárka místo tečky jako oddělovač desetinných míst. Tento filtr to automaticky zohlední, takže se o to nemusíte starat. padLeft(int length, string pad = ' ') .[filter] ----------------------------------------------- -Doplní řetězec do určité délky jiným řetězcem zleva. +Filtr `padLeft` doplní řetězec zleva na požadovanou délku jiným řetězcem. ```latte {='hello'|padLeft: 10, '123'} {* vypíše '12312hello' *} @@ -608,7 +609,7 @@ Doplní řetězec do určité délky jiným řetězcem zleva. padRight(int length, string pad = ' ') .[filter] ------------------------------------------------ -Doplní řetězec do určité délky jiným řetězcem zprava. +Filtr `padRight` doplní řetězec zprava na požadovanou délku jiným řetězcem. ```latte {='hello'|padRight: 10, '123'} {* vypíše 'hello12312' *} @@ -617,18 +618,18 @@ Doplní řetězec do určité délky jiným řetězcem zprava. query .[filter] --------------- -Dynamicky generuje query string v URL: +Filtr `query` dynamicky generuje query string v URL: ```latte -click -search +klikněte +hledat ``` -Vypíše: +Výstup: ```latte -click -search +klikněte +hledat ``` Klíče s hodnotou `null` se vynechají. @@ -638,7 +639,7 @@ Viz také [#escapeUrl]. random .[filter] ---------------- -Vrací náhodný prvek pole nebo znak řetězce: +Filtr `random` vrací náhodný prvek pole nebo náhodný znak řetězce: ```latte {=[1, 2, 3, 4]|random} {* vypíše např.: 3 *} @@ -650,7 +651,7 @@ Viz také [#first], [#last]. repeat(int count) .[filter] --------------------------- -Opakuje řetězec x-krát. +Filtr `repeat` opakuje řetězec zadaný počet krát. ```latte {='hello'|repeat: 3} {* vypíše 'hellohellohello' *} @@ -659,7 +660,7 @@ Opakuje řetězec x-krát. replace(string|array search, string replace = '') .[filter] ----------------------------------------------------------- -Nahradí všechny výskyty vyhledávacího řetězce náhradním řetězcem. +Filtr `replace` nahradí všechny výskyty hledaného řetězce náhradním řetězcem. ```latte {='hello world'|replace: 'world', 'friend'} {* vypíše 'hello friend' *} @@ -674,7 +675,7 @@ Lze provést i více záměn najednou: replaceRE(string pattern, string replace = '') .[filter] -------------------------------------------------------- -Provede vyhledávání regulárních výrazů s nahrazením. +Filtr `replaceRE` provádí nahrazování podle regulárních výrazů. ```latte {='hello world'|replaceRE: '/l.*/', 'l'} {* vypíše 'hel' *} @@ -683,19 +684,19 @@ Provede vyhledávání regulárních výrazů s nahrazením. reverse .[filter] ----------------- -Obrátí daný řetězec nebo pole. +Filtr `reverse` obrátí pořadí znaků v řetězci nebo prvků v poli. ```latte {var $s = 'Nette'} {$s|reverse} {* vypíše 'etteN' *} {var $a = ['N', 'e', 't', 't', 'e']} -{$a|reverse} {* returns ['e', 't', 't', 'e', 'N'] *} +{$a|reverse} {* vrátí ['e', 't', 't', 'e', 'N'] *} ``` round(int precision = 0) .[filter] ---------------------------------- -Zaokrouhlí číslo na danou přesnost. +Filtr `round` zaokrouhlí číslo na zadanou přesnost. ```latte {=3.4|round} {* vypíše 3 *} @@ -709,25 +710,25 @@ Viz také [#ceil], [#floor]. slice(int start, int length = null, bool preserveKeys = false) .[filter] ------------------------------------------------------------------------ -Extrahuje část pole nebo řetězce. +Filtr `slice` extrahuje část pole nebo řetězce. ```latte {='hello'|slice: 1, 2} {* vypíše 'el' *} {=['a', 'b', 'c']|slice: 1, 2} {* vypíše ['b', 'c'] *} ``` -Filtr funguje jako funkce PHP `array_slice` pro pole nebo `mb_substr` pro řetězce s fallbackem na funkci `iconv_substr` v režimu UTF‑8. +Tento filtr funguje jako funkce PHP `array_slice` pro pole nebo `mb_substr` pro řetězce s fallbackem na funkci `iconv_substr` v režimu UTF-8. -Pokud je start kladný, posloupnost začné posunutá o tento počet od začátku pole/řetezce. Pokud je záporný posloupnost začné posunutá o tolik od konce. +Pokud je `start` kladný, posloupnost začíná posunutá o tento počet od začátku pole/řetězce. Pokud je záporný, posloupnost začíná posunutá o tolik od konce. -Pokud je zadaný parametr length a je kladný, posloupnost bude obsahovat tolik prvků. Pokud je do této funkce předán záporný parametr length, posloupnost bude obsahovat všechny prvky původního pole, začínající na pozici start a končicí na pozici menší na length prvků od konce pole. Pokud tento parametr nezadáte, posloupnost bude obsahovat všechny prvky původního pole, začínající pozici start. +Pokud je zadán parametr `length` a je kladný, posloupnost bude obsahovat tolik prvků. Pokud je do této funkce předán záporný parametr `length`, posloupnost bude obsahovat všechny prvky původního pole, začínající na pozici `start` a končící na pozici menší o `length` prvků od konce pole. Pokud tento parametr nezadáte, posloupnost bude obsahovat všechny prvky původního pole, začínající pozicí `start`. -Ve výchozím nastavení filtr změní pořadí a resetuje celočíselného klíče pole. Toto chování lze změnit nastavením preserveKeys na true. Řetězcové klíče jsou vždy zachovány, bez ohledu na tento parametr. +Ve výchozím nastavení filtr změní pořadí a resetuje celočíselné klíče pole. Toto chování lze změnit nastavením `preserveKeys` na true. Řetězcové klíče jsou vždy zachovány, bez ohledu na tento parametr. sort(?Closure comparison, string|int|\Closure|null by=null, string|int|\Closure|bool byKey=false) .[filter] ----------------------------------------------------------------------------------------------------------- -Filtr seřadí prvky pole nebo iterátoru a zachová jejich asociační klíče. Při nastaveném [národním prostředí |develop#locale] se řazení řídí jeho pravidly, pokud není specifikována vlastní porovnávací funkce. +Filtr `sort` seřadí prvky pole nebo iterátoru a zachová jejich asociační klíče. Při nastaveném [národním prostředí |develop#locale] se řazení řídí jeho pravidly, pokud není specifikována vlastní porovnávací funkce. ```latte {foreach ($names|sort) as $name} @@ -735,7 +736,7 @@ Filtr seřadí prvky pole nebo iterátoru a zachová jejich asociační klíče. {/foreach} ``` -Řazené pole v opačném pořadí: +Pro řazení pole v opačném pořadí: ```latte {foreach ($names|sort|reverse) as $name} @@ -757,7 +758,7 @@ Filtr `|sort` také umožňuje řadit prvky podle klíčů: {/foreach} ``` -Pokud potřebujete seřadit tabulku podle konkrétního sloupce, můžete použít parametr `by`. Hodnota `'name'` v ukázce určuje, že se bude řadit podle `$item->name` nebo `$item['name']`, v závislosti na tom, zda je `$item` pole nebo objekt: +Pokud potřebujete seřadit tabulku podle konkrétního sloupce, můžete použít parametr `by`. Hodnota `'name'` v ukázce určuje, že se bude řadit podle `$item->name` nebo `$item['name']`, v závislosti na tom, zda je `$item` objekt nebo pole: ```latte {foreach ($items|sort: by: 'name') as $item} @@ -768,7 +769,7 @@ Pokud potřebujete seřadit tabulku podle konkrétního sloupce, můžete použ Můžete také definovat callback funkci, která určí hodnotu, podle které se má řadit: ```latte -{foreach ($items|sort: by: fn($items) => $items->category->name) as $item} +{foreach ($items|sort: by: fn($item) => $item->category->name) as $item} {$item->name} {/foreach} ``` @@ -778,7 +779,7 @@ Stejným způsobem lze využít i parametr `byKey`. spaceless .[filter] ------------------- -Odstraní zbytečné bílé místo (mezery) z výstupu. Můžete také použít alias `strip`. +Filtr `spaceless` odstraní nadbytečné bílé znaky z výstupu. Můžete také použít alias `strip`. ```latte {block |spaceless} @@ -788,7 +789,7 @@ Odstraní zbytečné bílé místo (mezery) z výstupu. Můžete také použít {/block} ``` -Vypíše: +Výstup: ```latte
  • Hello
@@ -797,7 +798,7 @@ Vypíše: stripHtml .[filter] ------------------- -Převádí HTML na čistý text. Tedy odstraní z něj HTML značky a HTML entity převede na text. +Filtr `stripHtml` převádí HTML na čistý text. Odstraní HTML značky a převede HTML entity na jejich textovou reprezentaci. ```latte {='

one < two

'|stripHtml} {* vypíše 'one < two' *} @@ -808,7 +809,7 @@ Výsledný čistý text může přirozeně obsahovat znaky, které představují substr(int offset, int length = null) .[filter] ----------------------------------------------- -Extrahuje část řetězce. Tento filtr byl nahrazen filtrem [#slice]. +Filtr `substr` extrahuje část řetězce. Tento filtr byl nahrazen filtrem [#slice]. ```latte {$string|substr: 1, 2} @@ -817,7 +818,7 @@ Extrahuje část řetězce. Tento filtr byl nahrazen filtrem [#slice]. translate(string message, ...args) .[filter] -------------------------------------------- -Překládá výrazy do jiných jazyků. Aby byl filtr k dispozici, je potřeba [nastavit překladač|develop#TranslatorExtension]. Můžete také použít [tagy pro překlad|tags#Překlady]. +Filtr `translate` překládá výrazy do jiných jazyků. Aby byl filtr k dispozici, je potřeba [nastavit překladač|develop#TranslatorExtension]. Můžete také použít [tagy pro překlad|tags#Překlady]. ```latte {='Košík'|translate} @@ -827,7 +828,7 @@ Překládá výrazy do jiných jazyků. Aby byl filtr k dispozici, je potřeba [ trim(string charlist = " \t\n\r\0\x0B\u{A0}") .[filter] ------------------------------------------------------- -Odstraní prázdné znaky (nebo jiné znaky) od začátku a konce řetězce. +Filtr `trim` odstraní bílé znaky (nebo jiné zadané znaky) od začátku a konce řetězce. ```latte {=' I like Latte. '|trim} {* vypíše 'I like Latte.' *} @@ -837,7 +838,7 @@ Odstraní prázdné znaky (nebo jiné znaky) od začátku a konce řetězce. truncate(int length, string append = '…') .[filter] --------------------------------------------------- -Ořízne řetězec na uvedenou maximální délku, přičemž se snaží zachovávat celá slova. Pokud dojde ke zkrácení řetězce, přidá nakonec trojtečku (lze změnit druhým parametrem). +Filtr `truncate` zkrátí řetězec na uvedenou maximální délku, přičemž se snaží zachovávat celá slova. Pokud dojde ke zkrácení řetězce, přidá nakonec trojtečku (lze změnit druhým parametrem). ```latte {var $title = 'Hello, how are you?'} @@ -849,7 +850,7 @@ Ořízne řetězec na uvedenou maximální délku, přičemž se snaží zachov upper .[filter] --------------- -Převede řetězec na velká písmena. Vyžaduje PHP rozšíření `mbstring`. +Filtr `upper` převede řetězec na velká písmena. Vyžaduje PHP rozšíření `mbstring`. ```latte {='latte'|upper} {* vypíše 'LATTE' *} @@ -860,9 +861,9 @@ Viz také [#capitalize], [#firstUpper], [#lower]. webalize .[filter] ------------------ -Upraví UTF‑8 řetězec do tvaru používaného v URL. +Filtr `webalize` upraví UTF-8 řetězec do tvaru používaného v URL. -Převádí se na ASCII. Převede mezery na pomlčky. Odstraní znaky, které nejsou alfanumerické, podtržítka ani pomlčky. Převede na malá písmena. Také odstraní přední a koncové mezery. +Převádí znaky na ASCII ekvivalenty. Převádí mezery na pomlčky. Odstraní znaky, které nejsou alfanumerické, podtržítka ani pomlčky. Převádí text na malá písmena. Také odstraní úvodní a koncové bílé znaky. ```latte {var $s = 'Náš 10. produkt'} diff --git a/latte/cs/functions.texy b/latte/cs/functions.texy index c765b63c79..7f4fd0e8e0 100644 --- a/latte/cs/functions.texy +++ b/latte/cs/functions.texy @@ -2,24 +2,24 @@ Latte funkce ************ .[perex] -V šablonách můžeme kromě běžných PHP funkcí používat i tyto další. +V šablonách Latte můžeme kromě běžných PHP funkcí využívat i další speciální funkce, které rozšiřují možnosti při práci s daty a šablonami. .[table-latte-filters] -| `clamp` | [ohraničí hodnotu do daného rozsahu |#clamp] -| `divisibleBy`| [zkontroluje, zda je proměnná dělitelná číslem |#divisibleBy] -| `even` | [zkontroluje, zda je dané číslo sudé |#even] -| `first` | [vrací první prvek pole nebo znak řetězce |#first] -| `group` | [seskupí data podle různých kritérií |#group] -| `hasBlock` | [zjistí existenci bloku |#hasBlock] -| `last` | [vrací poslední prvek pole nebo znak řetězce |#last] -| `odd` | [zkontroluje, zda je dané číslo liché |#odd] +| `clamp` | [omezí hodnotu do zadaného rozsahu |#clamp] +| `divisibleBy`| [ověří dělitelnost čísla |#divisibleBy] +| `even` | [zkontroluje, zda je číslo sudé |#even] +| `first` | [získá první prvek pole nebo znak řetězce |#first] +| `group` | [seskupí data podle zadaných kritérií |#group] +| `hasBlock` | [ověří existenci bloku |#hasBlock] +| `last` | [získá poslední prvek pole nebo znak řetězce |#last] +| `odd` | [zkontroluje, zda je číslo liché |#odd] | `slice` | [extrahuje část pole nebo řetězce |#slice] Použití ======= -Funkce se používají strejně jaké běžné PHP funkce a lze je použít ve všechn výrazech: +Funkce v Latte se používají stejně jako běžné PHP funkce a lze je využít ve všech výrazech: ```latte

{clamp($num, 1, 100)}

@@ -27,14 +27,14 @@ Funkce se používají strejně jaké běžné PHP funkce a lze je použít ve v {if odd($num)} ... {/if} ``` -[Vlastní funkce|extending-latte#funkce] lze registrovat tímto způsobem: +[Vlastní funkce|extending-latte#funkce] můžete do Latte přidat takto: ```php $latte = new Latte\Engine; $latte->addFunction('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len)); ``` -V šabloně se potom volá takto: +V šabloně pak tuto funkci můžete volat následovně: ```latte

{shortify($text)}

@@ -48,7 +48,7 @@ Funkce clamp(int|float $value, int|float $min, int|float $max): int|float .[method] ---------------------------------------------------------------------------- -Ohraničí hodnotu do daného inkluzivního rozsahu min a max. +Funkce `clamp` omezí hodnotu do zadaného inkluzivního rozsahu mezi `$min` a `$max`. ```latte {=clamp($level, 0, 255)} @@ -59,7 +59,7 @@ Viz také [filtr clamp|filters#clamp]. divisibleBy(int $value, int $by): bool .[method] ------------------------------------------------ -Zkontroluje, zda je proměnná dělitelná číslem. +Funkce `divisibleBy` ověří, zda je číslo `$value` dělitelné číslem `$by`. ```latte {if divisibleBy($num, 5)} ... {/if} @@ -68,7 +68,7 @@ Zkontroluje, zda je proměnná dělitelná číslem. even(int $value): bool .[method] -------------------------------- -Zkontroluje, zda je dané číslo sudé. +Funkce `even` zkontroluje, zda je dané číslo sudé. ```latte {if even($num)} ... {/if} @@ -77,7 +77,7 @@ Zkontroluje, zda je dané číslo sudé. first(string|iterable $value): mixed .[method] ---------------------------------------------- -Vrací první prvek pole nebo znak řetězce: +Funkce `first` vrací první prvek pole nebo první znak řetězce: ```latte {=first([1, 2, 3, 4])} {* vypíše 1 *} @@ -89,9 +89,9 @@ Viz také [#last], [filtr first|filters#first]. group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16} ------------------------------------------------------------------------------------ -Funkce seskupí data podle různých kritérií. +Funkce `group` seskupí data podle zadaných kritérií. -V tomto příkladu se řádky v tabulce seskupují podle sloupce `categoryId`. Výstupem je pole polí, kde klíčem je hodnota ve sloupci `categoryId`. [Přečtěte si podrobný návod|cookbook/grouping]. +V tomto příkladu se řádky v tabulce seskupují podle sloupce `categoryId`. Výsledkem je pole polí, kde klíčem je hodnota ve sloupci `categoryId`. [Podrobný návod najdete zde|cookbook/grouping]. ```latte {foreach group($items, categoryId) as $categoryId => $categoryItems} @@ -108,7 +108,7 @@ Viz také filtr [group|filters#group]. hasBlock(string $name): bool .[method]{data-version:3.0.10} ----------------------------------------------------------- -Zjistí, zda blok uvedeného jména existuje: +Funkce `hasBlock` ověří, zda existuje blok s uvedeným názvem: ```latte {if hasBlock(header)} ... {/if} @@ -119,7 +119,7 @@ Viz také [kontrola existence bloků|template-inheritance#Kontrola existence blo last(string|array $value): mixed .[method] ------------------------------------------ -Vrací poslední prvek pole nebo znak řetězce: +Funkce `last` vrací poslední prvek pole nebo poslední znak řetězce: ```latte {=last([1, 2, 3, 4])} {* vypíše 4 *} @@ -131,7 +131,7 @@ Viz také [#first], [filtr last|filters#last]. odd(int $value): bool .[method] ------------------------------- -Zkontroluje, zda je dané číslo liché. +Funkce `odd` zkontroluje, zda je dané číslo liché. ```latte {if odd($num)} ... {/if} @@ -140,17 +140,17 @@ Zkontroluje, zda je dané číslo liché. slice(string|array $value, int $start, int $length=null, bool $preserveKeys=false): string|array .[method] ---------------------------------------------------------------------------------------------------------- -Extrahuje část pole nebo řetězce. +Funkce `slice` extrahuje část pole nebo řetězce. ```latte {=slice('hello', 1, 2)} {* vypíše 'el' *} {=slice(['a', 'b', 'c'], 1, 2)} {* vypíše ['b', 'c'] *} ``` -Filtr funguje jako funkce PHP `array_slice` pro pole nebo `mb_substr` pro řetězce s fallbackem na funkci `iconv_substr` v režimu UTF‑8. +Tato funkce funguje podobně jako PHP funkce `array_slice` pro pole nebo `mb_substr` pro řetězce (s fallbackem na `iconv_substr` v režimu UTF-8). -Pokud je start kladný, posloupnost začné posunutá o tento počet od začátku pole/řetezce. Pokud je záporný posloupnost začné posunutá o tolik od konce. +- Pokud je `$start` kladný, výsledek začíná od tohoto indexu od začátku pole/řetězce. Pokud je záporný, začíná se od konce. -Pokud je zadaný parametr length a je kladný, posloupnost bude obsahovat tolik prvků. Pokud je do této funkce předán záporný parametr length, posloupnost bude obsahovat všechny prvky původního pole, začínající na pozici start a končicí na pozici menší na length prvků od konce pole. Pokud tento parametr nezadáte, posloupnost bude obsahovat všechny prvky původního pole, začínající pozici start. +- Pokud je `$length` kladný, výsledek bude obsahovat tolik prvků. Pokud je záporný, výsledek bude obsahovat všechny prvky kromě posledních `$length` prvků. Pokud není zadán, výsledek bude obsahovat všechny prvky od `$start` do konce. -Ve výchozím nastavení filtr změní pořadí a resetuje celočíselného klíče pole. Toto chování lze změnit nastavením preserveKeys na true. Řetězcové klíče jsou vždy zachovány, bez ohledu na tento parametr. +- Parametr `$preserveKeys` určuje, zda zachovat původní klíče pole. Ve výchozím nastavení (false) jsou číselné klíče resetovány. Řetězcové klíče jsou vždy zachovány bez ohledu na toto nastavení. diff --git a/latte/cs/recipes.texy b/latte/cs/recipes.texy index 90d74badb3..11389d60c2 100644 --- a/latte/cs/recipes.texy +++ b/latte/cs/recipes.texy @@ -5,19 +5,19 @@ Tipy a triky Editory a IDE ============= -Pište šablony v editoru nebo IDE, který má podporu pro Latte. Bude to mnohem příjemnější. +Efektivní práce s Latte šablonami začíná u správně nastaveného vývojového prostředí. Vhodný editor nebo IDE s podporou Latte vám významně usnadní práci a zvýší produktivitu. -- NetBeans IDE má podporu vestavěnou -- PhpStorm: nainstalujte v `Settings > Plugins > Marketplace` [plugin Latte|https://plugins.jetbrains.com/plugin/7457-latte] -- VS Code: hledejte v marketplace [Nette Latte + Neon|https://marketplace.visualstudio.com/items?itemName=Kasik96.latte] nebo [Nette Latte templates|https://marketplace.visualstudio.com/items?itemName=smuuf.latte-lang] plugin -- Sublime Text 3: v Package Control najděte a nainstalujte balíček `Nette` a zvolte Latte ve `View > Syntax` -- ve starých editorech použijte pro soubory .latte zvýrazňování Smarty +- PhpStorm: v `Settings > Plugins > Marketplace` nainstalujte [plugin Latte|https://plugins.jetbrains.com/plugin/7457-latte] +- VS Code: vyhledejte a nainstalujte [Nette Latte + Neon|https://marketplace.visualstudio.com/items?itemName=Kasik96.latte] nebo [Nette Latte templates|https://marketplace.visualstudio.com/items?itemName=smuuf.latte-lang] plugin +- NetBeans IDE: nativní podpora Latte je součástí instalace +- Sublime Text 3: přes Package Control nainstalujte balíček `Nette` a v `View > Syntax` zvolte Latte +- Pro starší editory: použijte zvýrazňování syntaxe pro Smarty u souborů s příponou .latte -Plugin pro PhpStorm je velmi pokročilý a umí výborně napovídat PHP kód. Aby fungoval optimálně, používejte [typované šablony|type-system]. +Plugin pro PhpStorm vyniká pokročilými funkcemi a nabízí vynikající napovídání PHP kódu. Pro jeho optimální funkčnost doporučujeme používat [typované šablony|type-system]. [* latte-phpstorm-plugin.webp *] -Podporu pro Latte najdete také ve webovém zvýrazňovači kódu [Prism.js|https://prismjs.com/#supported-languages] a editoru [Ace|https://ace.c9.io]. +Podporu Latte najdete také v online zvýrazňovači kódu [Prism.js|https://prismjs.com/#supported-languages] a webovém editoru [Ace|https://ace.c9.io]. Latte uvnitř JavaScriptu nebo CSS @@ -37,9 +37,11 @@ Latte lze velmi pohodlně používat i uvnitř JavaScriptu nebo CSS. Jak se vša ``` -**Varianta 1** +Existuje několik řešení: -Vyhněte se situaci, kdy následuje písmeno hned za `{`, třeba tím, že před něj vložíte mezeru, odřádkování nebo uvozovku: +**Řešení 1: Oddělení závorek** + +Vložte mezeru, odřádkování nebo uvozovku mezi `{` a následující písmeno: ```latte `. Naopak v atributech `style` a `on***` se pomocí HTML entit escapuje. -A samozřejmě uvnitř vnořeného JavaScriptu nebo CSS platí escapovací pravidla těchto jazyků. Takže řetezec v atributu např. `onload` se nejprve escapuje podle pravidel JS a potom podle pravidel HTML atributu. +A samozřejmě uvnitř vnořeného JavaScriptu nebo CSS platí escapovací pravidla těchto jazyků. Řetězec v atributu například `onload` se nejprve escapuje podle pravidel JS a potom podle pravidel HTML atributu. -Uff... Jak vidíte, HTML je velmi komplexní dokument, kde se vrství kontexty, a bez uvědomění si, kde přesně data vypisuji (tj. v jakém kontextu), nelze říct, jak to správně udělat. +Jak vidíte, HTML je velmi komplexní dokument, kde se vrství kontexty. Bez uvědomění si, kde přesně data vypisuji (tj. v jakém kontextu), nelze říct, jak to správně udělat. Chcete příklad? --------------- -Mějme řetězec `Rock'n'Roll`. +Vezměme řetězec `Rock'n'Roll`. -Pokud jej budete vypisovat v HTML textu, zrovna v tomhle případě netřeba dělat žádné záměny, protože řetězec neobsahuje žádný znak se speciálním významem. Jiná situace nastane, pokud jej vypíšete uvnitř HTML atributu uvozeného do jednoduchých uvozovek. V takovém případě je potřeba escapovat uvozovky na HTML entity: +Pokud jej budete vypisovat v HTML textu, v tomto konkrétním případě není třeba provádět žádné záměny, protože řetězec neobsahuje žádný znak se speciálním významem. Jiná situace nastane, pokud jej vypíšete uvnitř HTML atributu ohraničeného jednoduchými uvozovkami. V takovém případě je potřeba escapovat uvozovky na HTML entity: ```html
``` -Tohle bylo jednoduché. Mnohem zajímavější situace nastane při vrstvení kontextů, například pokud řetězec bude součástí JavaScriptu. +To bylo jednoduché. Mnohem zajímavější situace nastane při vrstvení kontextů, například pokud řetězec bude součástí JavaScriptu. -Nejprve jej tedy vypíšeme do samotného JavaScriptu. Tj. obalíme jej do uvozovek a zároveň escapujeme pomocí znaku `\` uvozovky v něm obsažené: +Nejprve jej vypíšeme do samotného JavaScriptu. Obalíme jej do uvozovek a zároveň escapujeme pomocí znaku `\` uvozovky v něm obsažené: ```js 'Rock\'n\'Roll' ``` -Ještě můžeme doplnit volání nějaké funkce, ať kód něco dělá: +Doplňme volání nějaké funkce, ať kód něco dělá: ```js alert('Rock\'n\'Roll'); ``` -Pokud tento kód vložíme do HTML dokumentu pomocí ``: ```html @@ -174,13 +173,13 @@ Pokud bychom jej však chtěli vložit do HTML atributu, musíme ještě escapov
``` -Vnořeným kontextem ale nemusí být jen JS nebo CSS. Běžně jím je také URL. Parametry v URL se escapují tak, že se znaky se speciálním významen převádějí na sekvence začínající `%`. Příklad: +Vnořeným kontextem ale nemusí být jen JS nebo CSS. Běžně jím je také URL. Parametry v URL se escapují tak, že se znaky se speciálním významem převádějí na sekvence začínající `%`. Příklad: ``` https://example.org/?a=Jazz&b=Rock%27n%27Roll ``` -A když tento řetězec vypíšeme v atributu, ještě aplikujeme escapování podle tohoto kontextu a nahradíme `&` za `&`: +A když tento řetězec vypíšeme v atributu, ještě aplikujeme escapování podle tohoto kontextu a nahradíme `&` za `&`: ```html @@ -192,13 +191,13 @@ Pokud jste dočetli až sem, gratulujeme, bylo to vyčerpávající. Teď už m Latte vs naivní systémy ======================= -Ukázali jsem si, jak se správně escapuje v HTML dokumentu a jak zásadní je znalost kontextu, tedy místa, kde data vypisujeme. Jinými slovy, jak funguje kontextově sensitvní escapování. -Ačkoliv jde o nezbytný předpoklad funkční obrany před XSS, **Latte je jediný šablonovací systém pro PHP, který tohle umí.** +Ukázali jsme si, jak se správně escapuje v HTML dokumentu a jak zásadní je znalost kontextu, tedy místa, kde data vypisujeme. Jinými slovy, jak funguje kontextově sensitivní escapování. +Ačkoliv jde o nezbytný předpoklad funkční obrany před XSS, **Latte je jediný šablonovací systém pro PHP, který tohle umí**. Jak je to možné, když všechny systémy dnes tvrdí, že mají automatické escapování? -Automatické escapování bez znalosti kontextu je trošku bullshit, který **vytváří falešný dojem bezpečí**. +Automatické escapování bez znalosti kontextu je poněkud zavádějící a **vytváří falešný dojem bezpečí**. -Šablonovací systémy, jako je Twig, Laravel Blade a další, nevidí v šabloně žádnou HTML strukturu. Nevidí tudíž ani kontexty. Oproti Latte jsou slepé a naivní. Zpracovávají jen vlastní značky, vše ostatní je pro ně nepodstatný tok znaků: +Šablonovací systémy jako Twig, Laravel Blade a další nevidí v šabloně žádnou HTMLstrukturu. Nevidí tudíž ani kontexty. Oproti Latte jsou slepé a naivní. Zpracovávají jen vlastní značky, vše ostatní je pro ně nepodstatný tok znaků:
@@ -230,7 +229,7 @@ Automatické escapování bez znalosti kontextu je trošku bullshit, který **vy
-Naivní systémy jen mechanicky převádějí znaky `< > & ' "` na HTML entity, což je sice ve většině případů užití platný způsob escapování, ale zdaleka ne vždy. Nemohou tak odhalit ani předejít vzniku různých bezpečnostní děr, jak si ukážeme dále. +Naivní systémy pouze mechanicky převádějí znaky `< > & ' "` na HTML entity, což je sice ve většině případů platný způsob escapování, ale zdaleka ne vždy. Nemohou tak odhalit ani předejít vzniku různých bezpečnostních děr, jak si ukážeme dále. Latte šablonu vidí stejně jako vy. Chápe HTML, XML, rozeznává značky, atributy atd. A díky tomu rozlišuje jednotlivé kontexty a podle nich ošetřuje data. Nabízí tak opravdu efektivní ochranu proti kritické zranitelnosti Cross-site Scripting. @@ -270,63 +269,60 @@ Vlevo vidíte šablonu v Latte, vpravo je vygenerovaný HTML kód. Několikrát
-Není to skvělé! Latte dělá kontextově sensitivní escapování automaticky, takže programátor: +Není to skvělé! Latte provádí kontextově sensitivní escapování automaticky, takže programátor: - nemusí přemýšlet ani vědět, jak se kde escapuje - nemůže se splést - nemůže na escapování zapomenout -Tohle dokonce nejsou všechny kontexty, které Latte při vypisování rozlišuje a pro které přizpůsobuje ošetření dat. Další zajimavé případy si projdeme nyní. +Tohle dokonce nejsou všechny kontexty, které Latte při vypisování rozlišuje a pro které přizpůsobuje ošetření dat. Další zajímavé případy si projdeme nyní. Jak hacknout naivní systémy =========================== -Na několika praktických příkladech si ukážeme, jak je rozlišování kontextů důležité a proč naivní šablonovací systémy neposkytují dostatečnou ochranu před XSS, na rozdíl od Latte. -Jako zástupce naivního systému použijeme v ukázkách Twig, ale totéž platí i pro ostatní systémy. +Nyní si na praktických příkladech ukážeme, proč je rozlišování kontextů tak důležité a proč naivní šablonovací systémy neposkytují dostatečnou ochranu před XSS, na rozdíl od Latte. +V ukázkách použijeme Twig jako zástupce naivních systémů, ale podobné principy platí i pro ostatní systémy. -Zranitelnost atributem ----------------------- +Zranitelnost pomocí atributu +---------------------------- -Pokusíme se do stránky injektovat škodlivý kód pomocí HTML atributu, jak jsme si [ukazovali výše|#Jak zranitelnost vzniká]. Mějme šablonu v Twigu vykreslující obrázek: +Pokusme se injektovat škodlivý kód do stránky pomocí HTML atributu. Představme si šablonu v Twigu pro vykreslení obrázku: ```twig .{file:Twig} {{ ``` -Všimněte si, že okolo hodnot atributů nejsou uvozovky. Kodér na ně mohl zapomenout, což se prostě stává. Například v Reactu se kód píše takto, bez uvozovek, a kodér, který střídá jazyky, pak na uvozovky může snadno zapomenout. +Všimněte si chybějících uvozovek kolem hodnot atributů. Takové opomenutí se může snadno stát, zejména když vývojář střídá různé technologie (např. v Reactu se atributy píší bez uvozovek). -Útočník jako popisek obrázku vloží šikovně sestavený řetězec `foo onload=alert('Hacked!')`. Už víme, že Twig nemůže poznat, jestli se proměnná vypisuje v toku HTML textu, uvnitř atributu, HTML komentáře, atd., zkrátka nerozlišuje kontexty. A jen mechanicky převádí znaky `< > & ' "` na HTML entity. -Takže výsledný kód bude vypadat takto: +Útočník by mohl jako popisek obrázku vložit řetězec `foo onload=alert('Hacked!')`. Twig nedokáže rozpoznat kontext, ve kterém se proměnná vypisuje, a pouze mechanicky převede znaky `< > & ' "` na HTML entity. Výsledný kód bude vypadat takto: ```html foo ``` -**A vznikla bezpečností díra!** +**Vznikla bezpečnostní díra!** Do stránky se dostal podvržený atribut `onload`, který prohlížeč spustí ihned po načtení obrázku. -Součástí stránky se stal podvržený atribut `onload` a prohlížeč ihned po stažení obrázku jej spustí. - -Nyní se podíváme, jak si se stejnou šablonou poradí Latte: +Srovnejme to s Latte: ```latte .{file:Latte} {$imageAlt} ``` -Latte vidí šablonu stejně jako vy. Na rozdíl od Twigu chápe HTML a ví, že proměnná se vypisuje jako hodnota atributu, který není v uvozovkách. Proto je doplní. Když útočník vloží stejný popisek, výsledný kód bude vypadat takto: +Latte chápe strukturu HTML a rozpozná, že proměnná se vypisuje jako hodnota atributu bez uvozovek. Proto je automaticky doplní. I když útočník vloží stejný škodlivý řetězec, výsledek bude bezpečný: ```html foo onload=alert('Hacked!') ``` -**Latte úspěšně zabránilo XSS.** +**Latte úspěšně odvrátilo XSS útok.** -Vypsání proměnné v JavaScript ------------------------------ +Bezpečné použití proměnných v JavaScriptu +----------------------------------------- -Díky kontextově sensitivnímu escapování je možné zcela nativně používat PHP proměnné uvnitř JavaScriptu. +Díky kontextově citlivému escapování můžete v Latte bezpečně používat PHP proměnné přímo v JavaScriptu: ```latte

{$movie}

@@ -334,7 +330,7 @@ Díky kontextově sensitivnímu escapování je možné zcela nativně používa ``` -Pokud bude proměnná `$movie` obsahovat řetězec `'Amarcord & 8 1/2'`, vygeneruje se následující výstup. Všimněte si, že uvnitř HTML se použije jiné escapování, než uvnitř JavaScriptu a ještě jiné v atributu `onclick`: +Pokud `$movie` obsahuje řetězec `'Amarcord & 8 1/2'`, Latte vygeneruje následující kód: ```latte

Amarcord & 8 1/2

@@ -342,11 +338,13 @@ Pokud bude proměnná `$movie` obsahovat řetězec `'Amarcord & 8 1/2'`, vygener ``` +Všimněte si, jak Latte použilo různé metody escapování pro HTML text, JavaScript v atributu `onclick` a JavaScript uvnitř tagu ` ``` -To je také důvod, proč se kolem proměnné **nepíší uvozovky**: Latte je u řetězců doplní samo. A pokud byste chtěli řetězcovou proměnnou vložit do jiného řetězce, jednoduše je spojte: +To je také důvod, proč se kolem proměnné **nepíší uvozovky**: Latte je u řetězců doplní samo. Pokud chcete řetězcovou proměnnou vložit do jiného řetězce, jednoduše je spojte: ```latte ``` -Latte lze velmi pohodlně používat i uvnitř JavaScriptu, jen se stačí vynout konstrukcím jako v tomto příkladě, kdy následuje písmeno hned za `{`, viz [Latte uvnitř JavaScriptu nebo CSS|recipes#Latte uvnitř JavaScriptu nebo CSS]. +Latte lze velmi pohodlně používat i uvnitř JavaScriptu, jen se stačí vyhnout konstrukcím jako v tomto příkladě, kdy následuje písmeno hned za `{`, viz [Latte uvnitř JavaScriptu nebo CSS|recipes#Latte uvnitř JavaScriptu nebo CSS]. -Pokud Latte vypnete pomocí `{syntax off}` (tj. značkou, nikoliv n:atributem), bude důsledně ignorovat všechny značky až do `{/syntax}` +Pokud Latte vypnete pomocí `{syntax off}` (tj. značkou, nikoliv n:atributem), bude důsledně ignorovat všechny značky až do `{/syntax}`. {trace} @@ -941,7 +938,7 @@ n:class Díky `n:class` velice snadno vygenerujete HTML atribut `class` přesně podle představ. -Příklad: potřebuji, aby aktivní prvek měl třídu `active`: +Příklad: potřebujeme, aby aktivní prvek měl třídu `active`: ```latte {foreach $items as $item} @@ -971,7 +968,7 @@ A všechny prvky mají mít třídu `list-item`: n:attr ------ -Atribut `n:attr` umí se stejnou elegancí jako má [n:class|#n:class] generovat libovolné HTML atributy. +Atribut `n:attr` umí se stejnou elegancí jako [n:class|#n:class] generovat libovolné HTML atributy. ```latte {foreach $data as $item} diff --git a/latte/cs/template-inheritance.texy b/latte/cs/template-inheritance.texy index ab6e030bdb..6c62b34f1c 100644 --- a/latte/cs/template-inheritance.texy +++ b/latte/cs/template-inheritance.texy @@ -2,15 +2,15 @@ Dědičnost a znovupoužitelnost šablon ************************************ .[perex] -Mechanismy opětovného použití a dědičnosti šablon zvýší vaši produktivitu, protože každá šablona obsahuje pouze svůj jedinečný obsah a opakované prvky a struktury se znovupoužijí. Představujeme tři koncepty: [#layoutová dědičnost], [#horizontální znovupoužití] a [#jednotková dědičnost]. +Mechanismy dědičnosti a znovupoužitelnosti šablon v Latte významně zvyšují produktivitu vývojářů. Každá šablona tak může obsahovat pouze svůj jedinečný obsah, zatímco opakující se prvky a struktury se efektivně znovupoužívají. V této kapitole představíme tři klíčové koncepty: [layoutovou dědičnost|#layoutová dědičnost], [#horizontální znovupoužití] a [jednotkovou dědičnost|#jednotková dědičnost]. -Koncept dědičnosti šablon Latte je podobný dědičnosti tříd v PHP. Definujete **nadřazenou šablonu**, od které mohou dědit další **podřízené šablony** a mohou přepsat části nadřazené šablony. Funguje to skvěle, když prvky sdílejí společnou strukturu. Zní to komplikovaně? Nebojte se, je to velmi snadné. +Koncept dědičnosti šablon v Latte je analogický k dědičnosti tříd v PHP. Definujete **nadřazenou šablonu**, od které mohou další **podřízené šablony** dědit a případně přepisovat její části. Tento přístup je zvláště účinný, když různé prvky sdílejí společnou strukturu. Ačkoli to může znít složitě, v praxi jde o velmi intuitivní a snadno použitelný systém. Layoutová dědičnost `{layout}` .{toc:Layoutová dědičnost} ========================================================= -Podívejme se na dědičnost šablony rozložení, tedy layoutu, rovnou příkladem. Toto je nadřazená šablona, kterou budeme nazývat například `layout.latte` a která definuje kostru HTML dokumentu: +Podívejme se na layoutovou dědičnost na konkrétním příkladu. Následující ukázka představuje nadřazenou šablonu, kterou můžeme nazvat například `layout.latte`. Tato šablona definuje základní kostru HTML dokumentu: ```latte @@ -30,36 +30,36 @@ Podívejme se na dědičnost šablony rozložení, tedy layoutu, rovnou příkla ``` -Značky `{block}` definují tři bloky, které mohou podřízené šablony vyplnit. Značka block dělá jen to, že oznámí, že toto místo může podřízená šablona přepsat definováním vlastního bloku se stejným názvem. +Značky `{block}` zde vymezují tři bloky, které mohou podřízené šablony naplnit vlastním obsahem. Blok v tomto kontextu jednoduše označuje místo, které může podřízená šablona přepsat definováním vlastního bloku se stejným názvem. -Podřízená šablona může vypadat takto: +Podřízená šablona pak může vypadat například takto: ```latte {layout 'layout.latte'} -{block title}My amazing blog{/block} +{block title}Můj úžasný blog{/block} {block content} -

Welcome to my awesome homepage.

+

Vítejte na mé skvělé domovské stránce.

{/block} ``` -Klíčem je zde značka `{layout}`. Říká Latte, že tato šablona „rozšiřuje“ další šablonu. Když Latte vykresluje tuto šablonu, nejprve najde nadřazenou šablonu - v tomto případě `layout.latte`. +Klíčovým prvkem je zde značka `{layout}`. Ta Latte sděluje, že tato šablona "rozšiřuje" jinou šablonu. Při vykreslování této šablony Latte nejprve nalezne nadřazenou šablonu - v tomto případě `layout.latte`. -V tomto okamžiku si Latte všimne tří blokových značek v `layout.latte` a nahradí tyto bloky obsahem podřízené šablony. Vzhledem k tomu, že podřízená šablona nedefinovala blok *footer*, použije se místo toho obsah z nadřazené šablony. Obsah ve značce `{block}` v nadřazené šabloně se vždy používá jako záložní. +V tomto okamžiku Latte identifikuje tři blokové značky v `layout.latte` a nahradí tyto bloky obsahem z podřízené šablony. Vzhledem k tomu, že podřízená šablona nedefinovala blok *footer*, použije se pro tento blok obsah z nadřazené šablony. Obsah uvnitř značky `{block}` v nadřazené šabloně vždy slouží jako výchozí, pokud není přepsán. -Výstup může vypadat takto: +Výsledný výstup může vypadat následovně: ```latte - My amazing blog + Můj úžasný blog
-

Welcome to my awesome homepage.

+

Vítejte na mé skvělé domovské stránce.