Iterátorokkal való munka

A Nette\Utils\Iterables egy statikus osztály iterátorokkal való munkához szükséges függvényekkel. A tömbökhöz hasonló megfelelője a Nette\Utils\Arrays.

Telepítés:

composer require nette/utils

Minden példa feltételezi a létrehozott aliast:

use Nette\Utils\Iterables;

contains (iterable $iterable, $value): bool

Keresi a megadott értéket az iterátorban. Szigorú összehasonlítást (===) használ az egyezés ellenőrzésére. true-t ad vissza, ha az érték megtalálható, egyébként false-t.

Iterables::contains(new ArrayIterator([1, 2, 3]), 1);    // true
Iterables::contains(new ArrayIterator([1, 2, 3]), '1');  // false

Ez a metódus hasznos, ha gyorsan meg kell tudni, hogy egy adott érték megtalálható-e az iterátorban anélkül, hogy manuálisan végig kellene menni az összes elemen.

containsKey (iterable $iterable, $key): bool

Keresi a megadott kulcsot az iterátorban. Szigorú összehasonlítást (===) használ az egyezés ellenőrzésére. true-t ad vissza, ha a kulcs megtalálható, egyébként false-t.

Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0);  // true
Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4);  // false

every (iterable $iterable, callable $predicate): bool

Ellenőrzi, hogy az iterátor összes eleme megfelel-e a $predicate-ben definiált feltételnek. A $predicate függvény szignatúrája function ($value, $key, iterable $iterable): bool, és true-t kell visszaadnia minden elemre, hogy az every() metódus true-t adjon vissza.

$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]);
$isBelowThreshold = fn($value) => $value < 40;
$res = Iterables::every($iterator, $isBelowThreshold); // true

Ez a metódus hasznos annak ellenőrzésére, hogy egy gyűjtemény összes eleme megfelel-e egy bizonyos feltételnek, például hogy minden szám kisebb-e egy adott értéknél.

filter (iterable $iterable, callable $predicate): Generator

Létrehoz egy új iterátort, amely csak azokat az elemeket tartalmazza az eredeti iterátorból, amelyek megfelelnek a $predicate-ben definiált feltételnek. A $predicate függvény szignatúrája function ($value, $key, iterable $iterable): bool, és true-t kell visszaadnia a megtartandó elemekre.

$iterator = new ArrayIterator([1, 2, 3]);
$iterator = Iterables::filter($iterator, fn($v) => $v < 3);
// 1, 2

A metódus generátort használ, ami azt jelenti, hogy a szűrés fokozatosan történik az eredmény bejárása során. Ez memóriahatékony és lehetővé teszi nagyon nagy gyűjtemények feldolgozását is. Ha nem járja be az eredményül kapott iterátor összes elemét, számítási teljesítményt takarít meg, mivel nem kerül feldolgozásra az eredeti iterátor összes eleme.

