Bölüm 11 — Konu 49: `map`, `where`, `reduce`, `fold`

Bölüm 11'e hoş geldin. Bu bölümde, Bölüm 4'te öğrendiğimiz koleksiyonları çok daha güçlü ve kısa bir şekilde işlemeyi sağlayan fonksiyonel programlama metodlarını işleyeceğiz. Bunların bazılarına (.where(), .forEach()) önceki derslerde kısaca değinmiştik — şimdi hepsini sistematik olarak, tam derinlikle görüyoruz.

#map — Her Elemanı Dönüştürme

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  Iterable<int> kareler = sayilar.map((sayi) => sayi * sayi);
  print(kareler); // (1, 4, 9, 16, 25)

  List<int> kareListesi = sayilar.map((sayi) => sayi * sayi).toList();
  print(kareListesi); // [1, 4, 9, 16, 25]
}

.map(), listedeki her elemana verilen fonksiyonu uygular ve yeni bir koleksiyon (dönüştürülmüş halleriyle) üretir. Orijinal sayilar listesi değişmez — map, her zaman yeni bir sonuç üretir, var olan listeyi değiştirmez.

.map()'in döndürdüğü tip Iterable'dır, List değil! Bunu bir listeye çevirmek için .toList() çağırman gerekir (yukarıdaki örnekte gördüğün gibi). Bunun nedenini birazcık sonra (lazy evaluation) açıklayacağız.

Klasik for döngüsüyle aynı işi yapmak isteseydik:

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];
  List<int> kareler = [];
  for (var sayi in sayilar) {
    kareler.add(sayi * sayi);
  }
  print(kareler); // [1, 4, 9, 16, 25]
}

.map(), bunu tek satırda ve daha bildirimsel (declarative) bir şekilde ifade ediyor — "her elemanı böyle dönüştür" demek, "boş bir liste oluştur, döngü kur, her elemanı işle, listeye ekle" demekten çok daha kısa ve niyeti net.

#where — Filtreleme

Bölüm 5'te bir önizlemesini görmüştük — şimdi tam olarak işleyelim:

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  List<int> ciftler = sayilar.where((sayi) => sayi % 2 == 0).toList();
  print(ciftler); // [2, 4, 6, 8, 10]
}

.where(), koşulu (true döndüren) sağlayan elemanları seçer, koşulu sağlamayanları eler. Verdiğin fonksiyon, her eleman için true/false döndürmelidir (buna predicate — yüklemsel fonksiyon — denir).

#map ile where'i Birlikte Kullanma — Zincirleme

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  List<int> sonuc = sayilar
      .where((sayi) => sayi % 2 == 0) // önce çiftleri filtrele
      .map((sayi) => sayi * sayi)     // sonra karesini al
      .toList();

  print(sonuc); // [4, 16, 36, 64, 100]
}

Bu, Bölüm 6'da öğrendiğimiz method chaining kavramının fonksiyonel programlamadaki karşılığıdır — birden fazla işlemi, tek bir akıcı ifade içinde zincirleyebiliyorsun. Bu tarz kod, "ne yapmak istediğini" adım adım okunabilir bir şekilde anlatır: "çiftleri al, karesini hesapla."

#reduce — Koleksiyonu Tek Bir Değere İndirgeme

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  int toplam = sayilar.reduce((a, b) => a + b);
  print(toplam); // 15
}

.reduce(), koleksiyondaki tüm elemanları birleştirerek tek bir değere indirger. Verdiğin fonksiyon, her adımda "şu ana kadarki birikmiş değer" (a) ile "sıradaki eleman"'ı (b) alır, ikisini birleştirip yeni bir "birikmiş değer" üretir.

Adım adım nasıl çalıştığını görelim:

reduce başlar: a=1 (ilk eleman), b=2 → a+b = 3
sonraki adım:   a=3 (önceki sonuç), b=3 → a+b = 6
sonraki adım:   a=6, b=4 → a+b = 10
sonraki adım:   a=10, b=5 → a+b = 15
sonuç: 15

Önemli kural: .reduce(), boş bir listede çağrılamaz — çünkü "başlangıç değeri" olarak listenin ilk elemanını kullanır, boş listede ilk eleman yoktur:

void main() {
  List<int> bosListe = [];
  int sonuc = bosListe.reduce((a, b) => a + b); // ❌ HATA! StateError
}

#fold — reduce'un Daha Esnek Versiyonu

void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  int toplam = sayilar.fold(0, (a, b) => a + b); // 0'dan başlıyor
  print(toplam); // 15

  int toplamArtı100 = sayilar.fold(100, (a, b) => a + b); // 100'den başlıyor!
  print(toplamArtı100); // 115
}

