Arbeiten mit Iteratoren
Nette\Utils\Iterables ist eine statische Klasse mit Funktionen für die Arbeit mit Iteratoren. Ihr Analogon für Arrays ist Nette\Utils\Arrays.
Installation:
composer require nette/utils
Alle Beispiele setzen voraus, dass ein Alias erstellt wurde:
use Nette\Utils\Iterables;
contains (iterable $iterable, $value): bool
Sucht nach dem angegebenen Wert im Iterator. Verwendet einen strikten Vergleich (===) zur Überprüfung der
Übereinstimmung. Gibt true zurück, wenn der Wert gefunden wird, andernfalls false.
Iterables::contains(new ArrayIterator([1, 2, 3]), 1); // true
Iterables::contains(new ArrayIterator([1, 2, 3]), '1'); // false
Diese Methode ist nützlich, wenn Sie schnell feststellen müssen, ob sich ein bestimmter Wert im Iterator befindet, ohne alle Elemente manuell durchlaufen zu müssen.
containsKey (iterable $iterable, $key): bool
Sucht nach dem angegebenen Schlüssel im Iterator. Verwendet einen strikten Vergleich (===) zur Überprüfung der
Übereinstimmung. Gibt true zurück, wenn der Schlüssel gefunden wird, andernfalls false.
Iterables::containsKey(new ArrayIterator([1, 2, 3]), 0); // true
Iterables::containsKey(new ArrayIterator([1, 2, 3]), 4); // false
every (iterable $iterable, callable $predicate): bool
Überprüft, ob alle Elemente des Iterators die in $predicate definierte Bedingung erfüllen. Die Funktion
$predicate hat die Signatur function ($value, $key, iterable $iterable): bool und muss für jedes
Element true zurückgeben, damit die Methode every() true zurückgibt.
$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]);
$isBelowThreshold = fn($value) => $value < 40;
$res = Iterables::every($iterator, $isBelowThreshold); // true
Diese Methode ist nützlich zur Überprüfung, ob alle Elemente in einer Sammlung eine bestimmte Bedingung erfüllen, beispielsweise ob alle Zahlen kleiner als ein bestimmter Wert sind.
filter (iterable $iterable, callable $predicate): Generator
Erstellt einen neuen Iterator, der nur die Elemente aus dem ursprünglichen Iterator enthält, die die in
$predicate definierte Bedingung erfüllen. Die Funktion $predicate hat die Signatur
function ($value, $key, iterable $iterable): bool und muss für die Elemente, die beibehalten werden sollen,
true zurückgeben.
$iterator = new ArrayIterator([1, 2, 3]);
$iterator = Iterables::filter($iterator, fn($v) => $v < 3);
// 1, 2
Die Methode verwendet einen Generator, was bedeutet, dass die Filterung schrittweise beim Durchlaufen des Ergebnisses erfolgt. Dies ist speichereffizient und ermöglicht die Verarbeitung auch sehr großer Sammlungen. Wenn Sie nicht alle Elemente des resultierenden Iterators durchlaufen, sparen Sie Rechenleistung, da nicht alle Elemente des ursprünglichen Iterators verarbeitet werden.
first (iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed
Gibt das erste Element des Iterators zurück. Wenn $predicate angegeben ist, gibt es das erste Element zurück,
das die angegebene Bedingung erfüllt. Die Funktion $predicate hat die Signatur
function ($value, $key, iterable $iterable): bool. Wenn kein passendes Element gefunden wird, wird die Funktion
$else aufgerufen (falls angegeben) und ihr Ergebnis zurückgegeben. Wenn $else nicht angegeben ist, wird
null zurückgegeben.
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
Diese Methode ist nützlich, wenn Sie schnell das erste Element einer Sammlung oder das erste Element, das eine bestimmte Bedingung erfüllt, erhalten müssen, ohne die gesamte Sammlung manuell durchlaufen zu müssen.
firstKey (iterable $iterable, ?callable $predicate=null, ?callable $else=null): mixed
Gibt den Schlüssel des ersten Elements des Iterators zurück. Wenn $predicate angegeben ist, gibt es den
Schlüssel des ersten Elements zurück, das die angegebene Bedingung erfüllt. Die Funktion $predicate hat die
Signatur function ($value, $key, iterable $iterable): bool. Wenn kein passendes Element gefunden wird, wird die
Funktion $else aufgerufen (falls angegeben) und ihr Ergebnis zurückgegeben. Wenn $else nicht angegeben
ist, wird null zurückgegeben.
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
Erstellt einen neuen Iterator durch Anwendung der Funktion $transformer auf jedes Element des ursprünglichen
Iterators. Die Funktion $transformer hat die Signatur
function ($value, $key, iterable $iterable): mixed, und ihr Rückgabewert wird als neuer Wert des Elements
verwendet.
$iterator = new ArrayIterator([1, 2, 3]);
$iterator = Iterables::map($iterator, fn($v) => $v * 2);
// 2, 4, 6
Die Methode verwendet einen Generator, was bedeutet, dass die Transformation schrittweise beim Durchlaufen des Ergebnisses erfolgt. Dies ist speichereffizient und ermöglicht die Verarbeitung auch sehr großer Sammlungen. Wenn Sie nicht alle Elemente des resultierenden Iterators durchlaufen, sparen Sie Rechenleistung, da nicht alle Elemente des ursprünglichen Iterators verarbeitet werden.
mapWithKeys (iterable $iterable, callable $transformer): Generator
Erstellt einen neuen Iterator durch Transformation der Werte und Schlüssel des ursprünglichen Iterators. Die Funktion
$transformer hat die Signatur function ($value, $key, iterable $iterable): ?array{$newKey, $newValue}.
Wenn $transformer null zurückgibt, wird das Element übersprungen. Für beibehaltene Elemente wird das
erste Element des zurückgegebenen Arrays als neuer Schlüssel und das zweite Element als neuer Wert verwendet.
$iterator = new ArrayIterator(['a' => 1, 'b' => 2]);
$iterator = Iterables::mapWithKeys($iterator, fn($v, $k) => $v > 1 ? [$v * 2, strtoupper($k)] : null);
// [4 => 'B']
Wie map() verwendet diese Methode einen Generator für die schrittweise Verarbeitung und effiziente
Speicherverwaltung. Dies ermöglicht die Arbeit mit großen Sammlungen und spart Rechenleistung bei teilweisem Durchlauf des
Ergebnisses.
memoize (iterable $iterable): IteratorAggregate
Erstellt einen Wrapper um einen Iterator, der während der Iteration dessen Schlüssel und Werte zwischenspeichert. Dies ermöglicht eine wiederholte Iteration der Daten, ohne die ursprüngliche Datenquelle erneut durchlaufen zu müssen.
$iterator = /* Daten, die nicht mehrmals iteriert werden können */
$memoized = Iterables::memoize($iterator);
// Jetzt können Sie $memoized mehrmals iterieren, ohne Daten zu verlieren
Diese Methode ist nützlich in Situationen, in denen Sie denselben Datensatz mehrmals durchlaufen müssen, der ursprüngliche Iterator jedoch keine wiederholte Iteration zulässt oder ein wiederholter Durchlauf kostspielig wäre (z. B. beim Lesen von Daten aus einer Datenbank oder Datei).
some (iterable $iterable, callable $predicate): bool
Überprüft, ob mindestens ein Element des Iterators die in $predicate definierte Bedingung erfüllt. Die Funktion
$predicate hat die Signatur function ($value, $key, iterable $iterable): bool und muss für mindestens
ein Element true zurückgeben, damit die Methode some() true zurückgibt.
$iterator = new ArrayIterator([1, 30, 39, 29, 10, 13]);
$isEven = fn($value) => $value % 2 === 0;
$res = Iterables::some($iterator, $isEven); // true
Diese Methode ist nützlich zur schnellen Überprüfung, ob in einer Sammlung mindestens ein Element existiert, das eine bestimmte Bedingung erfüllt, beispielsweise ob die Sammlung mindestens eine gerade Zahl enthält.
Siehe every().
toIterator (iterable $iterable): Iterator
Konvertiert jedes iterierbare Objekt (Array, Traversable) in einen Iterator. Wenn die Eingabe bereits ein Iterator ist, wird sie unverändert zurückgegeben.
$array = [1, 2, 3];
$iterator = Iterables::toIterator($array);
// Jetzt haben Sie einen Iterator anstelle eines Arrays
Diese Methode ist nützlich, wenn Sie sicherstellen müssen, dass Sie einen Iterator zur Verfügung haben, unabhängig vom Typ der Eingabedaten. Dies kann beim Erstellen von Funktionen nützlich sein, die mit verschiedenen Typen iterierbarer Daten arbeiten.
