İteratörlerle Çalışma

Nette\Utils\Iterables, iteratörlerle çalışmak için fonksiyonlar içeren statik bir sınıftır. Diziler için benzeri Nette\Utils\Arrays'dir.

Kurulum:

composer require nette/utils

Tüm örnekler, bir takma ad oluşturulduğunu varsayar:

use Nette\Utils\Iterables;

contains (iterable $iterable, $value): bool

Belirtilen değeri iteratörde arar. Eşleşmeyi doğrulamak için katı karşılaştırma (===) kullanır. Değer bulunursa true, aksi takdirde false döndürür.

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

Bu metot, tüm öğeleri manuel olarak dolaşmadan belirli bir değerin iteratörde olup olmadığını hızlıca öğrenmeniz gerektiğinde kullanışlıdır.

containsKey (iterable $iterable, $key): bool

Belirtilen anahtarı iteratörde arar. Eşleşmeyi doğrulamak için katı karşılaştırma (===) kullanır. Anahtar bulunursa true, aksi takdirde false döndürür.

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

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

İteratördeki tüm öğelerin $predicate içinde tanımlanan koşulu karşılayıp karşılamadığını doğrular. $predicate fonksiyonu function ($value, $key, iterable $iterable): bool imzasına sahiptir ve every() metodunun true döndürmesi için her öğe için true döndürmelidir.

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

Bu metot, bir koleksiyondaki tüm öğelerin belirli bir koşulu karşılayıp karşılamadığını doğrulamak için kullanışlıdır, örneğin tüm sayıların belirli bir değerden küçük olup olmadığını kontrol etmek gibi.

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

Orijinal iteratörden yalnızca $predicate içinde tanımlanan koşulu karşılayan öğeleri içeren yeni bir iteratör (jeneratör) oluşturur. $predicate fonksiyonu function ($value, $key, iterable $iterable): bool imzasına sahiptir ve korunacak öğeler için true döndürmelidir.

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

Metot bir jeneratör kullanır, bu da filtrelemenin sonuç üzerinde gezinirken aşamalı olarak gerçekleştiği anlamına gelir. Bu, bellek açısından verimlidir ve çok büyük koleksiyonların işlenmesine olanak tanır. Sonuç iteratörünün tüm öğelerini dolaşmazsanız, orijinal iteratörün tüm öğeleri işlenmeyeceği için hesaplama gücünden tasarruf edersiniz.

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

İteratörün ilk öğesini döndürür. Eğer $predicate belirtilmişse, verilen koşulu karşılayan ilk öğeyi döndürür. $predicate fonksiyonu function ($value, $key, iterable $iterable): bool imzasına sahiptir. Uygun öğe bulunamazsa, $else fonksiyonu (eğer belirtilmişse) çağrılır ve sonucu döndürülür. Eğer $else belirtilmemişse, null döndürülür.

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

Bu metot, tüm koleksiyonu manuel olarak dolaşmadan bir koleksiyonun ilk öğesini veya belirli bir koşulu karşılayan ilk öğeyi hızlıca almanız gerektiğinde kullanışlıdır.

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

İteratörün ilk öğesinin anahtarını döndürür. Eğer $predicate belirtilmişse, verilen koşulu karşılayan ilk öğenin anahtarını döndürür. $predicate fonksiyonu function ($value, $key, iterable $iterable): bool imzasına sahiptir. Uygun öğe bulunamazsa, $else fonksiyonu (eğer belirtilmişse) çağrılır ve sonucu döndürülür. Eğer $else belirtilmemişse, null döndürülür.

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

$transformer fonksiyonunu orijinal iteratörün her öğesine uygulayarak yeni bir iteratör oluşturur. $transformer fonksiyonu function ($value, $key, iterable $iterable): mixed imzasına sahiptir ve dönüş değeri öğenin yeni değeri olarak kullanılır.

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

Metot bir jeneratör kullanır, bu da dönüşümün sonuç üzerinde gezinirken aşamalı olarak gerçekleştiği anlamına gelir. Bu, bellek açısından verimlidir ve çok büyük koleksiyonların işlenmesine olanak tanır. Sonuç iteratörünün tüm öğelerini dolaşmazsanız, orijinal iteratörün tüm öğeleri işlenmeyeceği için hesaplama gücünden tasarruf edersiniz.

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

Orijinal iteratörün değerlerini ve anahtarlarını dönüştürerek yeni bir iteratör oluşturur. $transformer fonksiyonu function ($value, $key, iterable $iterable): ?array{$newKey, $newValue} imzasına sahiptir. Eğer $transformer null döndürürse, öğe atlanır. Korunan öğeler için, döndürülen dizinin ilk öğesi yeni anahtar olarak ve ikinci öğesi yeni değer olarak kullanılır.

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

map() gibi, bu metot da aşamalı işleme ve bellek ile verimli çalışma için bir jeneratör kullanır. Bu, büyük koleksiyonlarla çalışmaya ve sonucun kısmi geçişi sırasında hesaplama gücünden tasarruf etmeye olanak tanır.

memoize (iterable $iterable): IteratorAggregate

İterasyon sırasında anahtarlarını ve değerlerini önbelleğe alan bir iteratör etrafında bir sarmalayıcı oluşturur. Bu, orijinal veri kaynağını tekrar dolaşmaya gerek kalmadan verilerin tekrar tekrar itere edilmesini sağlar.

$iterator = /* birden fazla kez itere edilemeyen veriler */
$memoized = Iterables::memoize($iterator);
// Artık $memoized'ı veri kaybı olmadan birden fazla kez itere edebilirsiniz

Bu metot, aynı veri kümesini birden fazla kez dolaşmanız gereken ancak orijinal iteratörün tekrarlanan iterasyona izin vermediği veya tekrarlanan dolaşımın maliyetli olacağı durumlarda (örneğin, veritabanından veya dosyadan veri okurken) kullanışlıdır.

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

İteratördeki en az bir öğenin $predicate içinde tanımlanan koşulu karşılayıp karşılamadığını doğrular. $predicate fonksiyonu function ($value, $key, iterable $iterable): bool imzasına sahiptir ve some() metodunun true döndürmesi için en az bir öğe için true döndürmelidir.

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

Bu metot, bir koleksiyonda belirli bir koşulu karşılayan en az bir öğenin olup olmadığını hızlıca doğrulamak için kullanışlıdır, örneğin koleksiyonun en az bir çift sayı içerip içermediğini kontrol etmek gibi.

Bkz. every().

toIterator (iterable $iterable): Iterator

Herhangi bir itere edilebilir nesneyi (array, Traversable) Iterator'a dönüştürür. Girdi zaten bir Iterator ise, değişiklik yapmadan onu döndürür.

$array = [1, 2, 3];
$iterator = Iterables::toIterator($array);
// Artık dizi yerine bir Iterator'ınız var

Bu metot, girdi verilerinin türünden bağımsız olarak bir Iterator'a sahip olduğunuzdan emin olmanız gerektiğinde kullanışlıdır. Bu, farklı türlerde itere edilebilir verilerle çalışan fonksiyonlar oluştururken faydalı olabilir.