.fold(), .reduce()'a çok benzer ama bir farkla: .fold(), başlangıç değerini sen belirlersin (ilk parametre olarak) — koleksiyonun ilk elemanını kullanmak zorunda değilsin. Bu, iki önemli avantaj sağlar:

1. Boş koleksiyonda çalışabilir:

void main() {
  List<int> bosListe = [];
  int toplam = bosListe.fold(0, (a, b) => a + b);
  print(toplam); // 0 — hata vermez!
}

2. Farklı bir tipe "indirgeyebilirsin":

void main() {
  List<int> sayilar = [1, 2, 3];

  // int listesinden bir String üretmek — reduce ile YAPILAMAZ (tip uyuşmazlığı), fold ile yapılabilir
  String sonuc = sayilar.fold("Sayılar: ", (metin, sayi) => "$metin$sayi ");
  print(sonuc); // Sayılar: 1 2 3
}

.reduce()'da, "birikmiş değer" ile "eleman" aynı tipte olmak zorundadır (int ile int). .fold()'da ise, başlangıç değerini farklı bir tipte (burada String) seçebilirsin, bu yüzden koleksiyonu tamamen farklı bir tipe "indirgeyebilirsin." Bu, .fold()'u .reduce()'dan daha genel ve esnek yapar.

#reduce mı fold mu? — Karar Verme

Pratik tavsiye: Genel olarak .fold(), .reduce()'un yapabildiği her şeyi yapabilir (ve daha fazlasını) — bu yüzden emin değilsen .fold() kullanmak daha güvenli bir seçimdir. .reduce(), sadece "kesinlikle boş olmayan bir liste var ve sonuç aynı tipte olacak" durumlarında biraz daha kısa bir sözdizimi sunar.

#Gerçek Dünya Örneği — Hepsini Bir Arada Kullanmak

class Urun {
  String ad;
  double fiyat;
  int adet;
  Urun(this.ad, this.fiyat, this.adet);
}

void main() {
  List<Urun> sepet = [
    Urun("Kalem", 5.0, 3),
    Urun("Defter", 15.0, 2),
    Urun("Silgi", 2.0, 5),
  ];

  // where: sadece 10 TL'den pahalı ürünler
  var pahaliUrunler = sepet.where((u) => u.fiyat > 10).toList();

  // map: her ürünün toplam tutarını hesapla
  var tutarlar = sepet.map((u) => u.fiyat * u.adet);

  // fold: sepetin genel toplamını hesapla
  double genelToplam = sepet.fold(0, (toplam, u) => toplam + (u.fiyat * u.adet));

  print("Pahalı ürünler: ${pahaliUrunler.map((u) => u.ad).toList()}");
  print("Tutarlar: ${tutarlar.toList()}");
  print("Genel toplam: $genelToplam TL");
}

Bu örnek, gerçek bir uygulamada (örneğin bir alışveriş sepeti hesaplaması) bu üç metodun birlikte nasıl kullanılabileceğini gösteriyor — her biri farklı bir işi çok kısa ve okunabilir şekilde hallediyor.

#🎯 Bu Dersten Çıkarılması Gerekenler

• .map(), her elemanı dönüştürüp yeni bir Iterable üretir; orijinal koleksiyonu değiştirmez.
• .where(), koşulu sağlayan elemanları filtreler.
• .reduce(), koleksiyonu tek bir değere indirger; boş koleksiyonda çalışmaz, sonuç eleman tipiyle aynı olmalıdır.
• .fold(), .reduce()'a benzer ama başlangıç değeri belirtilebilir — boş koleksiyonda çalışır ve farklı bir tipe indirgeme yapılabilir.
• Bu metodlar zincirlenebilir (.where().map().toList() gibi), bu da bildirimsel ve okunabilir kod yazmayı sağlar.

#📝 Ödevler

• [ ] Bir sayı listesinin her elemanının küpünü alan bir .map() örneği yaz.
• [ ] Bir isim listesinden, sadece 5 karakterden uzun olanları .where() ile filtrele.
• [ ] .where() ve .map()'i zincirleyerek, önce belirli bir koşulu sağlayan elemanları filtrele, sonra onları dönüştür.
• [ ] .reduce() ile bir listenin en büyük elemanını bul (matematiksel toplama değil, karşılaştırma mantığıyla).
• [ ] .fold() kullanarak bir Urun listesinden toplam tutarı hesapla; aynı işlemi boş bir listeyle de test edip .reduce()'un neden burada çalışmayacağını yorumla.

Sıradaki konu: Bölüm 11 — Konu 50: sort, Custom Comparator ile Sıralama