↑↓ seç · Enter aç · Esc kapat

Mutlu Tekin
Mutlu Tekin
← Yazılar

Bölüm 11 — Konu 52: Cascade Notasyonu (`..`)

3 dk okuma #dart
Dizi · 51/64 Dart Türkçe Tutorial
  1. Bölüm 1 — Konu 1: Dart Nedir, Nerede Kullanılır, Neden Flutter Bu Dili Seçti
  2. Bölüm 1 — Konu 2: Ortam Kurulumu (Dart SDK, DartPad, Terminal ile Çalıştırma)
  3. Bölüm 1 — Konu 3: İlk Program (`main()`, `print()`, Dosya Yapısı)
  4. Bölüm 1 — Konu 4: Yorum Satırları, Temel Sözdizimi Kuralları
  5. Bölüm 2 — Konu 5: Değişken Tanımlama — `var`, `final`, `const` Farkı
  6. Bölüm 2 — Konu 6: Temel Tipler — `int`, `double`, `String`, `bool`
  7. Bölüm 2 — Konu 7: Tip Çıkarımı (Type Inference) ve Açık Tip Belirtme
  8. Bölüm 2 — Konu 8: `dynamic` ve `Object` — Ne Zaman Kullanılır, Ne Zaman Kaçınılır
  9. Bölüm 2 — Konu 9: Null Safety Temelleri (`?`, `!`, `late`'e Giriş)
  10. Bölüm 3 — Konu 10: Aritmetik, Atama, Karşılaştırma, Mantıksal Operatörler
  11. Bölüm 3 — Konu 11: `if / else if / else`
  12. Bölüm 3 — Konu 12: `switch` / `switch expression` (Modern Dart)
  13. Bölüm 3 — Konu 13: Ternary Operatör, `??`, `??=`, `?.`
  14. Bölüm 3 — Konu 14: `for`, `while`, `do-while` Döngüleri
  15. Bölüm 4 — Konu 16: `List` — Oluşturma, Erişim, Temel Metodlar
  16. Bölüm 4 — Konu 17: `Set` — Benzersiz Eleman Mantığı
  17. Bölüm 4 — Konu 18: `Map` — Key-Value Yapılar
  18. Bölüm 4 — Konu 19: Koleksiyon Üzerinde `for-in`, `forEach`
  19. Bölüm 4 — Konu 20: Spread Operatörü (`...`, `...?`) ve Collection If/For
  20. Bölüm 5 — Konu 21: Fonksiyon Tanımlama, Parametreler (Positional, Named, Optional)
  21. Bölüm 5 — Konu 22: Varsayılan Parametre Değerleri (Derinlemesine)
  22. Bölüm 5 — Konu 23: Arrow Function (`=>`) Sözdizimi
  23. Bölüm 5 — Konu 24: Fonksiyonlar Birinci Sınıf Vatandaş — Değişkene Atama, Parametre Olarak Geçme
  24. Bölüm 5 — Konu 25: Anonim Fonksiyonlar ve Closure Kavramı (Derinlemesine)
  25. Bölüm 5 — Konu 26: Recursion (Özyineleme)
  26. Bölüm 6 — Konu 27: Class Tanımlama, Constructor (Varsayılan, Named, Factory)
  27. Bölüm 6 — Konu 28: Alanlar (Fields), Metodlar, `this` Kullanımı (Derinlemesine)
  28. Bölüm 6 — Konu 29: Initializer List, Constructor Kısayolları (Derinlemesine)
  29. Bölüm 6 — Konu 30: Getter / Setter
  30. Bölüm 6 — Konu 31: Statik Üyeler (`static`)
  31. Bölüm 7 — Konu 32: Kalıtım (`extends`), `super` Kullanımı
  32. Bölüm 7 — Konu 33: Metod Override Etme, `@override`
  33. Bölüm 7 — Konu 34: Soyut Sınıflar (`abstract class`)
  34. Bölüm 7 — Konu 35: Interface Mantığı (`implements`)
  35. Bölüm 7 — Konu 36: Mixin (`with`)
  36. Bölüm 7 — Konu 37: `enum` — Basit ve Gelişmiş (Metotlu Enum'lar)
  37. Bölüm 8 — Konu 38: `try / catch / finally`, `throw`
  38. Bölüm 8 — Konu 39: Özel Exception Sınıfları Yazma
  39. Bölüm 8 — Konu 40: Sound Null Safety Derinlemesine — `late`, `required`, Non-Nullable Varsayılan Davranış
  40. Bölüm 8 — Konu 41: `assert` ile Geliştirme Zamanı Kontrolleri
  41. Bölüm 9 — Konu 42: Generic Sınıflar ve Fonksiyonlar
  42. Bölüm 9 — Konu 43: Generic Sınırlamalar (`<T extends ...>`)
  43. Bölüm 9 — Konu 44: Dart'ın Built-in Generic Koleksiyonları Nasıl Çalışır
  44. Bölüm 10 — Konu 45: `Future` Kavramı, `async`/`await`
  45. Bölüm 10 — Konu 46: `Future.then`, Hata Yönetimi (`catchError`)
  46. Bölüm 10 — Konu 47: `Stream` Temelleri, `async*`, `yield`
  47. Bölüm 10 — Konu 48: `StreamController`, Broadcast Stream
  48. Bölüm 11 — Konu 49: `map`, `where`, `reduce`, `fold`
  49. Bölüm 11 — Konu 50: `sort`, Custom Comparator ile Sıralama
  50. Bölüm 11 — Konu 51: Iterable Kavramı Derinlemesine (Lazy Evaluation)
  51. Bölüm 11 — Konu 52: Cascade Notasyonu (`..`)
  52. Bölüm 12 — Konu 53: `pubspec.yaml`, pub.dev'den Paket Ekleme
  53. Bölüm 12 — Konu 54: Kütüphane Oluşturma, `import`/`export`, `part`/`part of`
  54. Bölüm 12 — Konu 55: Dart'ta Test Yazımı (`test` Paketi, Unit Test Mantığı)
  55. Bölüm 12 — Konu 56: Extension Methods
  56. Bölüm 12 — Konu 57: Dart'ın Derleme Modelleri (JIT vs AOT) ve Bunun Flutter'a Etkisi
  57. Bölüm 13 — Konu 59: Dart 3 Pattern Matching — Records, Destructuring, Sealed Classes, Exhaustive Switch
  58. Bölüm 13 — Konu 60: `Never` Tipi, `covariant` ve Generic Variance Detayları
  59. Bölüm 13 — Konu 61: Event Loop Derinlemesine — Microtask Queue vs Event Queue
  60. Bölüm 13 — Konu 62: Memory Model & Performans — Garbage Collection, `const` Nesnelerin Bellek Avantajı
  61. Bölüm 13 — Konu 63: Isolate'ler Arası Mesajlaşmanın Maliyeti ve `compute()`'un İç İşleyişi
  62. Bölüm 13 — Konu 64: FFI (Foreign Function Interface) — C Koduna Erişim
  63. Bölüm 13 — Konu 65: Sunucu Tarafında Dart — `dart:io`, `shelf` Paketiyle Basit Bir Backend/CLI Aracı Yazma
  64. Bölüm 13 — Konu 66: Derleyici & Analiz Araçları — `dart analyze`, Custom Lint Kuralları, `build_runner` Mimarisi
Dizinin sayfası →
İçindekiler 10 başlık
  1. Cascade (..) Nedir?
  2. Cascade ile Method Chaining Arasındaki Fark
  3. Koleksiyonlarla Cascade
  4. İç İçe Cascade — Nested Cascade
  5. ?.. — Null-Aware Cascade
  6. Gerçek Dünya Örneği — Flutter'da Cascade
  7. Ne Zaman Cascade Kullanılmamalı?
  8. 🎯 Bu Dersten Çıkarılması Gerekenler
  9. 📝 Ödevler
  10. 🏁 Bölüm 11 Tamamlandı!

Bölüm 11'in son konusundayız. Cascade notasyonunu, bir önceki derste List.from(orijinal)..sort() örneğinde kısaca kullanmıştık — şimdi bunu tam olarak işleyelim.

Cascade (..) Nedir?

Cascade notasyonu, aynı nesne üzerinde birden fazla işlemi, o nesneyi tekrar tekrar yazmadan, art arda zincirlemeni sağlayan bir sözdizimidir.

dart
class Kisi {
  String? isim;
  int? yas;
  String? sehir;

  void bilgiYazdir() {
    print("$isim, $yas yaşında, $sehir'de yaşıyor");
  }
}

void main() {
  // Cascade OLMADAN
  Kisi kisi1 = Kisi();
  kisi1.isim = "Ahmet";
  kisi1.yas = 25;
  kisi1.sehir = "İstanbul";
  kisi1.bilgiYazdir();

  // Cascade İLE — tek bir ifade
  Kisi kisi2 = Kisi()
    ..isim = "Ayşe"
    ..yas = 30
    ..sehir = "Ankara"
    ..bilgiYazdir();
}

Nasıl çalışıyor? Kisi() ile yeni bir nesne oluşturduk, sonra .. ile art arda o nesnenin alanlarına atama yaptık ve bir metodunu çağırdık — hepsi tek bir ifade içinde, kisi2. yazmayı her seferinde tekrar etmeden.

Cascade ile Method Chaining Arasındaki Fark

Bölüm 6'da method chaining'i (bir metodun this döndürerek zincirlenmesini) öğrenmiştik:

dart
class MetinOlusturucu {
  String metin = "";
  MetinOlusturucu ekle(String parca) {
    metin += parca;
    return this; // this döndürerek zincirlemeyi MÜMKÜN KILIYORDU
  }
}

Cascade'in büyük avantajı: Zincirleme yapmak için metodların özel olarak this döndürmesi gerekmiyor! Cascade, herhangi bir nesnede, herhangi bir metod/alanla çalışır — metodun kendisinin void dönmesi bile fark etmez:

dart
class HesapMakinesi {
  int sonuc = 0;

  void topla(int x) => sonuc += x; // void döndürüyor, this DEĞİL
  void cikar(int x) => sonuc -= x; // void döndürüyor
}

void main() {
  HesapMakinesi hm = HesapMakinesi()
    ..topla(10)
    ..topla(5)
    ..cikar(3);

  print(hm.sonuc); // 12
}

topla() ve cikar(), void döndürüyor — normal method chaining ile bunları zincirleyemezdin (hm.topla(10).topla(5) çalışmazdı çünkü topla()'nın döndürdüğü void'in üzerinde .topla() çağrılamaz). Ama cascade (..) ile, metodun ne döndürdüğü önemli değildir — cascade, her adımdan sonra orijinal nesneye (hm'e) geri döner, metodun kendi dönüş değerine değil.

Koleksiyonlarla Cascade

dart
void main() {
  List<int> liste = []
    ..add(1)
    ..add(2)
    ..add(3)
    ..remove(2);

  print(liste); // [1, 3]
}

Bu, Bölüm 4'te öğrendiğimiz List metodlarının (add, remove gibi) hepsinin void döndürdüğünü hatırlarsan, cascade olmadan bunları zincirlemenin imkansız olduğunu, cascade ile ise çok doğal bir şekilde art arda yazılabildiğini gösteriyor.

İç İçe Cascade — Nested Cascade

dart
class Adres {
  String? sehir;
  String? sokak;
}

class Kisi {
  String? isim;
  Adres? adres;
}

void main() {
  Kisi kisi = Kisi()
    ..isim = "Elif"
    ..adres = (Adres()
      ..sehir = "İzmir"
      ..sokak = "Atatürk Cd.");

  print("${kisi.isim}, ${kisi.adres?.sehir}, ${kisi.adres?.sokak}");
  // Elif, İzmir, Atatürk Cd.
}

Burada, adres alanına atama yaparken, içindeki Adres nesnesini de kendi cascade zinciriyle oluşturduk — parantez içine alarak ((Adres()..sehir=...)), bu iç cascade'in dış cascade'e karışmamasını sağladık.

?.. — Null-Aware Cascade

Bölüm 2-3'te öğrendiğimiz null safety operatörlerini hatırlarsan, cascade'in de bir null-aware versiyonu vardır:

dart
void main() {
  Kisi? kisi; // null

  kisi
    ?..isim = "Can" // eğer kisi null ise, bu satır ATLANIR, hata vermez
    ..yas = 20;
}

?.., "eğer nesne null değilse cascade zincirine başla, null ise tüm zinciri atla" anlamına gelir — Bölüm 3'te öğrendiğimiz ?.'nin cascade'e uygulanmış hali.

Gerçek Dünya Örneği — Flutter'da Cascade

Cascade, Flutter'da widget/controller yapılandırırken çok sık karşına çıkacak bir kalıptır. Örneğin (ileride göreceğin bir örneğe benzer şekilde):

dart
// Kavramsal bir örnek — gerçek Flutter kodunu Flutter tutorial'ında göreceğiz
class TextEditingController {
  String text = "";
  void clear() => text = "";
}

void main() {
  var controller = TextEditingController()
    ..text = "Başlangıç değeri"
    ..clear(); // sonra temizle
}

Bu kalıp, bir nesneyi oluşturduktan hemen sonra birkaç ayar/işlem yapman gerektiğinde, kodunu çok daha kompakt ve okunabilir hale getirir.

Ne Zaman Cascade Kullanılmamalı?

dart
// Cascade'in ANLAMSIZ olduğu bir durum — tek bir işlem için gereksiz
void main() {
  List<int> liste = []..add(1); // buna gerek yok, sadece liste.add(1) yeterli
}

Cascade, birden fazla ardışık işlem yapıldığında değer katar. Tek bir işlem için kullanmak, gereksiz bir sözdizimsel karmaşıklık katar — bu durumda sıradan nokta erişimi (liste.add(1)) yeterli ve daha nettir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Cascade (..), aynı nesne üzerinde birden fazla işlemi, nesneyi tekrar yazmadan zincirlemeni sağlar.
  • Method chaining'in aksine, cascade için metodların this döndürmesi gerekmez — void döndüren metodlar bile zincirlenebilir.
  • Koleksiyon metodları (add, remove gibi) genelde void döndürdüğü için, cascade onları zincirlemenin doğal yoludur.
  • İç içe cascade, parantez içine alınarak dış zincirden ayrıştırılabilir.
  • ?.., null-aware cascade sağlar — nesne null ise tüm zincir atlanır.
  • Cascade, sadece birden fazla ardışık işlem olduğunda anlamlıdır; tek işlem için gereksizdir.

📝 Ödevler

  • [ ] Kendi yazdığın bir class'ta (en az 3 alanlı), cascade kullanarak tek bir ifadede tüm alanları doldur ve bir metod çağır.
  • [ ] void döndüren metodları olan bir class yaz, cascade ile bu metodları zincirle; normal method chaining ile bunun neden mümkün olmayacağını yorumla.
  • [ ] Bir List üzerinde cascade kullanarak add, remove, insert gibi birden fazla işlemi tek ifadede zincirle.
  • [ ] İç içe cascade kullanarak, bir nesnenin içindeki başka bir nesneyi de cascade ile oluşturduğun bir örnek yaz.
  • [ ] ?.. null-aware cascade kullanarak, nullable bir nesnede cascade zincirinin güvenli şekilde atlandığını göster.

🏁 Bölüm 11 Tamamlandı!

Fonksiyonel koleksiyon programlamasını tamamladık: map, where, reduce, fold, sıralama, Iterable'ın lazy evaluation mantığı ve cascade notasyonu. Bu araçlar, Dart/Flutter kodunda günlük olarak kullanacağın, kodu kısa ve okunabilir tutan temel yapı taşlarıydı.

Sıradaki durak Bölüm 12 — Paketler, Proje Yapısı & Uzmanlık: pubspec.yaml, kütüphane oluşturma, test yazımı, extension method'lar ve Dart'ın derleme modelleriyle bu ana müfredatı tamamlayacağız.