first (iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed

Visszaadja az iterátor első elemét. Ha meg van adva a $predicate, akkor az első olyan elemet adja vissza, amely megfelel a megadott feltételnek. A $predicate függvény szignatúrája function ($value, $key, iterable $iterable): bool. Ha nem található megfelelő elem, meghívódik az $else függvény (ha meg van adva), és annak eredménye kerül visszaadásra. Ha az $else nincs megadva, null kerül visszaadásra.

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

Ez a metódus hasznos, ha gyorsan meg kell szerezni egy gyűjtemény első elemét vagy az első olyan elemet, amely megfelel egy bizonyos feltételnek, anélkül, hogy manuálisan végig kellene menni az egész gyűjteményen.

firstKey (iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed

Visszaadja az iterátor első elemének kulcsát. Ha meg van adva a $predicate, akkor az első olyan elem kulcsát adja vissza, amely megfelel a megadott feltételnek. A $predicate függvény szignatúrája function ($value, $key, iterable $iterable): bool. Ha nem található megfelelő elem, meghívódik az $else függvény (ha meg van adva), és annak eredménye kerül visszaadásra. Ha az $else nincs megadva, null kerül visszaadásra.

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): Generator

Létrehoz egy új iterátort a $transformer függvény alkalmazásával az eredeti iterátor minden elemére. A $transformer függvény szignatúrája function ($value, $key, iterable $iterable): mixed, és a visszatérési értéke lesz az elem új értéke.

$iterator = new ArrayIterator([1, 2, 3]);
$iterator = Iterables::map($iterator, fn($v) => $v * 2);
// 2, 4, 6

A metódus generátort használ, ami azt jelenti, hogy a transzformáció fokozatosan történik az eredmény bejárása során. Ez memóriahatékony és lehetővé teszi nagyon nagy gyűjtemények feldolgozását is. Ha nem járja be az eredményül kapott iterátor összes elemét, számítási teljesítményt takarít meg, mivel nem kerül feldolgozásra az eredeti iterátor összes eleme.

mapWithKeys (iterable $iterable, callable $transformer): Generator

Létrehoz egy új iterátort az eredeti iterátor értékeinek és kulcsainak transzformálásával. A $transformer függvény szignatúrája function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}. Ha a $transformer null-t ad vissza, az elem kihagyásra kerül. A megtartott elemek esetében a visszaadott tömb első eleme lesz az új kulcs, a második eleme pedig az új érték.

$iterator = new ArrayIterator(['a' => 1, 'b' => 2]);
$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null);
// [4 => 'B']

Mint a map(), ez a metódus is generátort használ a fokozatos feldolgozáshoz és a hatékony memóriakezeléshez. Ez lehetővé teszi nagy gyűjteményekkel való munkát és számítási teljesítmény megtakarítását az eredmény részleges bejárása esetén.

memoize (iterable $iterable): IteratorAggregate

Létrehoz egy burkolót az iterátor köré, amely az iteráció során gyorsítótárba helyezi annak kulcsait és értékeit. Ez lehetővé teszi az adatok ismételt iterálását anélkül, hogy újra végig kellene menni az eredeti adatforráson.

$iterator = /* data, která nelze iterovat vícekrát */
$memoized = Iterables::memoize($iterator);
// Nyní můžete iterovat $memoized vícekrát bez ztráty dat

Ez a metódus hasznos olyan helyzetekben, amikor ugyanazt az adathalmazt többször kell bejárni, de az eredeti iterátor nem teszi lehetővé az ismételt iterációt, vagy az ismételt bejárás költséges lenne (pl. adatbázisból vagy fájlból történő adatolvasáskor).

some (iterable $iterable, callable $predicate): bool

Ellenőrzi, hogy az iterátor legalább egy eleme megfelel-e a $predicate-ben definiált feltételnek. A $predicate függvény szignatúrája function ($value, $key, iterable $iterable): bool, és true-t kell visszaadnia legalább egy elemre, hogy a some() metódus true-t adjon vissza.

$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]);
$isEven = fn($value) => $value % 2 === 0;
$res = Iterables::some($iterator, $isEven); // true

Ez a metódus hasznos annak gyors ellenőrzésére, hogy a gyűjteményben létezik-e legalább egy elem, amely megfelel egy bizonyos feltételnek, például hogy a gyűjtemény tartalmaz-e legalább egy páros számot.

Lásd every().

toIterator (iterable $iterable): Iterator

Átalakít bármilyen iterálható objektumot (array, Traversable) Iteratorrá. Ha a bemenet már Iterator, változatlanul visszaadja.

$array = [1, 2, 3];
$iterator = Iterables::toIterator($array);
// Nyní máte Iterator místo pole

Ez a metódus hasznos, ha biztosítani kell, hogy Iterator álljon rendelkezésre, függetlenül a bemeneti adatok típusától. Ez hasznos lehet olyan függvények létrehozásakor, amelyek különböző típusú iterálható adatokkal dolgoznak.