From dba2b17a4201aede7ba3545eda5325edcc9105a9 Mon Sep 17 00:00:00 2001 From: David Grudl Date: Wed, 17 Jan 2024 16:18:21 +0100 Subject: [PATCH] nette/utils 4.0.4 --- utils/bg/@home.texy | 1 + utils/bg/@left-menu.texy | 1 + utils/bg/arrays.texy | 96 ++++++++++++++++++++++++------- utils/bg/images.texy | 5 ++ utils/bg/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/cs/@home.texy | 1 + utils/cs/@left-menu.texy | 1 + utils/cs/arrays.texy | 96 ++++++++++++++++++++++++------- utils/cs/images.texy | 5 ++ utils/cs/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/de/@home.texy | 1 + utils/de/@left-menu.texy | 1 + utils/de/arrays.texy | 92 ++++++++++++++++++++++++------ utils/de/images.texy | 5 ++ utils/de/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/el/@home.texy | 1 + utils/el/@left-menu.texy | 1 + utils/el/arrays.texy | 92 ++++++++++++++++++++++++------ utils/el/images.texy | 5 ++ utils/el/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/en/@home.texy | 1 + utils/en/@left-menu.texy | 1 + utils/en/arrays.texy | 92 ++++++++++++++++++++++++------ utils/en/images.texy | 5 ++ utils/en/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/es/@home.texy | 1 + utils/es/@left-menu.texy | 1 + utils/es/arrays.texy | 92 ++++++++++++++++++++++++------ utils/es/images.texy | 5 ++ utils/es/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/fr/@home.texy | 1 + utils/fr/@left-menu.texy | 1 + utils/fr/arrays.texy | 92 ++++++++++++++++++++++++------ utils/fr/images.texy | 5 ++ utils/fr/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/hu/@home.texy | 1 + utils/hu/@left-menu.texy | 1 + utils/hu/arrays.texy | 92 ++++++++++++++++++++++++------ utils/hu/images.texy | 5 ++ utils/hu/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/it/@home.texy | 1 + utils/it/@left-menu.texy | 1 + utils/it/arrays.texy | 92 ++++++++++++++++++++++++------ utils/it/images.texy | 5 ++ utils/it/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/pl/@home.texy | 1 + utils/pl/@left-menu.texy | 1 + utils/pl/arrays.texy | 96 ++++++++++++++++++++++++------- utils/pl/images.texy | 5 ++ utils/pl/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/pt/@home.texy | 1 + utils/pt/@left-menu.texy | 1 + utils/pt/arrays.texy | 92 ++++++++++++++++++++++++------ utils/pt/images.texy | 5 ++ utils/pt/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/ro/@home.texy | 1 + utils/ro/@left-menu.texy | 1 + utils/ro/arrays.texy | 92 ++++++++++++++++++++++++------ utils/ro/images.texy | 5 ++ utils/ro/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/ru/@home.texy | 1 + utils/ru/@left-menu.texy | 1 + utils/ru/arrays.texy | 96 ++++++++++++++++++++++++------- utils/ru/images.texy | 5 ++ utils/ru/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/sl/@home.texy | 1 + utils/sl/@left-menu.texy | 1 + utils/sl/arrays.texy | 92 ++++++++++++++++++++++++------ utils/sl/images.texy | 5 ++ utils/sl/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/tr/@home.texy | 1 + utils/tr/@left-menu.texy | 1 + utils/tr/arrays.texy | 92 ++++++++++++++++++++++++------ utils/tr/images.texy | 5 ++ utils/tr/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ utils/uk/@home.texy | 1 + utils/uk/@left-menu.texy | 1 + utils/uk/arrays.texy | 96 ++++++++++++++++++++++++------- utils/uk/images.texy | 5 ++ utils/uk/iterables.texy | 119 +++++++++++++++++++++++++++++++++++++++ 80 files changed, 3226 insertions(+), 282 deletions(-) create mode 100644 utils/bg/iterables.texy create mode 100644 utils/cs/iterables.texy create mode 100644 utils/de/iterables.texy create mode 100644 utils/el/iterables.texy create mode 100644 utils/en/iterables.texy create mode 100644 utils/es/iterables.texy create mode 100644 utils/fr/iterables.texy create mode 100644 utils/hu/iterables.texy create mode 100644 utils/it/iterables.texy create mode 100644 utils/pl/iterables.texy create mode 100644 utils/pt/iterables.texy create mode 100644 utils/ro/iterables.texy create mode 100644 utils/ru/iterables.texy create mode 100644 utils/sl/iterables.texy create mode 100644 utils/tr/iterables.texy create mode 100644 utils/uk/iterables.texy diff --git a/utils/bg/@home.texy b/utils/bg/@home.texy index 21e46d7f6c..bf120bdbac 100644 --- a/utils/bg/@home.texy +++ b/utils/bg/@home.texy @@ -13,6 +13,7 @@ | [Nette\Utils\Image |images] | [Пагинация |paginator] | Nette\Utils\Paginator | [Парсинг и генериране на JSON |json] | Nette\Utils\Json +| [Iterables |iterables] | Nette\Utils\Iterables | [Полета |arrays] | Nette\Utils\Arrays | [Низове |strings] | Nette\Utils\Strings | [Тип Nette\Utils\Type |type] diff --git a/utils/bg/@left-menu.texy b/utils/bg/@left-menu.texy index 1c661ebc3d..8c8dc979e3 100644 --- a/utils/bg/@left-menu.texy +++ b/utils/bg/@left-menu.texy @@ -8,6 +8,7 @@ - [Снимки |images] - [Обратни извиквания |callback] - [Пагинатор |paginator] +- [Iterables |iterables] - [Поле |arrays] - [Случайни низове |random] - [Струни |strings] diff --git a/utils/bg/arrays.texy b/utils/bg/arrays.texy index 07d74c2de8..f759d61f5c 100644 --- a/utils/bg/arrays.texy +++ b/utils/bg/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Масиви .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] е статичен клас, който съдържа полезни функции за работа с масиви. +[api:Nette\Utils\Arrays] е статичен клас, който съдържа няколко удобни функции за масиви. Неговият еквивалент за итератори е [Nette\Utils\Iterables |iterables]. Следващите примери предполагат, че псевдонимът вече е създаден: @@ -76,10 +76,10 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- -Проверява дали всички елементи в масива са преминали теста, реализиран в `$callback` с подпис `function ($value, $key, array $array): bool`. +Проверява дали всички елементи в масива са преминали теста, реализиран в `$predicate` с подпис `function ($value, $key, array $array): bool`. ```php $array = [1, 30, 39, 29, 10, 13]; @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Вижте [some( |#some]). -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Връща нов масив, съдържащ всички двойки ключ-стойност, отговарящи на зададения `$predicate`. Обратното извикване има сигнатурата `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Връща първия елемент (отговарящ на зададеното предсказание, ако е дадено). Ако няма такъв елемент, връща резултата от извикването на `$else` или null. + `$predicate` има сигнатура `function ($value, int|string $key, array $array): bool`. + +Той не променя вътрешния указател за разлика от `reset()`. Параметрите `$predicate` и `$else` съществуват от версия 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Връща първия запис в масива или null, ако масивът е празен. Не променя вътрешния указател, за разлика от `reset()`. +Вижте [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Връща ключа на първия елемент (отговарящ на зададения предикат, ако е зададен) или null, ако няма такъв елемент. `$predicate` има сигнатура `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Масиви::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Вижте [lastKey( |#lastKey()]). + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Връща последния елемент (отговарящ на зададения предикат, ако е зададен). Ако няма такъв елемент, връща резултата от извикването на `$else` или null. + `$predicate` има сигнатура `function ($value, int|string $key, array $array): bool`. + +Той не променя вътрешния указател за разлика от `end()`. Параметрите `$predicate` и `$else` съществуват от версия 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Вижте [first( |#first()]). + -Връща последния запис на масива или null, ако масивът е празен. Не променя вътрешния указател, за разлика от `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Връща ключа на последния елемент (отговарящ на зададения предикат, ако е зададен) или null, ако няма такъв елемент. `$predicate` има сигнатура `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Вижте [firstKey( |#firstKey()]). + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Извиква `$callback` върху всички елементи на масив и връща масив от върнати стойности. Обратното извикване има сигнатура `function ($value, $key, array $array): bool`. +Извиква `$transformer` върху всички елементи на масив и връща масив от върнати стойности. Обратното извикване има сигнатура `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,10 +383,10 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // vrátí null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- -Проверява се дали поне един елемент от масива е преминал теста, реализиран в `$callback`, с подпис `function ($value, $key, array $array): bool`. +Проверява се дали поне един елемент от масива е преминал теста, реализиран в `$predicate`, с подпис `function ($value, $key, array $array): bool`. ```php $array = [1, 2, 3, 4]; diff --git a/utils/bg/images.texy b/utils/bg/images.texy index 68435e34bd..ba22eb6872 100644 --- a/utils/bg/images.texy +++ b/utils/bg/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Определя дали даденият [тип |#Formats] изображение се поддържа. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Връща масив от поддържаните типове изображения (константи `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Изчислява размерите на правоъгълника, който огражда текст с определен шрифт и размер. Връща асоциативен масив, съдържащ ключовете `left`, `top`, `width`, `height`. Лявото поле може да бъде отрицателно, ако текстът започва с ляв надвес. diff --git a/utils/bg/iterables.texy b/utils/bg/iterables.texy new file mode 100644 index 0000000000..8fcdc85e1d --- /dev/null +++ b/utils/bg/iterables.texy @@ -0,0 +1,119 @@ +Функции на итератора +******************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] е статичен клас с функции за работа с итератори. Неговият аналог за масиви е [Nette\Utils\Arrays |arrays]. + + +Инсталация: + +```shell +composer require nette/utils +``` + +Всички примери предполагат създаването на псевдоним: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Тества за наличие на стойност в итератора. Използва стриктно сравнение (`===`). + +```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] +------------------------------------------------------- + +Тества за наличие на ключ в итератора. Използва стриктно сравнение (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false +``` + + +every(iterable $iterable, callable $predicate): bool .[method] +-------------------------------------------------------------- + +Проверява дали всички елементи на итератора са преминали тест, реализиран в `$predicate` със сигнатура `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 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`. Запазва оригиналните ключове. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Итератор, който трансформира стойностите чрез извикване на `$transformer`. Той има сигнатура `function ($value, $key, iterable $iterable): bool`. Запазва оригиналните ключове. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +some(iterable $iterable, callable $predicate): bool .[method] +------------------------------------------------------------- + +Проверява дали поне един елемент от итератора преминава тест, реализиран в `$predicate` със сигнатура `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Вижте [every( |#every()]). diff --git a/utils/cs/@home.texy b/utils/cs/@home.texy index bd9a730b5f..4afd52488a 100644 --- a/utils/cs/@home.texy +++ b/utils/cs/@home.texy @@ -8,6 +8,7 @@ V balíčku `nette/utils` najdete sadu užitečných tříd pro každodenní pou | [Datum a čas |datetime] | Nette\Utils\DateTime | [Finder] | Nette\Utils\Finder | [HTML elementy |html-elements] | Nette\Utils\Html +| [Iterátory |iterables] | Nette\Utils\Iterables | [JSON |json] | Nette\Utils\Json | [Náhodné řetězce |random] | Nette\Utils\Random | [Obrázky |images] | Nette\Utils\Image diff --git a/utils/cs/@left-menu.texy b/utils/cs/@left-menu.texy index f64ec996d3..387fe25685 100644 --- a/utils/cs/@left-menu.texy +++ b/utils/cs/@left-menu.texy @@ -5,6 +5,7 @@ Balíček nette/utils - [Finder] - [Floats] - [HTML elementy |html-elements] +- [Iterátory |iterables] - [JSON] - [Náhodné řetězce |random] - [Obrázky |images] diff --git a/utils/cs/arrays.texy b/utils/cs/arrays.texy index f4e63d26fb..b97bf5a19b 100644 --- a/utils/cs/arrays.texy +++ b/utils/cs/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays ====== -[api:Nette\Utils\Arrays] je statická třída obsahující užitečné funkce pro práci s poli. +[api:Nette\Utils\Arrays] je statická třída obsahující užitečné funkce pro práci s poli. Její obdobou pro iterátory je [Nette\Utils\Iterables|iterables]. Následující příklady předpokládají vytvořený alias: @@ -76,10 +76,10 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- -Testuje, zda všechny prvky v poli projdou testem implementovaným v `$callback` se signaturou `function ($value, $key, array $array): bool`. +Testuje, zda všechny prvky v poli projdou testem implementovaným v `$predicate` se signaturou `function ($value, $key, array $array): bool`. ```php $array = [1, 30, 39, 29, 10, 13]; @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Viz [#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Vrací nové pole obsahující všechny dvojice klíč-hodnota odpovídající zadanému predikátu. Callback má signaturu `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?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, int|string $key, array $array): bool`. + +Nezmění vnitřní ukazatel narozdíl od `reset()`. Parametry `$predicate` a `$else` existují od verze 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Vrátí první položku z pole nebo null, pokud je pole prázdné. Nezmění vnitřní ukazatel narozdíl od `reset()`. +Viz [#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Vrací klíč první položky (odpovídající predikátu, pokud je uveden) nebo null, pokud taková položka neexistuje. Predikát `$predicate` má signaturu `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Viz [#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Vrátí poslední 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, int|string $key, array $array): bool`. + +Nezmění vnitřní ukazatel narozdíl od `end()`. Parametry `$predicate` a `$else` existují od verze 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Viz [#first()]. + -Vrátí poslední položku z pole nebo null, pokud je pole prázdné. Nezmění vnitřní ukazatel narozdíl od `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Vrací klíč poslední položky (odpovídající predikátu, pokud je uveden) nebo null, pokud taková položka neexistuje. Predikát `$predicate` má signaturu `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Viz [#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Zavolá `$callback` na všechny prvky v poli a vrátí pole vrácených hodnot. Callback má signaturu `function ($value, $key, array $array): bool`. +Zavolá `$transformer` na všechny prvky v poli a vrátí pole vrácených hodnot. Callback má signaturu `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,10 +383,10 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // vrátí null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- -Testuje, zda alespoň jeden prvek v poli projde testem implementovaným v `$callback` se signaturou `function ($value, $key, array $array): bool`. +Testuje, zda alespoň jeden prvek v poli projde testem implementovaným v `$predicate` se signaturou `function ($value, $key, array $array): bool`. ```php $array = [1, 2, 3, 4]; diff --git a/utils/cs/images.texy b/utils/cs/images.texy index 1ae07eb9b7..213eb24804 100644 --- a/utils/cs/images.texy +++ b/utils/cs/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Zjišťuje, zda je podporovaný daný [typ|#Formáty] obrázku. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Vrací pole podporovaných [typů|#Formáty] obrázku. + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Spočítá rozměry obdélníku, který obepne text v určitém písmu a velikosti. Vrací asociativní pole obsahující klíče `left`, `top`, `width`, `height`. Levý okraj může být i záporný, pokud text začíná levým podřezáváním. diff --git a/utils/cs/iterables.texy b/utils/cs/iterables.texy new file mode 100644 index 0000000000..9d1b474457 --- /dev/null +++ b/utils/cs/iterables.texy @@ -0,0 +1,119 @@ +Práce s iterátory +***************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] je statická třída s funkcemi pro práci s iterátory. Její obdobou pro pole je [Nette\Utils\Arrays|arrays]. + + +Instalace: + +```shell +composer require nette/utils +``` + +Všechny příklady předpokládají vytvořený alias: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Testuje přítomnost hodnoty v iterátoru. Používá striktní porovnání (`===`). + +```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] +------------------------------------------------------- + +Testuje přítomnost klíče v iterátoru. Používá striktní porovnání (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Viz [#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Viz [#every()]. diff --git a/utils/de/@home.texy b/utils/de/@home.texy index dd67234580..16b27abe0b 100644 --- a/utils/de/@home.texy +++ b/utils/de/@home.texy @@ -13,6 +13,7 @@ Im Paket `nette/utils` finden Sie eine Reihe von nützlichen Klassen für den t | [Generieren von HTML-Code |html-elements] | Nette\Utils\Html | [Helferfunktionen |helpers] | Nette\Utils\Helfer | [JSON] | Nette\Utils\Json +| [Iterables |iterables] | Nette\Utils\Iterables | [Paginator] | Nette\Utils\Paginator | [PHP-Reflexion |reflection] | Nette\Utils\Reflexion | [Rückruf |Callback] | Nette\Utils\Callback diff --git a/utils/de/@left-menu.texy b/utils/de/@left-menu.texy index 5ca87cc2c6..e94adaa3c3 100644 --- a/utils/de/@left-menu.texy +++ b/utils/de/@left-menu.texy @@ -8,6 +8,7 @@ Paket nette/utils - [Finder] - [Floats] - [Hilfsfunktionen |helpers] +- [Iterabilien |iterables] - [HTML-Elemente |HTML Elements] - [JSON] - [Paginator |paginator] diff --git a/utils/de/arrays.texy b/utils/de/arrays.texy index cd3ec38478..73f7372c02 100644 --- a/utils/de/arrays.texy +++ b/utils/de/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] ist eine statische Klasse, die eine Handvoll praktischer Array-Funktionen enthält. +[api:Nette\Utils\Arrays] ist eine statische Klasse, die eine Handvoll praktischer Array-Funktionen enthält. Ihre Entsprechung für Iteratoren ist [Nette\Utils\Iterables |iterables]. Die folgenden Beispiele setzen voraus, dass der folgende Klassenalias definiert ist: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Prüft, ob alle Elemente im Array den Test bestehen, der von der angegebenen Funktion mit der Signatur `function ($value, $key, array $array): bool` implementiert wird. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Siehe [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Gibt ein neues Array zurück, das alle Schlüssel-Wert-Paare enthält, die mit dem angegebenen `$predicate` übereinstimmen. Der Callback hat die Signatur `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Gibt das erste Element zurück (das dem angegebenen Prädikat entspricht, falls angegeben). Wenn es kein solches Element gibt, wird das Ergebnis des Aufrufs von `$else` oder null zurückgegeben. + `$predicate` hat die Signatur `function ($value, int|string $key, array $array): bool`. + +Im Gegensatz zu `reset()` wird der interne Zeiger nicht verändert. Die Parameter `$predicate` und `$else` gibt es seit Version 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Gibt das erste Element aus dem Array zurück oder null, wenn Array leer ist. Im Gegensatz zu `reset()` wird der interne Zeiger nicht verändert. +Siehe [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Gibt den Schlüssel des ersten Elements zurück (das mit dem angegebenen Prädikat übereinstimmt, falls gegeben) oder null, wenn es kein solches Element gibt. `$predicate` hat die Signatur `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Siehe [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Gibt das letzte Element zurück (das dem angegebenen Prädikat entspricht, falls angegeben). Wenn es kein solches Element gibt, wird das Ergebnis des Aufrufs von `$else` oder null zurückgegeben. + `$predicate` hat die Signatur `function ($value, int|string $key, array $array): bool`. + +Im Gegensatz zu `end()` wird der interne Zeiger nicht verändert. Die Parameter `$predicate` und `$else` gibt es seit Version 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Siehe [first() |#first()]. + -Gibt das letzte Element des Arrays zurück oder null, wenn das Array leer ist. Im Gegensatz zu `end()` wird der interne Zeiger nicht verändert. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Gibt den Schlüssel des letzten Elements zurück (das mit dem angegebenen Prädikat übereinstimmt, falls angegeben) oder null, wenn es kein solches Element gibt. `$predicate` hat die Signatur `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Siehe [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Ruft `$callback` für alle Elemente im Array auf und gibt das Array der Rückgabewerte zurück. Der Callback hat die Signatur `function ($value, $key, array $array): bool`. +Ruft `$transformer` für alle Elemente im Array auf und gibt das Array der Rückgabewerte zurück. Der Callback hat die Signatur `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returns null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Prüft, ob mindestens ein Element im Array den Test besteht, der durch den angegebenen Callback mit der Signatur `function ($value, $key, array $array): bool` implementiert wird. diff --git a/utils/de/images.texy b/utils/de/images.texy index 5aef1e8eb2..861dda114b 100644 --- a/utils/de/images.texy +++ b/utils/de/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Ermittelt, ob der angegebene [Bildtyp |#Formats] unterstützt wird. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Gibt ein Array der unterstützten Bildtypen zurück (Konstanten `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Berechnet die Abmessungen des Rechtecks, das den Text in einer bestimmten Schriftart und -größe umschließt. Sie gibt ein assoziatives Array zurück, das die Schlüssel `left`, `top`, `width`, `height` enthält. Der linke Rand kann negativ sein, wenn der Text mit einem linken Überhang beginnt. diff --git a/utils/de/iterables.texy b/utils/de/iterables.texy new file mode 100644 index 0000000000..cf64305f41 --- /dev/null +++ b/utils/de/iterables.texy @@ -0,0 +1,119 @@ +Iterator-Funktionen +******************* + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] ist eine statische Klasse mit Funktionen für die Arbeit mit Iteratoren. Ihr Gegenstück für Arrays ist [Nette\Utils\Arrays |arrays]. + + +Installation: + +```shell +composer require nette/utils +``` + +Alle Beispiele gehen von der Erstellung eines Alias aus: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Prüft auf das Vorhandensein eines Wertes im Iterator. Er verwendet einen strengen Vergleich (`===`). + +```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] +------------------------------------------------------- + +Prüft auf das Vorhandensein eines Schlüssels im Iterator. Er verwendet einen strengen Vergleich (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Siehe [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Siehe [every() |#every()]. diff --git a/utils/el/@home.texy b/utils/el/@home.texy index d9739dc497..a0678fe23b 100644 --- a/utils/el/@home.texy +++ b/utils/el/@home.texy @@ -13,6 +13,7 @@ | [Helpers |helpers] | Nette\Utils\Helpers | [Στοιχεία HTML |HTML Elements] | Nette\Utils\Html | [Images |Images] | Nette\Utils\Image +| [Iterables |iterables] | Nette\Utils\Iterables | [JSON |JSON] | Nette\Utils\Json | [Paginator |paginator] | Nette\Utils\Paginator | [PHP Reflection |reflection] | Nette\Utils\Reflection diff --git a/utils/el/@left-menu.texy b/utils/el/@left-menu.texy index 6ef2e7ba0b..1f5380b7a1 100644 --- a/utils/el/@left-menu.texy +++ b/utils/el/@left-menu.texy @@ -8,6 +8,7 @@ - [Βοηθοί |helpers] - [Στοιχεία HTML |HTML Elements] - [Εικόνες |Images] +- [Iterables |iterables] - [JSON |JSON] - [Σελιδοποιητής |paginator] - [Τυχαίες συμβολοσειρές |random] diff --git a/utils/el/arrays.texy b/utils/el/arrays.texy index 6bb271d5e7..42a4978c65 100644 --- a/utils/el/arrays.texy +++ b/utils/el/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] είναι μια στατική κλάση, η οποία περιέχει μια χούφτα από εύχρηστες συναρτήσεις συστοιχιών. +[api:Nette\Utils\Arrays] είναι μια στατική κλάση, η οποία περιέχει μια χούφτα από εύχρηστες συναρτήσεις πίνακα. Το ισοδύναμό της για τους επαναλήπτες είναι η [Nette\Utils\Iterables |iterables]. Τα παραδείγματα που ακολουθούν υποθέτουν ότι έχει οριστεί το ακόλουθο ψευδώνυμο της κλάσης: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Ελέγχει αν όλα τα στοιχεία του πίνακα περνούν τον έλεγχο που υλοποιείται από την παρεχόμενη συνάρτηση, η οποία έχει την υπογραφή `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Βλέπε [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Επιστρέφει έναν νέο πίνακα που περιέχει όλα τα ζεύγη κλειδιών-τιμών που ταιριάζουν με το δεδομένο `$predicate`. Το callback έχει την υπογραφή `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Επιστρέφει το πρώτο στοιχείο (που ταιριάζει με το καθορισμένο κατηγόρημα, αν δίνεται). Εάν δεν υπάρχει τέτοιο στοιχείο, επιστρέφει το αποτέλεσμα της κλήσης του `$else` ή null. +Το `$predicate` έχει την υπογραφή `function ($value, int|string $key, array $array): bool`. + +Δεν αλλάζει τον εσωτερικό δείκτη σε αντίθεση με το `reset()`. Οι παράμετροι `$predicate` και `$else` υπάρχουν από την έκδοση 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Επιστρέφει το πρώτο στοιχείο από τον πίνακα ή null αν ο πίνακας είναι άδειος. Δεν αλλάζει τον εσωτερικό δείκτη σε αντίθεση με το `reset()`. +Βλέπε [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Επιστρέφει το κλειδί του πρώτου στοιχείου (που ταιριάζει με το καθορισμένο κατηγόρημα, αν δίνεται) ή null αν δεν υπάρχει τέτοιο στοιχείο. Το `$predicate` έχει την υπογραφή `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Βλέπε [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Επιστρέφει το τελευταίο στοιχείο (που ταιριάζει με το καθορισμένο κατηγόρημα, αν δίνεται). Εάν δεν υπάρχει τέτοιο στοιχείο, επιστρέφει το αποτέλεσμα της κλήσης του `$else` ή null. +Το `$predicate` έχει την υπογραφή `function ($value, int|string $key, array $array): bool`. + +Δεν αλλάζει τον εσωτερικό δείκτη σε αντίθεση με το `end()`. Οι παράμετροι `$predicate` και `$else` υπάρχουν από την έκδοση 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Βλέπε [first() |#first()]. + -Επιστρέφει το τελευταίο στοιχείο από τον πίνακα ή null αν ο πίνακας είναι άδειος. Δεν αλλάζει τον εσωτερικό δείκτη σε αντίθεση με το `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Επιστρέφει το κλειδί του τελευταίου στοιχείου (που ταιριάζει με το καθορισμένο κατηγόρημα, αν δίνεται) ή null αν δεν υπάρχει τέτοιο στοιχείο. Το `$predicate` έχει την υπογραφή `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Βλέπε [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Καλεί το `$callback` σε όλα τα στοιχεία του πίνακα και επιστρέφει τον πίνακα των τιμών επιστροφής. Η ανάκληση έχει την υπογραφή `function ($value, $key, array $array): bool`. +Καλεί το `$transformer` σε όλα τα στοιχεία του πίνακα και επιστρέφει τον πίνακα των τιμών επιστροφής. Η ανάκληση έχει την υπογραφή `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // επιστρέφει ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Ελέγχει αν τουλάχιστον ένα στοιχείο του πίνακα περνάει το τεστ που υλοποιείται από την παρεχόμενη κλήση με υπογραφή `function ($value, $key, array $array): bool`. diff --git a/utils/el/images.texy b/utils/el/images.texy index 6260f68f37..c90e750c2d 100644 --- a/utils/el/images.texy +++ b/utils/el/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Καθορίζει αν υποστηρίζεται ο συγκεκριμένος [τύπος |#Formats] εικόνας. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Επιστρέφει έναν πίνακα υποστηριζόμενων τύπων εικόνας (σταθερές `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Υπολογίζει τις διαστάσεις του ορθογωνίου που περικλείει το κείμενο σε καθορισμένη γραμματοσειρά και μέγεθος. Επιστρέφει έναν συσχετιστικό πίνακα που περιέχει τα κλειδιά `left`, `top`, `width`, `height`. Το αριστερό περιθώριο μπορεί να είναι αρνητικό εάν το κείμενο ξεκινά με αριστερή προεξοχή. diff --git a/utils/el/iterables.texy b/utils/el/iterables.texy new file mode 100644 index 0000000000..18b7eca582 --- /dev/null +++ b/utils/el/iterables.texy @@ -0,0 +1,119 @@ +Λειτουργίες επαναλήπτη +********************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] είναι μια στατική κλάση με συναρτήσεις για την εργασία με επαναλήπτες. Η αντίστοιχη κλάση για πίνακες είναι η [Nette\Utils\Arrays |arrays]. + + +Εγκατάσταση: + +```shell +composer require nette/utils +``` + +Όλα τα παραδείγματα προϋποθέτουν τη δημιουργία ενός ψευδώνυμου: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Ελέγχει την παρουσία μιας τιμής στον επαναλήπτη. Χρησιμοποιεί αυστηρή σύγκριση (`===`). + +```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] +------------------------------------------------------- + +Ελέγχει την παρουσία ενός κλειδιού στον επαναλήπτη. Χρησιμοποιεί αυστηρή σύγκριση (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false +``` + + +every(iterable $iterable, callable $predicate): bool .[method] +-------------------------------------------------------------- + +Ελέγχει αν όλα τα στοιχεία του επαναλήπτη περνούν ένα τεστ που υλοποιείται στο `$predicate` με την υπογραφή `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 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`. Διατηρεί τα αρχικά κλειδιά. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Επαναλήπτης που μετασχηματίζει τις τιμές καλώντας το `$transformer`. Έχει την υπογραφή `function ($value, $key, iterable $iterable): bool`. Διατηρεί τα αρχικά κλειδιά. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +some(iterable $iterable, callable $predicate): bool .[method] +------------------------------------------------------------- + +Ελέγχει αν τουλάχιστον ένα στοιχείο του επαναλήπτη περνάει ένα τεστ που υλοποιείται στο `$predicate` με την υπογραφή `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Βλέπε [every() |#every()]. diff --git a/utils/en/@home.texy b/utils/en/@home.texy index 470030790b..a46e587848 100644 --- a/utils/en/@home.texy +++ b/utils/en/@home.texy @@ -13,6 +13,7 @@ In package `nette/utils` you will find a set of useful classes for everyday use: | [Helpers |helpers] | Nette\Utils\Helpers | [HTML Elements] | Nette\Utils\Html | [Images] | Nette\Utils\Image +| [Iterables] | Nette\Utils\Iterables | [JSON] | Nette\Utils\Json | [Paginator |paginator] | Nette\Utils\Paginator | [PHP Reflection |reflection] | Nette\Utils\Reflection diff --git a/utils/en/@left-menu.texy b/utils/en/@left-menu.texy index fc5b708ef1..8a94eff2d9 100644 --- a/utils/en/@left-menu.texy +++ b/utils/en/@left-menu.texy @@ -8,6 +8,7 @@ Package nette/utils - [Helpers |helpers] - [HTML Elements] - [Images] +- [Iterables] - [JSON] - [Paginator |paginator] - [Random Strings |random] diff --git a/utils/en/arrays.texy b/utils/en/arrays.texy index d55ef13abb..a529286644 100644 --- a/utils/en/arrays.texy +++ b/utils/en/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays ====== -[api:Nette\Utils\Arrays] is a static class, which contains a handful of handy array functions. +[api:Nette\Utils\Arrays] is a static class, which contains a handful of handy array functions. Its equivalent for iterators is [Nette\Utils\Iterables|iterables]. Following examples assume the following class alias is defined: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Tests whether all elements in the array pass the test implemented by the provided function, which has the signature `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true See [#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Returns a new array containing all key-value pairs matching the given `$predicate`. The callback has the signature `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Returns the first item (matching the specified predicate if given). If there is no such item, it returns result of invoking `$else` or null. +The `$predicate` has the signature `function ($value, int|string $key, array $array): bool`. + +It does not change the internal pointer unlike `reset()`. The `$predicate` and `$else` parameters exist since version 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Returns the first item from the array or null if array is empty. It does not change the internal pointer unlike `reset()`. +See [#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Returns the key of first item (matching the specified predicate if given) or null if there is no such item. The `$predicate` has the signature `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +See [#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Returns the last item (matching the specified predicate if given). If there is no such item, it returns result of invoking `$else` or null. +The `$predicate` has the signature `function ($value, int|string $key, array $array): bool`. + +It does not change the internal pointer unlike `end()`. The `$predicate` and `$else` parameters exist since version 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +See [#first()]. + -Returns the last item from the array or null if array is empty. It does not change the internal pointer unlike `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Returns the key of last item (matching the specified predicate if given) or null if there is no such item. The `$predicate` has the signature `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +See [#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Calls `$callback` on all elements in the array and returns the array of return values. The callback has the signature `function ($value, $key, array $array): bool`. +Calls `$transformer` on all elements in the array and returns the array of return values. The callback has the signature `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returns null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Tests whether at least one element in the array passes the test implemented by the provided callback with signature `function ($value, $key, array $array): bool`. diff --git a/utils/en/images.texy b/utils/en/images.texy index 214cd3daae..e6ef329deb 100644 --- a/utils/en/images.texy +++ b/utils/en/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Determines if the given image [type|#Formats] is supported. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Returns an array of supported image [types|#Formats]. + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Calculates the dimensions of the rectangle that encloses the text in a specified font and size. It returns an associative array containing the keys `left`, `top`, `width`, `height`. The left margin can be negative if the text starts with a left overhang. diff --git a/utils/en/iterables.texy b/utils/en/iterables.texy new file mode 100644 index 0000000000..b348fdf336 --- /dev/null +++ b/utils/en/iterables.texy @@ -0,0 +1,119 @@ +Iterator Functions +****************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] is a static class with functions for working with iterators. Its counterpart for arrays is [Nette\Utils\Arrays|arrays]. + + +Installation: + +```shell +composer require nette/utils +``` + +All examples assume the creation of an alias: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Tests for the presence of a value in the iterator. It uses strict comparison (`===`). + +```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] +------------------------------------------------------- + +Tests for the presence of a key in the iterator. It uses strict comparison (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +See [#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iterator that transforms values by calling `$transformer`. It has the signature `function ($value, $key, iterable $iterable): bool`. Maintains original keys. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +See [#every()]. diff --git a/utils/es/@home.texy b/utils/es/@home.texy index de0038e21f..0bfdbb5347 100644 --- a/utils/es/@home.texy +++ b/utils/es/@home.texy @@ -13,6 +13,7 @@ En el paquete `nette/utils` encontrará un conjunto de clases útiles para el us | [Generación de cadenas aleatorias |random] | Nette\Utils\Random | [Generar código HTML |html-elements] | Nette\Utils\Html | [Generar PHP Reflection |reflection] | Nette\Utils\Reflection +| [Iterables |iterables] | Nette\Utils\Iterables | [Imágenes |Images] | Nette\Utils\Image | [JSON] | Nette\Utils\Json | [Matrices |Arrays] | Nette\Utils\Arrays diff --git a/utils/es/@left-menu.texy b/utils/es/@left-menu.texy index 5bea16e074..efa56faafc 100644 --- a/utils/es/@left-menu.texy +++ b/utils/es/@left-menu.texy @@ -8,6 +8,7 @@ Paquete nette/utils - [Fecha y hora |datetime] - [Flotadores |Floats] - [Funciones auxiliares |helpers] +- [Iterables |iterables] - [Imágenes |Images] - [JSON] - [Matrices |Arrays] diff --git a/utils/es/arrays.texy b/utils/es/arrays.texy index 219739fbdc..8f3956f59c 100644 --- a/utils/es/arrays.texy +++ b/utils/es/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] es una clase estática que contiene un puñado de prácticas funciones de array. +[api:Nette\Utils\Arrays] es una clase estática, que contiene un puñado de prácticas funciones de array. Su equivalente para iteradores es [Nette\Utils\Iterables |iterables]. Los siguientes ejemplos asumen que el siguiente alias de clase está definido: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Comprueba si todos los elementos de la matriz pasan la prueba implementada por la función proporcionada, que tiene la firma `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Véase [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Devuelve una nueva matriz que contiene todos los pares clave-valor que coinciden con la dirección `$predicate`. La llamada de retorno tiene la firma `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Devuelve el primer elemento (que coincida con el predicado especificado si se da). Si no existe tal elemento, devuelve el resultado de invocar `$else` o null. +El `$predicate` tiene la firma `function ($value, int|string $key, array $array): bool`. + +No modifica el puntero interno, a diferencia de `reset()`. Los parámetros `$predicate` y `$else` existen desde la versión 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Devuelve el primer elemento del array o null si el array está vacío. No cambia el puntero interno a diferencia de `reset()`. +Véase [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Devuelve la clave del primer elemento (que coincida con el predicado especificado si se da) o null si no existe tal elemento. `$predicate` tiene la firma `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Véase [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Devuelve el último elemento (que coincida con el predicado especificado si se da). Si no existe tal elemento, devuelve el resultado de invocar `$else` o null. +El `$predicate` tiene la firma `function ($value, int|string $key, array $array): bool`. + +No modifica el puntero interno, a diferencia de `end()`. Los parámetros `$predicate` y `$else` existen desde la versión 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Véase [first() |#first()]. + -Devuelve el último elemento del array o null si el array está vacío. No cambia el puntero interno a diferencia de `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Devuelve la clave del último elemento (que coincida con el predicado especificado si se da) o null si no existe tal elemento. `$predicate` tiene la firma `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Véase [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Llama a `$callback` en todos los elementos de la matriz y devuelve la matriz de valores de retorno. La llamada de retorno tiene la firma `function ($value, $key, array $array): bool`. +Llama a `$transformer` en todos los elementos de la matriz y devuelve la matriz de valores de retorno. La llamada de retorno tiene la firma `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returns null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Comprueba si al menos un elemento de la matriz supera la prueba implementada por la llamada de retorno proporcionada con la firma `function ($value, $key, array $array): bool`. diff --git a/utils/es/images.texy b/utils/es/images.texy index 3d34e6f2c0..85e01cfd60 100644 --- a/utils/es/images.texy +++ b/utils/es/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Determina si el [tipo de |#Formats] imagen dado es compatible. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Devuelve un array de tipos de imagen soportados (constantes `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Calcula las dimensiones del rectángulo que encierra el texto en una fuente y tamaño especificados. Devuelve una matriz asociativa que contiene las claves `left`, `top`, `width`, `height`. El margen izquierdo puede ser negativo si el texto comienza con un saliente a la izquierda. diff --git a/utils/es/iterables.texy b/utils/es/iterables.texy new file mode 100644 index 0000000000..fd4aa9ef4f --- /dev/null +++ b/utils/es/iterables.texy @@ -0,0 +1,119 @@ +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]. + + +Instalación: + +```shell +composer require nette/utils +``` + +Todos los ejemplos suponen la creación de un alias: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Comprueba la presencia de un valor en el iterador. Utiliza la comparación estricta (`===`). + +```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] +------------------------------------------------------- + +Comprueba la presencia de una clave en el iterador. Utiliza la comparación estricta (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Véase [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iterador que transforma valores llamando a `$transformer`. Tiene la firma `function ($value, $key, iterable $iterable): bool`. Mantiene las claves originales. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Véase [every() |#every()]. diff --git a/utils/fr/@home.texy b/utils/fr/@home.texy index c22a155f85..174f8aadf2 100644 --- a/utils/fr/@home.texy +++ b/utils/fr/@home.texy @@ -13,6 +13,7 @@ Dans le paquetage `nette/utils`, vous trouverez un ensemble de classes utiles po | [Chaînes de caractères |Strings] | Nette\Utils\Strings | [Images] | Nette\Utils\Image | [JSON] | Nette\Utils\Json +| [Iterables |iterables] | Nette\Utils\Iterables | [Finder] | Nette\Utils\Finder | [Paginateur |Paginator] | Nette\Utils\Paginator | [PHP Reflection |reflection] | Nette\Utils\Reflection diff --git a/utils/fr/@left-menu.texy b/utils/fr/@left-menu.texy index bddfa8c498..93efe1a2b7 100644 --- a/utils/fr/@left-menu.texy +++ b/utils/fr/@left-menu.texy @@ -8,6 +8,7 @@ Paquet net/utils - [Chaînes aléatoires |random] - [Chaînes de caractères |Strings] - [Images] +- [Itérables |iterables] - [JSON] - [Paginateur |paginator] - [PHP Reflection |reflection] diff --git a/utils/fr/arrays.texy b/utils/fr/arrays.texy index b99a079110..bf9ad09adf 100644 --- a/utils/fr/arrays.texy +++ b/utils/fr/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Matrices .[#toc-arrays] ======================= -[api:Nette\Utils\Arrays] est une classe statique, qui contient une poignée de fonctions pratiques pour les tableaux. +[api:Nette\Utils\Arrays] est une classe statique qui contient une poignée de fonctions pratiques pour les tableaux. Son équivalent pour les itérateurs est [Nette\Utils\Iterables |iterables]. Les exemples suivants supposent que l'alias de classe suivant est défini : @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Teste si tous les éléments du tableau passent le test implémenté par la fonction fournie, qui a la signature `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Voir [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Renvoie un nouveau tableau contenant toutes les paires clé-valeur correspondant à l'adresse `$predicate`. Le rappel a la signature `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Renvoie le premier élément (correspondant au prédicat spécifié s'il est donné). S'il n'y a pas d'élément de ce type, il renvoie le résultat de l'invocation de `$else` ou null. +Le site `$predicate` a la signature `function ($value, int|string $key, array $array): bool`. + +Il ne modifie pas le pointeur interne, contrairement à `reset()`. Les paramètres `$predicate` et `$else` existent depuis la version 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Retourne le premier élément du tableau ou null si le tableau est vide. Elle ne modifie pas le pointeur interne contrairement à `reset()`. +Voir [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Renvoie la clé du premier élément (correspondant au prédicat spécifié s'il est donné) ou null s'il n'y a pas d'élément de ce type. La signature de `$predicate` est `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Voir [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Renvoie le dernier élément (correspondant au prédicat spécifié, le cas échéant). S'il n'existe pas d'élément de ce type, il renvoie le résultat de l'invocation de `$else` ou null. +Le site `$predicate` a la signature `function ($value, int|string $key, array $array): bool`. + +Il ne modifie pas le pointeur interne, contrairement à `end()`. Les paramètres `$predicate` et `$else` existent depuis la version 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Voir [first() |#first()]. + -Retourne le dernier élément du tableau ou null si le tableau est vide. Elle ne modifie pas le pointeur interne contrairement à `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Renvoie la clé du dernier élément (correspondant au prédicat spécifié s'il est donné) ou null s'il n'y a pas d'élément de ce type. La signature de `$predicate` est `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Voir [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Appelle `$callback` sur tous les éléments du tableau et renvoie le tableau des valeurs de retour. Le callback a la signature `function ($value, $key, array $array): bool`. +Appelle `$transformer` sur tous les éléments du tableau et renvoie le tableau des valeurs de retour. Le callback a la signature `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returns null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Teste si au moins un élément du tableau passe le test implémenté par la callback fournie avec la signature `function ($value, $key, array $array): bool`. diff --git a/utils/fr/images.texy b/utils/fr/images.texy index 293f68cb22..33836488b4 100644 --- a/utils/fr/images.texy +++ b/utils/fr/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Détermine si le [type d' |#Formats] image donné est pris en charge. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Renvoie un tableau des types d'images pris en charge (constantes `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Calcule les dimensions du rectangle qui entoure le texte d'une police et d'une taille spécifiées. Il renvoie un tableau associatif contenant les clés `left`, `top`, `width`, `height`. La marge de gauche peut être négative si le texte commence avec un débordement à gauche. diff --git a/utils/fr/iterables.texy b/utils/fr/iterables.texy new file mode 100644 index 0000000000..cc63f3c5c7 --- /dev/null +++ b/utils/fr/iterables.texy @@ -0,0 +1,119 @@ +Fonctions de l'itérateur +************************ + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] est une classe statique contenant des fonctions permettant de travailler avec des itérateurs. Son équivalent pour les tableaux est [Nette\Utils\Arrays |arrays]. + + +L'installation : + +```shell +composer require nette/utils +``` + +Tous les exemples supposent la création d'un alias : + +```php +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 (`===`). + +```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] +------------------------------------------------------- + +Teste la présence d'une clé dans l'itérateur. Il utilise la comparaison stricte (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Voir [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Voir [every() |#every()]. diff --git a/utils/hu/@home.texy b/utils/hu/@home.texy index 3ad3dae544..9597ed506f 100644 --- a/utils/hu/@home.texy +++ b/utils/hu/@home.texy @@ -13,6 +13,7 @@ A `nette/utils` csomagban a mindennapi használatra hasznos osztályok találhat | [Segédprogramok |helpers] | Nette\Utils\Helpers | [HTML elemek |HTML Elements] | Nette\Utils\Html | [Képek |Images] | Nette\Utils\Image +| [Iterables |iterables] | Nette\Utils\Iterables | [JSON |JSON] | Nette\Utils\Json | [Paginátor |paginator] | Nette\Utils\Paginátor | [PHP Reflection |reflection] | Nette\Utils\Reflection diff --git a/utils/hu/@left-menu.texy b/utils/hu/@left-menu.texy index 9e6f969b23..8068605260 100644 --- a/utils/hu/@left-menu.texy +++ b/utils/hu/@left-menu.texy @@ -8,6 +8,7 @@ Csomag nette/utils - [Segédprogramok |helpers] - [HTML elemek |HTML Elements] - [Képek |Images] +- [Iterábilisok |iterables] - [JSON |JSON] - [Paginátor |paginator] - [Véletlenszerű karakterláncok |random] diff --git a/utils/hu/arrays.texy b/utils/hu/arrays.texy index 04ad5c1c18..178927eb84 100644 --- a/utils/hu/arrays.texy +++ b/utils/hu/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] egy statikus osztály, amely egy maroknyi praktikus tömbfüggvényt tartalmaz. +[api:Nette\Utils\Arrays] egy statikus osztály, amely egy maroknyi hasznos tömbfüggvényt tartalmaz. Ennek megfelelője az iterátorok esetében a [Nette\Utils\Iterables |iterables]. A következő példák feltételezik, hogy a következő osztály alias definiálva van: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Megvizsgálja, hogy a tömb minden eleme megfelel-e a megadott függvény által végrehajtott tesztnek, amelynek aláírása `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Lásd [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Visszaad egy új tömböt, amely tartalmazza az összes kulcs-érték párt, amely megfelel a megadott `$predicate`. A visszahívás aláírása `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Visszaadja az első elemet (amely megfelel a megadott predikátumnak, ha megadva van). Ha nincs ilyen elem, akkor a `$else` meghívásának eredményét vagy nullát adja vissza. +A `$predicate` aláírása `function ($value, int|string $key, array $array): bool`. + +Nem változtatja meg a belső mutatót, ellentétben a `reset()`. A `$predicate` és `$else` paraméterek a 4.0.4-es verzió óta léteznek. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Visszaadja a tömb első elemét, vagy null, ha a tömb üres. Nem változtatja meg a belső mutatót, ellentétben a `reset()`. +Lásd [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Visszaadja az első elem kulcsát (amely megfelel a megadott predikátumnak, ha megadva van), vagy null, ha nincs ilyen elem. A `$predicate` aláírása `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Lásd [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Visszaadja az utolsó elemet (amely megfelel a megadott predikátumnak, ha megadva van). Ha nincs ilyen elem, akkor a `$else` meghívásának eredményét vagy nullát adja vissza. +A `$predicate` aláírása `function ($value, int|string $key, array $array): bool`. + +Nem változtatja meg a belső mutatót, ellentétben a `end()`. A `$predicate` és `$else` paraméterek a 4.0.4-es verzió óta léteznek. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Lásd [first() |#first()]. + -Visszaadja a tömb utolsó elemét vagy nullát, ha a tömb üres. Nem változtatja meg a belső mutatót, ellentétben a `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Visszaadja az utolsó elem kulcsát (amely megfelel a megadott predikátumnak, ha meg van adva), vagy null, ha nincs ilyen elem. A `$predicate` aláírása `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Lásd [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -A `$callback` meghívja a tömb összes elemét, és visszaadja a visszatérési értékek tömbjét. A visszahívás aláírása `function ($value, $key, array $array): bool`. +A `$transformer` meghívja a tömb összes elemét, és visszaadja a visszatérési értékek tömbjét. A visszahívás aláírása `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // nullát ad vissza ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Megvizsgálja, hogy a tömb legalább egy eleme átmegy-e a `function ($value, $key, array $array): bool` aláírással ellátott callback által végrehajtott teszten. diff --git a/utils/hu/images.texy b/utils/hu/images.texy index 7c8be60c3b..b1c513f87e 100644 --- a/utils/hu/images.texy +++ b/utils/hu/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Megállapítja, hogy az adott [képtípus |#Formats] támogatott-e. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Visszaadja a támogatott képtípusok tömbjét (konstansok `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Kiszámítja a megadott betűtípusú és méretű szöveget körülvevő téglalap méreteit. Egy asszociatív tömböt ad vissza, amely a `left`, `top`, `width`, `height` kulcsokat tartalmazza. A bal oldali margó negatív lehet, ha a szöveg bal oldali túlnyúlással kezdődik. diff --git a/utils/hu/iterables.texy b/utils/hu/iterables.texy new file mode 100644 index 0000000000..8abc933d62 --- /dev/null +++ b/utils/hu/iterables.texy @@ -0,0 +1,119 @@ +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]. + + +Telepítés: + +```shell +composer require nette/utils +``` + +Minden példa feltételezi egy alias létrehozását: + +```php +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 (`===`). + +```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] +------------------------------------------------------- + +Az iterátorban lévő kulcs jelenlétét vizsgálja. Szigorú összehasonlítást használ (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Lásd [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Lásd [every() |#every()]. diff --git a/utils/it/@home.texy b/utils/it/@home.texy index a3bf3fc8fe..f1d7290a66 100644 --- a/utils/it/@home.texy +++ b/utils/it/@home.texy @@ -13,6 +13,7 @@ Il pacchetto `nette/utils` contiene un insieme di classi utili per l'uso quotidi | [Helpers |helpers] | Nette\Utils\Helpers | [Elementi HTML |HTML Elements] | Nette\Utils\Html | [Immagini |Images] | Nette\Utils\Image +| [Iterabili |iterables] | Nette\Utils\Iterables | [JSON |JSON] | Nette\Utils\Json | [Paginatore |paginator] | Nette\Utils\Paginatore | [Riflessione PHP |reflection] | Nette\Utils\Reflection diff --git a/utils/it/@left-menu.texy b/utils/it/@left-menu.texy index 0e8f491439..d7407854fc 100644 --- a/utils/it/@left-menu.texy +++ b/utils/it/@left-menu.texy @@ -8,6 +8,7 @@ Pacchetto nette/utils - [Aiutanti |helpers] - [Elementi HTML |HTML Elements] - [Immagini |Images] +- [Iterabili |iterables] - [JSON |JSON] - [Paginatore |paginator] - [Stringhe casuali |random] diff --git a/utils/it/arrays.texy b/utils/it/arrays.texy index 55a5397fa5..cf43f008ad 100644 --- a/utils/it/arrays.texy +++ b/utils/it/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Array .[#toc-arrays] ==================== -[api:Nette\Utils\Arrays] è una classe statica che contiene una serie di pratiche funzioni per gli array. +[api:Nette\Utils\Arrays] è una classe statica che contiene una manciata di pratiche funzioni per gli array. Il suo equivalente per gli iteratori è [Nette\Utils\Iterables |iterables]. Gli esempi seguenti presuppongono che sia definito il seguente alias di classe: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Verifica se tutti gli elementi dell'array superano il test implementato dalla funzione fornita, che ha la firma `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Vedere [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Restituisce un nuovo array contenente tutte le coppie chiave-valore corrispondenti al dato `$predicate`. Il callback ha la firma `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Restituisce il primo elemento (che corrisponde al predicato specificato, se dato). Se non esiste un elemento, restituisce il risultato dell'invocazione di `$else` o null. + `$predicate` ha la firma `function ($value, int|string $key, array $array): bool`. + +Non modifica il puntatore interno, a differenza di `reset()`. I parametri `$predicate` e `$else` esistono dalla versione 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Restituisce il primo elemento dell'array o null se l'array è vuoto. Non modifica il puntatore interno, a differenza di `reset()`. +Vedere [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Restituisce la chiave del primo elemento (che corrisponde al predicato specificato, se dato) o null se non esiste un elemento. `$predicate` ha la firma `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Vedere [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Restituisce l'ultimo elemento (che corrisponde al predicato specificato, se dato). Se non esiste un elemento, restituisce il risultato dell'invocazione di `$else` o null. + `$predicate` ha la firma `function ($value, int|string $key, array $array): bool`. + +Non modifica il puntatore interno, a differenza di `end()`. I parametri `$predicate` e `$else` esistono dalla versione 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Vedere [prima() |#first()]. + -Restituisce l'ultimo elemento dell'array o null se l'array è vuoto. Non modifica il puntatore interno, a differenza di `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Restituisce la chiave dell'ultimo elemento (che corrisponde al predicato specificato, se dato) o null se non esiste un elemento. `$predicate` ha la firma `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Vedere [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Richiama `$callback` su tutti gli elementi dell'array e restituisce l'array dei valori di ritorno. Il callback ha la firma `function ($value, $key, array $array): bool`. +Richiama `$transformer` su tutti gli elementi dell'array e restituisce l'array dei valori di ritorno. Il callback ha la firma `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // restituisce null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Verifica se almeno un elemento dell'array supera il test implementato dal callback fornito con la firma `function ($value, $key, array $array): bool`. diff --git a/utils/it/images.texy b/utils/it/images.texy index 6db8f308cb..9e5065b80c 100644 --- a/utils/it/images.texy +++ b/utils/it/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Determina se il [tipo di |#Formats] immagine dato è supportato. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Restituisce un array di tipi di immagine supportati (costanti `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Calcola le dimensioni del rettangolo che racchiude il testo in un font e in una dimensione specificati. Restituisce un array associativo contenente le chiavi `left`, `top`, `width`, `height`. Il margine sinistro può essere negativo se il testo inizia con una sporgenza a sinistra. diff --git a/utils/it/iterables.texy b/utils/it/iterables.texy new file mode 100644 index 0000000000..c0b5462503 --- /dev/null +++ b/utils/it/iterables.texy @@ -0,0 +1,119 @@ +Funzioni di iteratore +********************* + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] è una classe statica con funzioni per lavorare con gli iteratori. La sua controparte per gli array è [NetteUtilsArrays |arrays]. + + +Installazione: + +```shell +composer require nette/utils +``` + +Tutti gli esempi presuppongono la creazione di un alias: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Verifica la presenza di un valore nell'iteratore. Utilizza un confronto rigoroso (`===`). + +```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] +------------------------------------------------------- + +Verifica la presenza di una chiave nell'iteratore. Utilizza un confronto rigoroso (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Vedere [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iteratore che trasforma i valori richiamando `$transformer`. Ha la firma `function ($value, $key, iterable $iterable): bool`. Mantiene le chiavi originali. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Vedere [every() |#every()]. diff --git a/utils/pl/@home.texy b/utils/pl/@home.texy index 4ae656e9ad..a62dd5dc22 100644 --- a/utils/pl/@home.texy +++ b/utils/pl/@home.texy @@ -13,6 +13,7 @@ W pakiecie `nette/utils` znajdziesz zestaw przydatnych klas do codziennego użyt | [Obrazki |images] | Nette\Utils\Image | [Odbicie w PHP |reflection] | Nette\Utils\Reflection | [typy PHP |type] Nette\Utils\Type +| [Iterables |iterables] | Nette\Utils\Iterables | [Arrays |arrays] | Nette\Utils\Arrays | [Helper Functions |helpers] | Nette\Utils\Helpers | [Porównywanie pływaków |floats] | Nette\Utils\Floats diff --git a/utils/pl/@left-menu.texy b/utils/pl/@left-menu.texy index e9c10fbdf0..2cd09d7774 100644 --- a/utils/pl/@left-menu.texy +++ b/utils/pl/@left-menu.texy @@ -8,6 +8,7 @@ Pakiet Nette/utils - [JSON |JSON] - [Losowe ciągi |random] - [Obrazy |images] +- [Iterables |iterables] - [Paginator |paginator] - [Refleksja w PHP |reflection] - [Rodzaje PHP |type] diff --git a/utils/pl/arrays.texy b/utils/pl/arrays.texy index 2ca6c6d02d..23f50f2380 100644 --- a/utils/pl/arrays.texy +++ b/utils/pl/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Tablice .[#toc-arrays] ====================== -[api:Nette\Utils\Arrays] jest klasą statyczną zawierającą przydatne funkcje do pracy z tablicami. +[api:Nette\Utils\Arrays] to statyczna klasa, która zawiera kilka przydatnych funkcji tablicowych. Jej odpowiednikiem dla iteratorów jest [Nette\Utils\Iterables |iterables]. Poniższe przykłady zakładają, że alias został utworzony: @@ -76,10 +76,10 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- -Testuje czy wszystkie elementy w tablicy przechodzą test zaimplementowany w `$callback` z podpisem `function ($value, $key, array $array): bool`. +Testuje czy wszystkie elementy w tablicy przechodzą test zaimplementowany w `$predicate` z podpisem `function ($value, $key, array $array): bool`. ```php $array = [1, 30, 39, 29, 10, 13]; @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Zobacz [some() |#some]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Zwraca nową tablicę zawierającą wszystkie pary klucz-wartość pasujące do podanego `$predicate`. Wywołanie zwrotne ma sygnaturę `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Zwraca pierwszy element (pasujący do określonego predykatu, jeśli został podany). Jeśli nie ma takiego elementu, zwraca wynik wywołania `$else` lub null. +Funkcja `$predicate` ma sygnaturę `function ($value, int|string $key, array $array): bool`. + +W przeciwieństwie do `reset()` nie zmienia wewnętrznego wskaźnika. Parametry `$predicate` i `$else` istnieją od wersji 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Zwraca pierwszy wpis z tablicy lub null jeśli tablica jest pusta. Nie zmienia wewnętrznego wskaźnika w przeciwieństwie do `reset()`. +Zobacz [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Zwraca klucz pierwszego elementu (pasującego do określonego predykatu, jeśli został podany) lub null, jeśli nie ma takiego elementu. Funkcja `$predicate` ma sygnaturę `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Zobacz [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Zwraca ostatni element (pasujący do określonego predykatu, jeśli został podany). Jeśli nie ma takiego elementu, zwraca wynik wywołania `$else` lub null. +Funkcja `$predicate` ma sygnaturę `function ($value, int|string $key, array $array): bool`. + +W przeciwieństwie do `end()` nie zmienia wewnętrznego wskaźnika. Parametry `$predicate` i `$else` istnieją od wersji 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Zobacz [first() |#first()]. + -Zwraca ostatni wpis tablicy lub null jeśli tablica jest pusta. Nie zmienia wewnętrznego wskaźnika w przeciwieństwie do `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Zwraca klucz ostatniego elementu (pasującego do określonego predykatu, jeśli został podany) lub null, jeśli nie ma takiego elementu. Funkcja `$predicate` ma sygnaturę `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Zobacz [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Wywołuje `$callback` na wszystkich elementach tablicy i zwraca tablicę wartości zwrotnych. Callback ma podpis `function ($value, $key, array $array): bool`. +Wywołuje `$transformer` na wszystkich elementach tablicy i zwraca tablicę wartości zwrotnych. Callback ma podpis `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,10 +383,10 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // vrátí null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- -Testuje czy przynajmniej jeden element w tablicy przechodzi test zaimplementowany w `$callback` z podpisem `function ($value, $key, array $array): bool`. +Testuje czy przynajmniej jeden element w tablicy przechodzi test zaimplementowany w `$predicate` z podpisem `function ($value, $key, array $array): bool`. ```php $array = [1, 2, 3, 4]; diff --git a/utils/pl/images.texy b/utils/pl/images.texy index c21623a869..077a3e652e 100644 --- a/utils/pl/images.texy +++ b/utils/pl/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Określa, czy dany [typ |#Formats] obrazu jest obsługiwany. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Zwraca tablicę obsługiwanych typów obrazów (stałe `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Oblicza wymiary prostokąta otaczającego tekst o określonej czcionce i rozmiarze. Zwraca tablicę asocjacyjną zawierającą klucze `left`, `top`, `width`, `height`. Lewy margines może być ujemny, jeśli tekst zaczyna się od lewego nawisu. diff --git a/utils/pl/iterables.texy b/utils/pl/iterables.texy new file mode 100644 index 0000000000..6b9b3718ff --- /dev/null +++ b/utils/pl/iterables.texy @@ -0,0 +1,119 @@ +Funkcje iteratora +***************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] to statyczna klasa z funkcjami do pracy z iteratorami. Jej odpowiednikiem dla tablic jest [Nette\Utils\Arrays |arrays]. + + +Instalacja: + +```shell +composer require nette/utils +``` + +Wszystkie przykłady zakładają utworzenie aliasu: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Sprawdza obecność wartości w iteratorze. Używa ścisłego porównania (`===`). + +```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] +------------------------------------------------------- + +Sprawdza obecność klucza w iteratorze. Używa ścisłego porównania (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Zobacz [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iterator, który przekształca wartości poprzez wywołanie `$transformer`. Ma sygnaturę `function ($value, $key, iterable $iterable): bool`. Zachowuje oryginalne klucze. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Zobacz [every() |#every()]. diff --git a/utils/pt/@home.texy b/utils/pt/@home.texy index 46bff91082..984915289e 100644 --- a/utils/pt/@home.texy +++ b/utils/pt/@home.texy @@ -13,6 +13,7 @@ No pacote `nette/utils` você encontrará um conjunto de aulas úteis para o uso | [Ajudantes |helpers] | Nette\Utils\Helpers | [Elementos HTML |HTML Elements] | Nette\Utils\Html | [Imagens |Images] | Nette\Utils\Image +| [Iterables |iterables] | Nette\Utils\Iterables | [JSON |JSON] | Nette\Utils\Json | [Paginador de Paginadores |paginator] | Nette\Utils\Paginator | [Reflexão PHP Ref |reflection] | Nette\Utils\Reflection diff --git a/utils/pt/@left-menu.texy b/utils/pt/@left-menu.texy index 83178cea74..041f24a015 100644 --- a/utils/pt/@left-menu.texy +++ b/utils/pt/@left-menu.texy @@ -8,6 +8,7 @@ Pacote nette/utils - [Ajudantes |helpers] - [Elementos HTML |HTML Elements] - [Imagens |Images] +- [Iteráveis |iterables] - [JSON |JSON] - [Paginador |paginator] - [Cordas Aleatórias |random] diff --git a/utils/pt/arrays.texy b/utils/pt/arrays.texy index 2b08aa82f7..142ccc6ee3 100644 --- a/utils/pt/arrays.texy +++ b/utils/pt/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Arrays .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] é uma classe estática, que contém um punhado de funções de matriz úteis. +[api:Nette\Utils\Arrays] é uma classe estática que contém um punhado de funções úteis de matriz. Seu equivalente para iteradores é [Nette\Utils\Iterables |iterables]. Os exemplos a seguir assumem que a seguinte classe está definida: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Testa se todos os elementos da matriz passam no teste implementado pela função fornecida, que tem a assinatura `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Veja [algumas() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Retorna uma nova matriz contendo todos os pares de valores-chave que correspondem ao endereço `$predicate` fornecido. O retorno de chamada tem a assinatura `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Retorna o primeiro item (que corresponde ao predicado especificado, se fornecido). Se não houver tal item, ele retorna o resultado da invocação de `$else` ou nulo. +O `$predicate` tem a assinatura `function ($value, int|string $key, array $array): bool`. + +Ele não altera o ponteiro interno, ao contrário de `reset()`. Os parâmetros `$predicate` e `$else` existem desde a versão 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Devolve o primeiro item da matriz ou nulo se a matriz estiver vazia. Ele não muda o ponteiro interno ao contrário de `reset()`. +Consulte [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Retorna a chave do primeiro item (que corresponde ao predicado especificado, se fornecido) ou nula se não houver tal item. O `$predicate` tem a assinatura `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Consulte [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Retorna o último item (que corresponde ao predicado especificado, se fornecido). Se não houver tal item, ele retorna o resultado da invocação de `$else` ou nulo. +O `$predicate` tem a assinatura `function ($value, int|string $key, array $array): bool`. + +Ele não altera o ponteiro interno, ao contrário de `end()`. Os parâmetros `$predicate` e `$else` existem desde a versão 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Consulte [first() |#first()]. + -Devolve o último item da matriz ou nulo se a matriz estiver vazia. Ele não muda o ponteiro interno ao contrário de `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Retorna a chave do último item (que corresponde ao predicado especificado, se fornecido) ou nula se não houver tal item. O `$predicate` tem a assinatura `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Consulte [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Liga para `$callback` sobre todos os elementos da matriz e retorna a matriz de valores de retorno. A chamada de retorno tem a assinatura `function ($value, $key, array $array): bool`. +Liga para `$transformer` sobre todos os elementos da matriz e retorna a matriz de valores de retorno. A chamada de retorno tem a assinatura `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returns null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Testa se pelo menos um elemento da matriz passa no teste implementado pela callback fornecida com a assinatura `function ($value, $key, array $array): bool`. diff --git a/utils/pt/images.texy b/utils/pt/images.texy index 20a1f45b09..a15b4ccf43 100644 --- a/utils/pt/images.texy +++ b/utils/pt/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Determina se o [tipo |#Formats] de imagem fornecido é compatível. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Retorna uma matriz de tipos de imagens compatíveis (constantes `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Calcula as dimensões do retângulo que envolve o texto em uma fonte e tamanho especificados. Retorna uma matriz associativa contendo as chaves `left`, `top`, `width`, `height`. A margem esquerda pode ser negativa se o texto começar com uma saliência à esquerda. diff --git a/utils/pt/iterables.texy b/utils/pt/iterables.texy new file mode 100644 index 0000000000..30bea5ca1f --- /dev/null +++ b/utils/pt/iterables.texy @@ -0,0 +1,119 @@ +Funções de iterador +******************* + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] é uma classe estática com funções para trabalhar com iteradores. Sua contraparte para matrizes é [Nette\Utils\Arrays |arrays]. + + +Instalação: + +```shell +composer require nette/utils +``` + +Todos os exemplos pressupõem a criação de um alias: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Testa a presença de um valor no iterador. Usa comparação rigorosa (`===`). + +```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] +------------------------------------------------------- + +Testa a presença de uma chave no iterador. Usa comparação rigorosa (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Consulte [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iterador que transforma valores chamando `$transformer`. Ele tem a assinatura `function ($value, $key, iterable $iterable): bool`. Mantém as chaves originais. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Consulte [every() |#every()]. diff --git a/utils/ro/@home.texy b/utils/ro/@home.texy index c4beaa362e..98e5316be5 100644 --- a/utils/ro/@home.texy +++ b/utils/ro/@home.texy @@ -13,6 +13,7 @@ Utilități [Ajutoare |helpers] | Helpers | Nette\Utils\Helpers | [Elemente HTML |HTML Elements] | Nette\Utils\Html [Imagini |Images] | Imagini | Nette\Utils\Image +[Iterables |iterables] | Iterables | Nette\Utils\Iterables [JSON |JSON] | JSON | Nette\Utils\Json | [Paginator |paginator] | Nette\Utils\Paginator [PHP Reflection |reflection] | [PHP |reflection] Reflection | Nette\Utils\Reflection diff --git a/utils/ro/@left-menu.texy b/utils/ro/@left-menu.texy index 8b2e3fc881..5218142956 100644 --- a/utils/ro/@left-menu.texy +++ b/utils/ro/@left-menu.texy @@ -8,6 +8,7 @@ Pachetul nette/utils - [Ajutători |helpers] - [Elemente HTML |HTML Elements] - [Imagini |Images] +- [Iterabile |iterables] - [JSON |JSON] - [Paginator |paginator] - [Șiruri aleatorii |random] diff --git a/utils/ro/arrays.texy b/utils/ro/arrays.texy index 82d9789065..82a2e3770e 100644 --- a/utils/ro/arrays.texy +++ b/utils/ro/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Array-uri .[#toc-arrays] ======================== -[api:Nette\Utils\Arrays] este o clasă statică, care conține o serie de funcții practice de matrice. +[api:Nette\Utils\Arrays] este o clasă statică, care conține o serie de funcții practice de matrice. Echivalentul său pentru iteratori este [Nette\Utils\Iterables |iterables]. Exemplele următoare presupun că este definit următorul alias de clasă: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Testează dacă toate elementele din matrice trec testul implementat de funcția furnizată, care are semnătura `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true A se vedea [some() |#some()]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Returnează o nouă matrice care conține toate perechile cheie-valoare care corespund cu `$predicate`. Callback-ul are semnătura `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Returnează primul element (care corespunde predicatului specificat, dacă este dat). Dacă nu există un astfel de element, se returnează rezultatul invocării `$else` sau null. + `$predicate` are semnătura `function ($value, int|string $key, array $array): bool`. + +Nu modifică pointerul intern, spre deosebire de `reset()`. Parametrii `$predicate` și `$else` există începând cu versiunea 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Returnează primul element din tablou sau nul dacă tabloul este gol. Nu modifică pointerul intern, spre deosebire de `reset()`. +A se vedea [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Returnează cheia primului element (care corespunde predicatului specificat, dacă este dat) sau nulă dacă nu există un astfel de element. `$predicate` are semnătura `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +A se vedea [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Returnează ultimul element (care corespunde predicatului specificat, dacă este dat). Dacă nu există un astfel de element, se returnează rezultatul invocării `$else` sau null. + `$predicate` are semnătura `function ($value, int|string $key, array $array): bool`. + +Nu modifică pointerul intern, spre deosebire de `end()`. Parametrii `$predicate` și `$else` există începând cu versiunea 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +A se vedea [first() |#first()]. + -Returnează ultimul element din tablou sau zero dacă tabloul este gol. Spre deosebire de `end()`, nu modifică pointerul intern. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Returnează cheia ultimului element (care corespunde predicatului specificat, dacă este dat) sau nulă dacă nu există un astfel de element. `$predicate` are semnătura `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +A se vedea [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Solicită `$callback` pentru toate elementele din matrice și returnează matricea de valori de returnare. Callback-ul are semnătura `function ($value, $key, array $array): bool`. +Solicită `$transformer` pentru toate elementele din matrice și returnează matricea de valori de returnare. Callback-ul are semnătura `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returnează null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Testează dacă cel puțin un element din matrice trece testul implementat de callback-ul furnizat cu semnătura `function ($value, $key, array $array): bool`. diff --git a/utils/ro/images.texy b/utils/ro/images.texy index 0444c318a0..ba0a16083d 100644 --- a/utils/ro/images.texy +++ b/utils/ro/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Determină dacă [tipul de |#Formats] imagine dat este acceptat. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Returnează o matrice de tipuri de imagini acceptate (constante `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Calculează dimensiunile dreptunghiului care înconjoară textul cu un font și o dimensiune specificate. Se returnează un tablou asociativ care conține cheile `left`, `top`, `width`, `height`. Marja stângă poate fi negativă dacă textul începe cu o depășire la stânga. diff --git a/utils/ro/iterables.texy b/utils/ro/iterables.texy new file mode 100644 index 0000000000..413b1f6ec2 --- /dev/null +++ b/utils/ro/iterables.texy @@ -0,0 +1,119 @@ +Funcții de 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]. + + +Instalare: + +```shell +composer require nette/utils +``` + +Toate exemplele presupun crearea unui alias: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Testează prezența unei valori în iterator. Utilizează o comparație strictă (`===`). + +```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] +------------------------------------------------------- + +Testează prezența unei chei în iterator. Utilizează o comparație strictă (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +A se vedea [some() |#some()]. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iterator care transformă valorile prin apelarea `$transformer`. Are semnătura `function ($value, $key, iterable $iterable): bool`. Păstrează cheile originale. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +A se vedea [every() |#every()]. diff --git a/utils/ru/@home.texy b/utils/ru/@home.texy index 9a92b30218..c3f516b34f 100644 --- a/utils/ru/@home.texy +++ b/utils/ru/@home.texy @@ -13,6 +13,7 @@ | [Изображения |images] | Nette\Utils\Image | [Пагинация |paginator] | Nette\Utils\Paginator | [Парсинг и генерация JSON |json] | Nette\Utils\Json +| [Iterables |iterables] | Nette\Utils\Iterables | [Поле |arrays] | Nette\Utils\Arrays | [Строки |strings] | Nette\Utils\Strings | [Типы |type] | Nette\Utils\Type diff --git a/utils/ru/@left-menu.texy b/utils/ru/@left-menu.texy index 94fce6f58f..62c1662dd5 100644 --- a/utils/ru/@left-menu.texy +++ b/utils/ru/@left-menu.texy @@ -8,6 +8,7 @@ - [Изображения |images] - [Обратные вызовы |callback] - [Пагинатор |paginator] +- [Итерабельные таблицы |iterables] - [Поле |arrays] - [Случайные строки |random] - [Строки |strings] diff --git a/utils/ru/arrays.texy b/utils/ru/arrays.texy index ba4e191f21..33326625d0 100644 --- a/utils/ru/arrays.texy +++ b/utils/ru/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Массивы .[#toc-arrays] ====================== -[api:Nette\Utils\Arrays] это статический класс, содержащий полезные функции для работы с массивами. +[api:Nette\Utils\Arrays] это статический класс, который содержит несколько удобных функций для работы с массивами. Его эквивалентом для итераторов является [Nette\Utils\Iterables |iterables]. В следующих примерах предполагается, что псевдоним уже создан: @@ -76,10 +76,10 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- -Проверяет, все ли элементы в массиве проходят тест, реализованный в `$callback` с сигнатурой `function ($value, $key, array $array): bool`. +Проверяет, все ли элементы в массиве проходят тест, реализованный в `$predicate` с сигнатурой `function ($value, $key, array $array): bool`. ```php $array = [1, 30, 39, 29, 10, 13]; @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true См. [some() |#some]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Возвращает новый массив, содержащий все пары ключ-значение, соответствующие заданному `$predicate`. Обратный вызов имеет сигнатуру `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Возвращает первый элемент (соответствующий указанному предикату, если он задан). Если такого элемента нет, возвращается результат вызова `$else` или null. +Функция `$predicate` имеет сигнатуру `function ($value, int|string $key, array $array): bool`. + +Она не изменяет внутренний указатель, в отличие от `reset()`. Параметры `$predicate` и `$else` существуют с версии 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Возвращает первую запись из массива или null, если массив пуст. Не изменяет внутренний указатель, в отличие от `reset()`. +См. [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Возвращает ключ первого элемента (соответствующего указанному предикату, если он задан) или null, если такого элемента нет. Ключ `$predicate` имеет сигнатуру `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +См. [lastKey() |#lastKey()]. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Возвращает последний элемент (соответствующий указанному предикату, если он задан). Если такого элемента нет, возвращается результат вызова `$else` или null. +Функция `$predicate` имеет сигнатуру `function ($value, int|string $key, array $array): bool`. + +Она не изменяет внутренний указатель, в отличие от `end()`. Параметры `$predicate` и `$else` существуют с версии 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +См. раздел [first() |#first()]. + -Возвращает последнюю запись массива или null, если массив пуст. Не изменяет внутренний указатель, в отличие от `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Возвращает ключ последнего элемента (соответствующего указанному предикату, если он задан) или null, если такого элемента нет. Ключ `$predicate` имеет сигнатуру `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +См. [firstKey() |#firstKey()]. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Вызывает `$callback` на всех элементах массива и возвращает массив возвращаемых значений. Обратный вызов имеет сигнатуру `function ($value, $key, array $array): bool`. +Вызывает `$transformer` на всех элементах массива и возвращает массив возвращаемых значений. Обратный вызов имеет сигнатуру `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,10 +383,10 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // vrátí null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- -Проверяет, проходит ли хотя бы один элемент в массиве тест, реализованный в `$callback` с сигнатурой `function ($value, $key, array $array): bool`. +Проверяет, проходит ли хотя бы один элемент в массиве тест, реализованный в `$predicate` с сигнатурой `function ($value, $key, array $array): bool`. ```php $array = [1, 2, 3, 4]; diff --git a/utils/ru/images.texy b/utils/ru/images.texy index e73a3dc303..7a9fe77e4f 100644 --- a/utils/ru/images.texy +++ b/utils/ru/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Определяет, поддерживается ли заданный [тип |#Formats] изображения. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Возвращает массив поддерживаемых типов изображений (константы `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Вычисляет размеры прямоугольника, в который заключен текст заданного шрифта и размера. Возвращается ассоциативный массив, содержащий ключи `left`, `top`, `width`, `height`. Левое поле может быть отрицательным, если текст начинается с левого свеса. diff --git a/utils/ru/iterables.texy b/utils/ru/iterables.texy new file mode 100644 index 0000000000..6330be8877 --- /dev/null +++ b/utils/ru/iterables.texy @@ -0,0 +1,119 @@ +Функции итератора +***************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] это статический класс с функциями для работы с итераторами. Его аналог для массивов - [Nette\Utils\Arrays |arrays]. + + +Установка: + +```shell +composer require nette/utils +``` + +Все примеры предполагают создание псевдонима: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Проверяет наличие значения в итераторе. Используется строгое сравнение (`===`). + +```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] +------------------------------------------------------- + +Проверяет наличие ключа в итераторе. Используется строгое сравнение (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false +``` + + +every(iterable $iterable, callable $predicate): bool .[method] +-------------------------------------------------------------- + +Проверяет, все ли элементы итератора проходят тест, реализованный в `$predicate` с сигнатурой `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 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`. Сохраняет исходные ключи. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Итератор, преобразующий значения путем вызова `$transformer`. Имеет сигнатуру `function ($value, $key, iterable $iterable): bool`. Сохраняет исходные ключи. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +some(iterable $iterable, callable $predicate): bool .[method] +------------------------------------------------------------- + +Проверяет, проходит ли хотя бы один элемент итератора тест, реализованный в `$predicate` с подписью `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +См. [every() |#every()]. diff --git a/utils/sl/@home.texy b/utils/sl/@home.texy index b04f690d17..8e5c925487 100644 --- a/utils/sl/@home.texy +++ b/utils/sl/@home.texy @@ -13,6 +13,7 @@ V paketu `nette/utils` boste našli niz uporabnih razredov za vsakdanjo uporabo: | [Pomočniki |helpers] | Nette\Utils\Helpers | [Elementi HTML |HTML Elements] | Nette\Utils\Html | [Slike |Images] | Nette\Utils\Image +| [Iterables |iterables] | Nette\Utils\Iterables | [JSON |JSON] | Nette\Utils\Json | [Paginator |paginator] | Nette\Utils\Paginator | [PHP Reflection |reflection] | Nette\Utils\Reflection diff --git a/utils/sl/@left-menu.texy b/utils/sl/@left-menu.texy index e9d66c191d..dbd800f038 100644 --- a/utils/sl/@left-menu.texy +++ b/utils/sl/@left-menu.texy @@ -8,6 +8,7 @@ Paket nette/utils - [Pomočniki |helpers] - [Elementi HTML |HTML Elements] - [Slike |Images] +- [Iterables |iterables] - [JSON |JSON] - [Paginator |paginator] - [Naključni nizi |random] diff --git a/utils/sl/arrays.texy b/utils/sl/arrays.texy index 7f042b7ea8..362c4163ac 100644 --- a/utils/sl/arrays.texy +++ b/utils/sl/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Mreže .[#toc-arrays] ==================== -[api:Nette\Utils\Arrays] je statični razred, ki vsebuje nekaj priročnih funkcij za polja. +[api:Nette\Utils\Arrays] je statični razred, ki vsebuje nekaj priročnih funkcij za polja. Njegov ekvivalent za iteratorje je [Nette\Utils\Iterables |iterables]. Naslednji primeri predpostavljajo, da je definiran naslednji vzdevek razreda: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Preizkusi, ali vsi elementi v polju prestanejo test, ki ga izvaja navedena funkcija s podpisom `function ($value, $key, array $array): bool`. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Glejte [some( |#some()]). -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Vrne novo polje, ki vsebuje vse pare ključ-vrednost, ki ustrezajo danemu `$predicate`. Povratni klic ima podpis `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Vrne prvi element (ki ustreza določenemu predikatu, če je podan). Če takega elementa ni, vrne rezultat klica `$else` ali nič. + `$predicate` ima podpis `function ($value, int|string $key, array $array): bool`. + +Za razliko od `reset()` ne spreminja notranjega kazalca. Parametra `$predicate` in `$else` obstajata od različice 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Vrne prvi element iz polja ali nič, če je polje prazno. Za razliko od `reset()` ne spremeni notranjega kazalca. +Glej [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Vrne ključ prvega elementa (ki ustreza določenemu predikatu, če je podan) ali nič, če takega elementa ni. `$predicate` ima podpis `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Glej [lastKey( |#lastKey()]). + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Vrne zadnji element (ki ustreza določenemu predikatu, če je podan). Če takega elementa ni, vrne rezultat klica `$else` ali nič. + `$predicate` ima podpis `function ($value, int|string $key, array $array): bool`. + +Za razliko od `end()` ne spreminja notranjega kazalca. Parametra `$predicate` in `$else` obstajata od različice 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Glej [first( |#first()]). + -Vrne zadnji element iz polja ali nič, če je polje prazno. Za razliko od `end()` ne spremeni notranjega kazalca. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Vrne ključ zadnjega elementa (ki ustreza določenemu predikatu, če je podan) ali nič, če takega elementa ni. `$predicate` ima podpis `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Glej [firstKey( |#firstKey()]). + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Kliče `$callback` na vse elemente v polju in vrne polje vrnjenih vrednosti. Povratni klic ima podpis `function ($value, $key, array $array): bool`. +Kliče `$transformer` na vse elemente v polju in vrne polje vrnjenih vrednosti. Povratni klic ima podpis `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // vrne nič ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Preizkusi, ali vsaj en element v polju prestane test, ki ga izvaja posredovani povratni klic s podpisom `function ($value, $key, array $array): bool`. diff --git a/utils/sl/images.texy b/utils/sl/images.texy index 3af7d1c59d..90f1f83819 100644 --- a/utils/sl/images.texy +++ b/utils/sl/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Ugotovi, ali je dana [vrsta |#Formats] slike podprta. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Vrne polje podprtih tipov slik (konstante `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Izračuna dimenzije pravokotnika, ki obkroža besedilo v določeni pisavi in velikosti. Vrne asociativno polje, ki vsebuje ključe `left`, `top`, `width`, `height`. Levi rob je lahko negativen, če se besedilo začne z levim previsom. diff --git a/utils/sl/iterables.texy b/utils/sl/iterables.texy new file mode 100644 index 0000000000..5bcaa78a32 --- /dev/null +++ b/utils/sl/iterables.texy @@ -0,0 +1,119 @@ +Funkcije iteratorja +******************* + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] je statični razred s funkcijami za delo z iteratorji. Njegova ustreznica za polja je [Nette\Utils\Arrays |arrays]. + + +Namestitev: + +```shell +composer require nette/utils +``` + +Vsi primeri predvidevajo vzpostavitev vzdevka: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Preizkusi prisotnost vrednosti v iteratorju. Uporablja strogo primerjavo (`===`). + +```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] +------------------------------------------------------- + +Preizkusi prisotnost ključa v iteratorju. Uporablja strogo primerjavo (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + +Glej [some( |#some()]). + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Iterator, ki preoblikuje vrednosti s klicem `$transformer`. Ima podpis `function ($value, $key, iterable $iterable): bool`. Ohrani prvotne ključe. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Glej [every( |#every()]). diff --git a/utils/tr/@home.texy b/utils/tr/@home.texy index 5fb8feb8e2..9190e91cd9 100644 --- a/utils/tr/@home.texy +++ b/utils/tr/@home.texy @@ -13,6 +13,7 @@ Yardımcı Programlar | [Yardımcılar |helpers] | Nette\Utils\Helpers | [HTML Elemanları |HTML Elements] | Nette\Utils\Html | [Görüntüler |Images] | Nette\Utils\Image +| [Iterables |iterables] | Nette\Utils\Iterables | [JSON |JSON] | Nette\Utils\Json | [Paginator |paginator] | Nette\Utils\Paginator | [PHP |reflection] Yansıması | Nette\Utils\Reflection diff --git a/utils/tr/@left-menu.texy b/utils/tr/@left-menu.texy index a0a5bb879b..5874ca28a6 100644 --- a/utils/tr/@left-menu.texy +++ b/utils/tr/@left-menu.texy @@ -8,6 +8,7 @@ Paket nette/utils - [Yardımcılar |helpers] - [HTML Öğeleri |HTML Elements] - [Görüntüler |Images] +- [Iterables |iterables] - [JSON |JSON] - [Paginator |paginator] - [Rastgele Dizeler |random] diff --git a/utils/tr/arrays.texy b/utils/tr/arrays.texy index 42130c7358..a7e8b892b7 100644 --- a/utils/tr/arrays.texy +++ b/utils/tr/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Diziler .[#toc-arrays] ====================== -[api:Nette\Utils\Arrays] bir avuç kullanışlı dizi işlevi içeren statik bir sınıftır. +[api:Nette\Utils\Arrays] bir avuç kullanışlı dizi işlevi içeren statik bir sınıftır. Yineleyiciler için karşılığı [Nette\Utils\Iterables' |iterables]dır. Aşağıdaki örneklerde, aşağıdaki sınıf takma adının tanımlandığı varsayılmaktadır: @@ -76,8 +76,8 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- Dizideki tüm öğelerin, `function ($value, $key, array $array): bool` imzasına sahip olan sağlanan işlev tarafından uygulanan testi geçip geçmediğini sınar. @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true [some() |#some()] işlevine bakın. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Verilen `$predicate` ile eşleşen tüm anahtar-değer çiftlerini içeren yeni bir dizi döndürür. Geri arama `function ($value, int|string $key, array $array): bool` imzasına sahiptir. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +İlk öğeyi döndürür (verilmişse belirtilen yüklemle eşleşen). Böyle bir öğe yoksa, `$else` çağrısının sonucunu veya null döndürür. + `$predicate`, `function ($value, int|string $key, array $array): bool` imzasına sahiptir. + + `reset()` adresinden farklı olarak dahili işaretçiyi değiştirmez. `$predicate` ve `$else` parametreleri 4.0.4 sürümünden beri mevcuttur. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Dizideki ilk öğeyi veya dizi boşsa null döndürür. `reset()` adresinden farklı olarak dahili göstericiyi değiştirmez. +Bkz. [last() |#last()]. + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +İlk öğenin anahtarını (verilmişse belirtilen yüklemle eşleşen) veya böyle bir öğe yoksa null döndürür. `$predicate` , `function ($value, int|string $key, array $array): bool` imzasına sahiptir. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` + [lastKey() |#lastKey()] işlevine bakın. + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Son öğeyi döndürür (verilmişse belirtilen yüklemle eşleşen). Böyle bir öğe yoksa, `$else` çağrısının sonucunu veya null döndürür. + `$predicate`, `function ($value, int|string $key, array $array): bool` imzasına sahiptir. + + `end()` adresinden farklı olarak dahili işaretçiyi değiştirmez. `$predicate` ve `$else` parametreleri 4.0.4 sürümünden beri mevcuttur. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +[First() |#first()] işlevine bakın. + -Dizideki son öğeyi veya dizi boşsa null döndürür. `end()` adresinden farklı olarak dahili göstericiyi değiştirmez. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Son öğenin anahtarını (verilmişse belirtilen yüklemle eşleşen) veya böyle bir öğe yoksa null döndürür. `$predicate` , `function ($value, int|string $key, array $array): bool` imzasına sahiptir. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` + [firstKey() |#firstKey()] işlevine bakın. + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Dizideki tüm öğeler üzerinde `$callback` adresini çağırır ve dönüş değerleri dizisini döndürür. Geri arama `function ($value, $key, array $array): bool` imzasına sahiptir. +Dizideki tüm öğeler üzerinde `$transformer` adresini çağırır ve dönüş değerleri dizisini döndürür. Geri arama `function ($value, $key, array $array): bool` imzasına sahiptir. ```php $array = ['foo', 'bar', 'baz']; @@ -325,8 +383,8 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // returns null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- Dizideki en az bir öğenin `function ($value, $key, array $array): bool` imzasıyla sağlanan geri arama tarafından uygulanan testi geçip geçmediğini sınar. diff --git a/utils/tr/images.texy b/utils/tr/images.texy index fafc8c5deb..285a6bddbf 100644 --- a/utils/tr/images.texy +++ b/utils/tr/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Verilen görüntü [türünün |#Formats] desteklenip desteklenmediğini belirler. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Desteklenen görüntü türlerinin bir dizisini döndürür (sabitler `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Metni belirtilen yazı tipi ve boyutta çevreleyen dikdörtgenin boyutlarını hesaplar. `left` , `top`, `width`, `height` anahtarlarını içeren bir ilişkisel dizi döndürür. Metin sola doğru bir çıkıntıyla başlıyorsa, sol kenar boşluğu negatif olabilir. diff --git a/utils/tr/iterables.texy b/utils/tr/iterables.texy new file mode 100644 index 0000000000..9bb6750c49 --- /dev/null +++ b/utils/tr/iterables.texy @@ -0,0 +1,119 @@ +Yineleyici İşlevleri +******************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] yineleyicilerle çalışmak için işlevler içeren statik bir sınıftır. Diziler için karşılığı [Nette\Utils\Arrays' |arrays]dir. + + +Kurulum: + +```shell +composer require nette/utils +``` + +Tüm örneklerde bir takma ad oluşturulduğu varsayılmaktadır: + +```php +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 (`===`). + +```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] +------------------------------------------------------- + +Yineleyicide bir anahtarın varlığını test eder. Sıkı karşılaştırma kullanır (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +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. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isBelowThreshold = fn($value) => $value < 40; +$res = Iterables::every($iterator, $isBelowThreshold); // true +``` + + [some() |#some()] işlevine bakın. + + +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. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::filter($iterator, fn($v) => $v < 3); +// 1, 2 +``` + + +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. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +Iterables::first(new ArrayIterator([])); // null +Iterables::first(new ArrayIterator([]), else: fn() => false); // false +``` + + +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. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + + `$transformer` adresini çağırarak değerleri dönüştüren yineleyici. `function ($value, $key, iterable $iterable): bool` imzasına sahiptir. Orijinal anahtarları korur. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +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. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Bkz. [every() |#every()]. diff --git a/utils/uk/@home.texy b/utils/uk/@home.texy index d2e35c55b6..9fa4b85aba 100644 --- a/utils/uk/@home.texy +++ b/utils/uk/@home.texy @@ -13,6 +13,7 @@ | [Зображення |images] | Nette\Utils\Image | [Пагінація |paginator] | Nette\Utils\Paginator | [Парсинг і генерація JSON |json] | Nette\Utils\Json +| [Змінні |iterables] | Nette\Utils\Iterables | [Поле |arrays] | Nette\Utils\Arrays | [Рядки |strings] | Nette\Utils\Strings | [Типи |type] | Nette\Utils\Type diff --git a/utils/uk/@left-menu.texy b/utils/uk/@left-menu.texy index 69dc75a6e1..66d73a31c6 100644 --- a/utils/uk/@left-menu.texy +++ b/utils/uk/@left-menu.texy @@ -8,6 +8,7 @@ - [Зображення |images] - [Зворотні виклики |callback] - [Пагінатор |paginator] +- [Ітерабельні змінні |iterables] - [Поле |arrays] - [Випадкові рядки |random] - [Рядки |strings] diff --git a/utils/uk/arrays.texy b/utils/uk/arrays.texy index f47e1096a2..cd19d823e4 100644 --- a/utils/uk/arrays.texy +++ b/utils/uk/arrays.texy @@ -15,7 +15,7 @@ composer require nette/utils Масиви .[#toc-arrays] ===================== -[api:Nette\Utils\Arrays] це статичний клас, що містить корисні функції для роботи з масивами. +[api:Nette\Utils\Arrays] це статичний клас, який містить декілька зручних функцій для роботи з масивами. Його еквівалентом для ітераторів є [Nette\Utils\Iterables |iterables]. У наступних прикладах передбачається, що псевдонім уже створено: @@ -76,10 +76,10 @@ Arrays::contains(['1', false], 1); // false ``` -every(iterable $array, callable $callback): bool .[method] ----------------------------------------------------------- +every(array $array, callable $predicate): bool .[method] +-------------------------------------------------------- -Перевіряє, чи всі елементи в масиві проходять тест, реалізований у `$callback` з сигнатурою `function ($value, $key, array $array): bool`. +Перевіряє, чи всі елементи в масиві проходять тест, реалізований у `$predicate` з сигнатурою `function ($value, $key, array $array): bool`. ```php $array = [1, 30, 39, 29, 10, 13]; @@ -90,16 +90,52 @@ $res = Arrays::every($array, $isBelowThreshold); // true Див. [some() |#some]. -first(array $array): mixed .[method] ------------------------------------- +filter(array $array, callable $predicate): array .[method]{data-version:4.0.4} +------------------------------------------------------------------------------ + +Повертає новий масив, що містить всі пари ключ-значення, які відповідають заданому `$predicate`. Зворотний виклик має сигнатуру `function ($value, int|string $key, array $array): bool`. + +```php +Arrays::filter( + ['a' => 1, 'b' => 2, 'c' => 3], + fn($v) => $v < 3, +); +// ['a' => 1, 'b' => 2] +``` + + +first(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------- + +Повертає перший елемент (що відповідає вказаному предикату, якщо він заданий). Якщо такого елемента немає, повертається результат виклику `$else` або нуль. +Функція `$predicate` має підпис `function ($value, int|string $key, array $array): bool`. + +Він не змінює внутрішній вказівник, на відміну від `reset()`. Параметри `$predicate` та `$else` з'явилися починаючи з версії 4.0.4. + +```php +Arrays::first([1, 2, 3]); // 1 +Arrays::first([1, 2, 3], fn($v) => $v > 2); // 3 +Arrays::first([]); // null +Arrays::first([], else: fn() => false); // false +``` -Повертає перший запис із масиву або null, якщо масив порожній. Не змінює внутрішній покажчик, на відміну від `reset()`. +Див. [функцію last( |#last()]). + + +firstKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +------------------------------------------------------------------------------------------------ + +Повертає ключ першого елемента (що відповідає вказаному предикату, якщо він заданий) або нуль, якщо такого елемента немає. `$predicate` має підпис `function ($value, int|string $key, array $array): bool`. ```php -Arrays::first([1, 2, 3]); // 1 -Arrays::first([]); // null +Arrays::firstKey([1, 2, 3]); // 0 +Arrays::firstKey([1, 2, 3], fn($v) => $v > 2); // 2 +Arrays::firstKey(['a' => 1, 'b' => 2]); // 'a' +Arrays::firstKey([]); // null ``` +Див. функцію [lastKey( |#lastKey()]). + flatten(array $array, bool $preserveKeys=false): array .[method] ---------------------------------------------------------------- @@ -229,21 +265,43 @@ Arrays::isList(['a' => 1, 'b' => 2]); // false ``` -last(array $array): mixed .[method] ------------------------------------ +last(array $array, ?callable $predicate=null, ?callable $else=null): mixed .[method] +------------------------------------------------------------------------------------ + +Повертає останній елемент (що відповідає вказаному предикату, якщо він заданий). Якщо такого елемента немає, повертається результат виклику `$else` або нуль. +Функція `$predicate` має підпис `function ($value, int|string $key, array $array): bool`. + +Він не змінює внутрішній вказівник, на відміну від `end()`. Параметри `$predicate` та `$else` з'явилися починаючи з версії 4.0.4. + +```php +Arrays::last([1, 2, 3]); // 3 +Arrays::last([1, 2, 3], fn($v) => $v < 3); // 2 +Arrays::last([]); // null +Arrays::last([], else: fn() => false); // false +``` + +Див. [функцію first() |#first()]. + -Повертає останній запис масиву або null, якщо масив порожній. Не змінює внутрішній покажчик, на відміну від `end()`. +lastKey(array $array, ?callable $predicate=null): int|string|null .[method]{data-version:4.0.4} +----------------------------------------------------------------------------------------------- + +Повертає ключ останнього елемента (який відповідає вказаному предикату, якщо його задано) або нуль, якщо такого елемента не існує. `$predicate` має підпис `function ($value, int|string $key, array $array): bool`. ```php -Arrays::last([1, 2, 3]); // 3 -Arrays::last([]); // null +Arrays::lastKey([1, 2, 3]); // 2 +Arrays::lastKey([1, 2, 3], fn($v) => $v < 3); // 1 +Arrays::lastKey(['a' => 1, 'b' => 2]); // 'b' +Arrays::lastKey([]); // null ``` +Зверніться до [firstKey( |#firstKey()]). + -map(iterable $array, callable $callback): array .[method] +map(array $array, callable $transformer): array .[method] --------------------------------------------------------- -Викликає `$callback` на всіх елементах масиву і повертає масив значень, що повертаються. Зворотний виклик має сигнатуру `function ($value, $key, array $array): bool`. +Викликає `$transformer` на всіх елементах масиву і повертає масив значень, що повертаються. Зворотний виклик має сигнатуру `function ($value, $key, array $array): bool`. ```php $array = ['foo', 'bar', 'baz']; @@ -325,10 +383,10 @@ $position = Arrays::getKeyOffset($array, 'not-exists'); // vrátí null ``` -some(iterable $array, callable $callback): bool .[method] ---------------------------------------------------------- +some(array $array, callable $predicate): bool .[method] +------------------------------------------------------- -Перевіряє, чи проходить хоча б один елемент у масиві тест, реалізований у `$callback` із сигнатурою `function ($value, $key, array $array): bool`. +Перевіряє, чи проходить хоча б один елемент у масиві тест, реалізований у `$predicate` із сигнатурою `function ($value, $key, array $array): bool`. ```php $array = [1, 2, 3, 4]; diff --git a/utils/uk/images.texy b/utils/uk/images.texy index 398fc1253e..a2d84ce2fd 100644 --- a/utils/uk/images.texy +++ b/utils/uk/images.texy @@ -300,6 +300,11 @@ static isTypeSupported(int $type): bool .[method] Визначає, чи підтримується даний [тип |#Formats] зображення. +static getSupportedTypes(): array .[method]{data-version:4.0.4} +--------------------------------------------------------------- +Повертає масив підтримуваних типів зображень (константи `ImageType::XXX`). + + static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method] ------------------------------------------------------------------------------------------------------------------------ Обчислює розміри прямокутника, який охоплює текст заданого шрифту та розміру. Повертає асоціативний масив, що містить ключі `left`, `top`, `width`, `height`. Ліве поле може бути від'ємним, якщо текст починається з лівого відступу. diff --git a/utils/uk/iterables.texy b/utils/uk/iterables.texy new file mode 100644 index 0000000000..4321573824 --- /dev/null +++ b/utils/uk/iterables.texy @@ -0,0 +1,119 @@ +Функції ітератора +***************** + +.[perex]{data-version:4.0.4} +[api:Nette\Utils\Iterables] статичний клас з функціями для роботи з ітераторами. Його аналогом для масивів є [Nette\Utils\Arrays |arrays]. + + +Встановлення: + +```shell +composer require nette/utils +``` + +Усі приклади передбачають створення псевдоніма: + +```php +use Nette\Utils\Iterables; +``` + + +contains(iterable $iterable, $value): bool .[method] +---------------------------------------------------- + +Перевіряє наявність значення в ітераторі. Використовує строге порівняння (`===`). + +```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] +------------------------------------------------------- + +Перевіряє наявність ключа в ітераторі. Використовує строге порівняння (`===`). + +```php +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true +Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false +``` + + +every(iterable $iterable, callable $predicate): bool .[method] +-------------------------------------------------------------- + +Перевіряє, чи всі елементи ітератора проходять тест, реалізований у `$predicate` з сигнатурою `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 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`. Зберігає оригінальні ключі. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$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`. + +```php +Iterables::first(new ArrayIterator([1, 2, 3])); // 1 +Iterables::first(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 3 +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`. + +```php +Iterables::firstKey(new ArrayIterator([1, 2, 3])); // 0 +Iterables::firstKey(new ArrayIterator([1, 2, 3]), fn($v) => $v > 2); // 2 +Iterables::firstKey(new ArrayIterator(['a' => 1, 'b' => 2])); // 'a' +Iterables::firstKey(new ArrayIterator([])); // null +``` + + +map(iterable $iterable, callable $transformer): array .[method] +--------------------------------------------------------------- + +Ітератор, що перетворює значення шляхом виклику `$transformer`. Має сигнатуру `function ($value, $key, iterable $iterable): bool`. Зберігає оригінальні ключі. + +```php +$iterator = new ArrayIterator([1, 2, 3]); +$iterator = Iterables::map($iterator, fn($v) => $v * 2); +// 2, 4, 6 +``` + + +some(iterable $iterable, callable $predicate): bool .[method] +------------------------------------------------------------- + +Перевіряє, чи проходить хоча б один елемент ітератора тест, реалізований у `$predicate` з сигнатурою `function ($value, $key, iterable $iterable): bool`. + +```php +$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]); +$isEven = fn($value) => $value % 2 === 0; +$res = Iterables::some($iterator, $isEven); // true +``` + +Див. [функцію every() |#every()].