Dart ve Flutter öğrenenler için Discord sunucumuz açıldı.Katıl

↑↓ seç · Enter aç · Esc kapat

Dizi · 64 bölüm

Dart Türkçe Tutorial

Tutorial üzerinden okuyarak öğrenmek isteyenler için güncel (10.2026) Türkçe dart programlama dili rehberidir.

Mutlu Tekin · https://mutlutekin.com/dizi/dart-turkce-tutorial

1. bölüm

Bölüm 1 — Konu 1: Dart Nedir, Nerede Kullanılır, Neden Flutter Bu Dili Seçti

Dart Nedir?

Dart, Google tarafından 2011 yılında geliştirilmeye başlanan, nesne yönelimli, tip güvenli (type-safe), client-optimized bir programlama dilidir. "Client-optimized" ifadesi önemli — Dart özellikle kullanıcı arayüzü (UI) geliştirmek için tasarlandı, sunucu tarafı bir dil olarak doğmadı (sonradan o alana da genişledi).

Dart'ı tanımlayan birkaç temel özellik:

  • Statik tip sistemi + tip çıkarımı: Java/C# gibi tip güvenliği sağlar ama JavaScript gibi var ile de rahat yazılabilir.
  • Null safety: Bir değişkenin null olup olamayacağı derleme zamanında (compile-time) bellidir — çalışma zamanı (runtime) "null reference" hatalarını büyük ölçüde ortadan kaldırır.
  • Hem derlenebilir hem yorumlanabilir: Aynı kod, geliştirme sırasında hızlı test için JIT (Just-In-Time), yayınlama sırasında performans için AOT (Ahead-Of-Time) derlenebilir. (Bunu Bölüm 12'de derinlemesine işleyeceğiz.)
  • Tanıdık sözdizimi: C, Java, JavaScript, Kotlin'e benzer bir syntax'a sahip — bu dilleri bilen biri için öğrenme eğrisi düşüktür.

Nerede Kullanılır?

Dart'ın kullanım alanları zamanla genişledi:

Alan Açıklama
Mobil (Flutter) En yaygın kullanım alanı — tek kod tabanıyla iOS + Android
Web Flutter Web ile tarayıcı uygulamaları
Desktop Flutter Desktop ile Windows/macOS/Linux uygulamaları
Sunucu/CLI dart:io ve shelf gibi paketlerle backend servisleri, komut satırı araçları
Embedded Sınırlı ölçüde gömülü sistemlerde de kullanılıyor

Yani Dart, "sadece Flutter'ın dili" değil — ama pratikte %90+ kullanımı Flutter üzerinden gerçekleşiyor, biz de bu tutorial'ı o hedefe göre kurguladık.

Neden Flutter Bu Dili Seçti?

Bu aslında çok stratejik bir mühendislik kararı. Google'ın Flutter için Dart'ı seçmesinin arkasındaki teknik nedenler:

1. Hem JIT hem AOT derleme desteği Geliştirme sırasında JIT derleme sayesinde hot reload mümkün oluyor (kodu değiştirip saniyeler içinde sonucu görebiliyorsun). Yayına alırken ise AOT derleme ile native makine koduna çevriliyor, bu da JavaScript veya yorumlanan dillere göre çok daha yüksek performans sağlıyor.

2. Garbage collection'ın UI thread'e uygun tasarımı Dart'ın çöp toplayıcısı (garbage collector), UI'da "jank" (takılma/donma) yaratmayacak şekilde optimize edilmiş. Bu, sürekli widget oluşturup yok eden bir framework için kritik.

3. Native derleme = JavaScript köprüsüne gerek yok React Native gibi frameworkler JavaScript'i native tarafa "köprüleyerek" çalışır — bu bir performans darboğazıdır. Flutter'da Dart doğrudan native ARM koduna derlenir, ara katman (bridge) yoktur.

4. Nesne yönelimli + herkese tanıdık sözdizimi Widget ağacı gibi derinlemesine iç içe geçmiş yapıları modellemek için güçlü bir class sistemine ihtiyaç var. Dart'ın sözdizimi Java/Kotlin/Swift bilenler için çok yabancı değil.

5. Google'ın dili üzerinde tam kontrolü Google, Dart'ı geliştirdiği için, Flutter'ın ihtiyaçlarına göre dile doğrudan yeni özellikler ekleyebiliyor (örneğin sound null safety'nin 2.12'de gelmesi, Dart 3'teki pattern matching — bunları Bölüm 13'te göreceğiz — büyük ölçüde Flutter geliştirici deneyimini iyileştirmek için tasarlandı).

Küçük Bir Örnek — Şimdilik Sadece Okuyarak İncele

Henüz kod yazmıyoruz (bu Konu 3'te), ama Dart'ın neye benzediğine dair bir fikir vermesi için:

dart
void main() {
  String dil = "Dart";
  int yayinYili = 2011;
  bool flutterIcinTasarlandi = false; // aslında Flutter'dan önce vardı

  print("$dil, $yayinYili yılında yayınlandı.");
}

Burada dikkat çekilmesi gereken tek şey: $dil gibi string interpolation kullanımı — bu Bölüm 2'de detaylı işlenecek bir konu, şimdilik sadece tanıdık gelsin diye gösterildi.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart, özellikle client-side UI geliştirme için optimize edilmiş bir dil.
  • Flutter'ın onu seçmesinin sebebi rastgele değil — JIT+AOT ikili derleme, native performans, UI-dostu garbage collection gibi somut mühendislik gerekçeleri var.
  • Dart sadece Flutter'a bağlı değil ama pratikte en güçlü kullanım alanı orası.

Sıradaki konu: Bölüm 1 — Konu 2: Ortam Kurulumu (Dart SDK, DartPad, terminal ile çalıştırma)

2. bölüm

Bölüm 1 — Konu 2: Ortam Kurulumu (Dart SDK, DartPad, Terminal ile Çalıştırma)

Neden Bu Konu Önemli?

Kod yazmaya başlamadan önce, kodu nerede ve nasıl çalıştıracağını bilmen gerekiyor. Dart ile üç temel şekilde çalışabilirsin:

  1. DartPad — tarayıcı üzerinden, kurulum gerektirmeyen online editör
  2. Dart SDK + terminal — kendi bilgisayarında gerçek geliştirme ortamı
  3. IDE (VS Code / Android Studio) — SDK üzerine kurulu, eklentilerle zenginleştirilmiş geliştirme ortamı

Şimdi bunları sırayla kuralım.

1. DartPad — Sıfır Kurulumla Deneme Alanı

dartpad.dev adresine gittiğinde, tarayıcıda çalışan tam bir Dart editörü karşına çıkar. Hiçbir kurulum gerektirmez.

Ne zaman kullanılır?

  • Küçük bir kod parçasını hızlıca denemek istediğinde
  • Bir kavramı (örneğin bir döngü mantığını) izole şekilde test etmek istediğinde
  • Henüz kendi bilgisayarına bir şey kurmadan Dart'a "tatmak" istediğinde

Nasıl çalışır?

  • Sol tarafa kod yazarsın, "Run" butonuna basarsın, sağda çıktıyı görürsün.
  • main() fonksiyonu otomatik olarak orada hazır gelir, sen içini doldurursun.

Bu tutorial boyunca küçük örnekleri DartPad'de hızlıca deneyebilirsin — ama gerçek bir proje geliştirmek için SDK kurulumu şart.

2. Dart SDK Kurulumu

SDK (Software Development Kit), Dart kodunu derlemeni ve çalıştırmanı sağlayan araç setidir. İçinde şunlar bulunur:

  • dart komutu (derleyici + çalıştırıcı + paket yöneticisi hepsi bir arada)
  • dartfmt / dart format (kod formatlama)
  • dart analyze (statik analiz — Bölüm 13'te detaylı göreceğiz)
  • pub paket yöneticisi (pub.dev'den paket indirmeyi sağlar)

Kurulum (işletim sistemine göre):

  • Windows: dart.dev/get-dart üzerinden installer indirilir veya choco install dart-sdk (Chocolatey varsa)
  • macOS: brew tap dart-lang/dart && brew install dart
  • Linux: Paket yöneticisine göre değişir (apt, snap vb.) — resmi dokümantasyon güncel komutları verir

Not: Eğer ileride doğrudan Flutter kurarsan, Flutter SDK'nın içinde zaten kendi Dart SDK'sı gömülü gelir. Ama şu an sadece Dart öğrendiğimiz için bağımsız Dart SDK kurmak daha doğru.

Kurulumu doğrulama:

Terminali (Windows'ta PowerShell/CMD, macOS/Linux'ta Terminal) aç ve şunu çalıştır:

bash
dart --version

Çıktı şuna benzer bir şey olmalı:

metin
Dart SDK version: 3.x.x (stable) (...) on "windows_x64"

Eğer "komut bulunamadı" gibi bir hata alıyorsan, SDK'nın PATH ortam değişkenine eklenip eklenmediğini kontrol etmen gerekir (kurulum sihirbazı genelde bunu otomatik yapar, ama bazen manuel eklemek gerekebilir).

3. Terminal ile Kod Çalıştırma

DartPad'in aksine, gerçek bir proje geliştirirken kodu kendi makinende, terminal üzerinden çalıştıracaksın.

Basit bir dosya oluşturup çalıştıralım:

merhaba.dart adında bir dosya oluştur:

dart
void main() {
  print("Terminalden çalışıyorum!");
}

Terminalde dosyanın bulunduğu klasöre git ve çalıştır:

bash
dart run merhaba.dart

Çıktı:

metin
Terminalden çalışıyorum!

dart run ne yapıyor? Arka planda dosyanı JIT (Just-In-Time) derleyip anında çalıştırıyor. Bu, geliştirme sırasında hızlı geri bildirim almanı sağlıyor — az önceki derste bahsettiğimiz JIT/AOT ikiliğinin küçük bir örneğini burada zaten görmüş oldun.

4. IDE Kurulumu (Önerilen: VS Code)

Terminalden dosya çalıştırmak öğretici ama pratik değil. Gerçek geliştirme için bir IDE (Integrated Development Environment) kullanacağız.

VS Code kurulumu:

  1. code.visualstudio.com üzerinden VS Code'u indir ve kur.
  2. VS Code içinde Extensions (Uzantılar) sekmesine git, "Dart" eklentisini ara ve kur.
  3. Bu eklenti otomatik olarak kod tamamlama (autocomplete), hata vurgulama (error highlighting), debug desteği gibi özellikleri açar.

Alternatif: Android Studio / IntelliJ Eğer ileride Flutter'a geçince Android emulator'lerle çalışacaksan, Android Studio kurmak mantıklı olabilir (Dart eklentisi orada da mevcut). Şimdilik salt Dart öğrenirken VS Code daha hafif ve hızlıdır.

5. Klasik Hatalar ve Çözümleri

Sorun Olası Çözüm
dart: command not found SDK'nın PATH'e eklenmediğini gösterir — kurulumu terminali kapatıp yeniden açarak veya PATH'i manuel ekleyerek düzelt
VS Code'da kod tamamlama çalışmıyor Dart eklentisinin kurulu ve aktif olduğunu kontrol et, VS Code'u yeniden başlat
dart run çalışmıyor, "no pubspec.yaml found" hatası Bu hata genelde proje bazlı komutlarda çıkar (dart create ile oluşturulan projelerde); tek dosyalık script'lerde sorun olmaz

🎯 Bu Dersten Çıkarılması Gerekenler

  • DartPad: hızlı deneme için, kurulum gerektirmez.
  • Dart SDK: gerçek geliştirme için zorunlu, dart --version ile doğrulanır.
  • Terminal: dart run dosya.dart ile herhangi bir Dart dosyasını çalıştırabilirsin.
  • VS Code + Dart eklentisi: günlük geliştirme için önerilen ortam.

📝 Ödevler

  • [ ] Dart SDK'yı kendi işletim sistemine kur, dart --version çıktısını al.
  • [ ] DartPad'de basit bir "Merhaba Dünya" programı yaz ve çalıştır.
  • [ ] Aynı programı kendi bilgisayarında bir .dart dosyasına yazıp terminalden dart run ile çalıştır.
  • [ ] VS Code'a Dart eklentisini kur, bilerek bir sözdizimi hatası (örneğin noktalı virgülü unutarak) yaz ve editörün bunu nasıl vurguladığını gözlemle.

Sıradaki konu: Bölüm 1 — Konu 3: İlk Program (main(), print(), dosya yapısı)

3. bölüm

Bölüm 1 — Konu 3: İlk Program (`main()`, `print()`, Dosya Yapısı)

main() Fonksiyonu — Programın Giriş Kapısı

Her Dart programının tek bir zorunlu unsuru vardır: main() fonksiyonu. Dart çalışma zamanı (runtime), bir dosyayı çalıştırırken önce main() fonksiyonunu arar ve programı oradan başlatır.

dart
void main() {
  print("Merhaba Dart!");
}

Bunu parça parça açalım:

  • void — bu fonksiyonun geri değer döndürmediğini belirtir. main() fonksiyonu bir şey hesaplayıp döndürmez, sadece programı çalıştırır.
  • main — fonksiyonun adı. Bu isim sabittir, değiştirilemez — Dart runtime'ı özellikle bu isimde bir fonksiyon arar.
  • () — parantezler, fonksiyonun parametre almadığını gösteriyor (aslında main komut satırı argümanlarını List<String> args olarak da alabilir, buna birazdan değineceğiz).
  • { } — süslü parantezler, fonksiyonun gövdesini (body) yani çalıştırılacak kod bloğunu belirtir.

print(), Dart'ın standart kütüphanesinde (dart:core içinde, otomatik olarak her yerde erişilebilir) tanımlı bir fonksiyondur. Görevi basittir: verdiğin değeri konsola (terminale veya DartPad çıktı paneline) yazdırmak.

dart
void main() {
  print("Bu bir metin");
  print(42);
  print(3.14);
  print(true);
}

Çıktı:

metin
Bu bir metin
42
3.14
true

Dikkat et — print() sadece string değil, herhangi bir değeri yazdırabilir. Arka planda Dart, verdiğin değeri otomatik olarak string'e çevirir (bu, her nesnenin sahip olduğu toString() metodu sayesinde olur — bunu Bölüm 6'da sınıflar konusunda detaylı göreceğiz).

Komut Satırı Argümanları (args) — Şimdilik Kısa Bir Bakış

main() fonksiyonu isteğe bağlı olarak bir parametre alabilir:

dart
void main(List<String> args) {
  print("Aldığım argümanlar: $args");
}

Bu programı terminalden şöyle çalıştırırsan:

bash
dart run merhaba.dart selam dunya

Çıktı:

metin
Aldığım argümanlar: [selam, dunya]

Bu konuyu şimdi derinlemesine işlemiyoruz (koleksiyonları henüz görmedik), ama main()'in bu şekilde de kullanılabildiğini bilmen yeterli — ileride CLI araçları yazarken (Bölüm 13) bu önemli olacak.

Dosya Yapısı — Bir Dart Dosyası Nasıl Görünür?

Basit bir .dart dosyası genelde şu sırayı takip eder:

dart
// 1. Import ifadeleri (varsa) - dışarıdan kütüphane/paket dahil etme
import 'dart:math';

// 2. Üst seviye değişkenler/sabitler (varsa)
const String uygulamaAdi = "İlk Programım";

// 3. Fonksiyonlar (main dahil, başka yardımcı fonksiyonlar da olabilir)
void main() {
  print(uygulamaAdi);
  selamVer();
}

void selamVer() {
  print("Merhaba!");
}

Şu an import satırını detaylı açmıyoruz (Bölüm 12'de kütüphaneler konusunda işleyeceğiz), sadece dosyanın genel iskeletini tanıman için gösteriyorum. Önemli olan şu: Dart dosyaları yukarıdan aşağıya okunur ama main() her zaman programın gerçek başlangıç noktasıdır — dosyanın neresinde tanımlanırsa tanımlansın.

Bölüm 2'de string interpolation'ı detaylı göreceğiz ama şimdiden küçük bir örnek görmen faydalı:

dart
void main() {
  String isim = "Ayşe";
  print("Merhaba, " + isim + "!");   // klasik birleştirme (+)
  print("Merhaba, $isim!");          // Dart'a özgü, daha temiz yöntem
}

İkisi de aynı çıktıyı verir: Merhaba, Ayşe! — ama $isim kullanımı Dart'ta çok daha yaygın ve idiomatic'tir. Bunu bir sonraki bölümde detaylandıracağız.

Sık Yapılan Başlangıç Hataları

dart
void main() {
  print("Merhaba")   // ❌ noktalı virgül unutuldu
}

Dart'ta her ifade (statement) noktalı virgülle (;) biter. Bunu unutmak en yaygın başlangıç hatasıdır — derleyici sana açık bir hata mesajıyla bunu bildirecektir.

dart
void Main() {   // ❌ büyük harfle "Main" yazıldı
  print("Hata verir");
}

Dart case-sensitive (büyük/küçük harf duyarlı) bir dildir. main ile Main tamamen farklı isimlerdir, runtime sadece küçük harfle yazılan main'i tanır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • main() her Dart programının zorunlu giriş noktasıdır, ismi değiştirilemez.
  • print() herhangi bir değeri konsola yazdırır, arka planda toString() kullanır.
  • main(List<String> args) ile komut satırı argümanları alınabilir (ileride kullanılacak).
  • Dart case-sensitive'dir ve her ifade noktalı virgülle biter.

📝 Ödevler

  • [ ] main() fonksiyonu içinde kendi adını, en sevdiğin sayıyı ve bugünün doğru/yanlış bir ifadesini (örn. "bugün pazartesi mi") 3 ayrı print() ile yazdır.
  • [ ] main(List<String> args) kullanarak terminalden verdiğin isim argümanını "Merhaba, [isim]!" şeklinde yazdıran bir program yaz.
  • [ ] Bilerek noktalı virgülü unutarak bir hata oluştur, derleyicinin verdiği hata mesajını oku ve ne anlama geldiğini yorumla.
  • [ ] selamVer() gibi kendi yazdığın ayrı bir fonksiyonu main() içinden çağıran bir örnek yaz (fonksiyonları detaylı işlemedik ama bu basit çağrıyı deneyerek görmen faydalı).

Sıradaki konu: Bölüm 1 — Konu 4: Yorum Satırları, Temel Sözdizimi Kuralları

4. bölüm

Bölüm 1 — Konu 4: Yorum Satırları, Temel Sözdizimi Kuralları

Bölüm 1'in son konusundayız — bu dersten sonra Dart dosyalarını okuyabilecek, temel kuralları bilerek kod yazmaya başlayabileceksin.

Yorum Satırları (Comments)

Yorumlar, derleyici tarafından tamamen yok sayılan, sadece insanların okuması için yazılan metinlerdir. Dart'ta üç tür yorum vardır:

1. Tek satırlık yorum (//)

dart
void main() {
  // Bu bir yorum satırıdır, çalıştırılmaz
  print("Merhaba"); // Bu satırın sonuna da yorum eklenebilir
}

2. Çok satırlı yorum (/* ... */)

dart
void main() {
  /*
    Bu birden fazla satıra
    yayılan bir yorumdur.
    Genelde uzun açıklamalar için kullanılır.
  */
  print("Merhaba");
}

3. Dokümantasyon yorumu (///)

dart
/// Bu fonksiyon kullanıcıya bir selam mesajı yazdırır.
/// [isim] parametresi selamlanacak kişinin adıdır.
void selamVer(String isim) {
  print("Merhaba, $isim!");
}

/// ile başlayan yorumlar özeldir — IDE'ler (VS Code gibi) bu yorumları fonksiyonun üzerine geldiğinde tooltip olarak gösterir, ayrıca dart doc aracı bunlardan otomatik dokümantasyon üretebilir. Bunu ileride kendi paketini yazarken (Bölüm 12) daha çok kullanacaksın; şimdilik var olduğunu bilmen yeterli.

Ne zaman yorum yazılır? İyi bir pratik: kodun ne yaptığını değil, neden öyle yaptığını açıklamak. Kod zaten "ne yaptığını" kendi başına anlatmalı (okunabilir isimlerle). Yorumlar genelde bir kararın arkasındaki mantığı açıklamak içindir.

Temel Sözdizimi Kuralları

1. Her ifade noktalı virgülle biter

dart
void main() {
  print("Bir");
  print("İki");
}

Bir önceki derste değindiğimiz gibi, bu en sık unutulan kuraldır. Dart, C/Java ailesine ait bir dil olduğu için bu kural onlardan miras kalmıştır (Python'un aksine).

2. Kod blokları süslü parantezle ({ }) tanımlanır

dart
void main() {
  if (true) {
    print("İçeride");
  }
}

Fonksiyon gövdeleri, if blokları, döngüler — hepsi { } ile sınırlandırılır. (İstisna: tek satırlık if ifadeleri süslü parantezsiz de yazılabilir ama bu genelde önerilmez, okunabilirliği düşürür.)

3. Case-sensitivity (büyük/küçük harf duyarlılığı)

dart
var isim = "Ali";
var Isim = "Veli"; // Bu, tamamen farklı bir değişkendir!

isim ve Isim derleyici için iki ayrı, ilgisiz değişkendir. Bu, birçok yeni başlayanın kafasını karıştırır — dikkatli olunmalı.

4. İsimlendirme kuralları (Naming Conventions)

Dart'ın resmi stil rehberi (Effective Dart) belirli isimlendirme kalıpları önerir:

Öğe Kural Örnek
Değişken, fonksiyon lowerCamelCase kullaniciAdi, hesaplaToplam()
Sınıf, enum, tip UpperCamelCase Kullanici, SiparisDurumu
Sabit (const) lowerCamelCase (Dart'ta SCREAMING_CASE önerilmez) maksimumDeger
Dosya adı snake_case kullanici_servisi.dart

Bu kurallar zorunlu değil (derleyici seni buna zorlamaz) ama topluluk standardıdır — başka birinin kodunu okurken ya da başkasının senin kodunu okuması gerektiğinde bu tutarlılık büyük fark yaratır. dart analyze ve dart format araçları bu standartlara uyup uymadığını kontrol etmene yardımcı olur.

5. Boşluk ve girinti (indentation) — zorunlu değil ama şart gibi

dart
void main() {
print("Kötü girinti");
    print("Tutarsız girinti");
}

Yukarıdaki kod çalışır (Dart, Python gibi girintiye göre blok ayırmaz, süslü parantezlere göre ayırır) ama okunması zordur. Doğrusu:

dart
void main() {
  print("Düzgün girinti");
  print("Tutarlı 2 boşluk");
}

Dart topluluğunda standart girinti 2 boşluktur (tab değil). dart format komutu, dosyanı otomatik olarak bu standarda göre düzenler — bunu birazdan deneyeceğiz.

6. Identifier (tanımlayıcı) kuralları

Değişken/fonksiyon/sınıf isimleri:

  • Harf veya alt çizgi (_) ile başlamalı (rakamla başlayamaz)
  • Harf, rakam, alt çizgi içerebilir
  • Dart'ın anahtar kelimeleri (if, class, void vb.) isim olarak kullanılamaz
dart
var 2isim = "Hata";     // ❌ rakamla başlıyor
var kullanıcı-adı = "Hata"; // ❌ tire kullanılamaz
var _gizliDeger = 42;   // ✅ alt çizgi ile başlayabilir (özel bir anlamı var, ileride göreceğiz)
var kullaniciAdi = "Ok"; // ✅ doğru

Not: Alt çizgi ile başlayan isimlerin Dart'ta özel bir anlamı vardır — bir kütüphane/sınıf içinde "private" (özel) erişim belirtir. Bunu Bölüm 6'da sınıflar konusunda detaylı işleyeceğiz.

dart format — Otomatik Kod Düzenleme

Girinti ve boşluk konusunda endişelenmene gerek yok aslında — Dart SDK ile gelen dart format aracı, kodunu otomatik olarak standart formata sokar.

Terminalde dene:

bash
dart format merhaba.dart

Bu komut, dosyandaki girintileri, boşlukları, satır uzunluklarını topluluk standardına göre otomatik düzeltir. VS Code'da Dart eklentisi kuruluysa, dosyayı kaydettiğinde (Ctrl+S / Cmd+S) bu otomatik de çalışacak şekilde ayarlanabilir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Üç yorum türü var: //, /* */, /// (dokümantasyon).
  • Her ifade ; ile biter, bloklar { } ile sınırlanır.
  • Dart case-sensitive'dir.
  • İsimlendirme kuralları: değişken/fonksiyon lowerCamelCase, sınıf UpperCamelCase, dosya snake_case.
  • dart format ile kod otomatik düzenlenebilir — girinti konusunda elle uğraşmana gerek yok.

📝 Ödevler

  • [ ] Bir .dart dosyasına 3 farklı yorum türünü (//, /* */, ///) kullanarak örnekler yaz.
  • [ ] Bilerek yanlış isimlendirilmiş (örn. KullaniciAdi büyük harfle başlayan bir değişken) bir kod yaz, sonra Effective Dart kurallarına göre düzelt.
  • [ ] Girintisi bozuk (tutarsız boşluklu) bir dosya yaz, dart format çalıştırıp önce/sonra farkını gözlemle.
  • [ ] Geçersiz bir identifier (örn. rakamla başlayan bir değişken adı) yazmayı dene, derleyicinin verdiği hatayı oku ve yorumla.

🏁 Bölüm 1 Tamamlandı!

Artık Dart ortamını kurabiliyor, ilk programını yazıp çalıştırabiliyor, temel sözdizimi kurallarını biliyorsun. Sıradaki durak Bölüm 2 — Değişkenler & Veri Tipleri: var/final/const farkı, temel tipler ve null safety'ye giriş ile devam edeceğiz.

5. bölüm

Bölüm 2 — Konu 5: Değişken Tanımlama — `var`, `final`, `const` Farkı

Bölüm 2'ye hoş geldin. Bu bölümde değişkenleri ve veri tiplerini derinlemesine işleyeceğiz. İlk konumuz, Dart'ta bir değişken tanımlamanın üç temel yolu: var, final ve const.

var — Değeri Değişebilen, Tipi Çıkarılan Değişken

dart
void main() {
  var isim = "Ahmet";
  print(isim); // Ahmet

  isim = "Mehmet"; // ✅ değer değiştirilebilir
  print(isim); // Mehmet
}

var ile bir değişken tanımladığında, Dart tip çıkarımı (type inference) yapar — yani sen tipi yazmasan da Dart, verdiğin ilk değere bakarak tipi otomatik belirler. Yukarıdaki örnekte isim değişkeni, "Ahmet" bir String olduğu için otomatik olarak String tipinde kabul edilir.

Önemli detay: Tip bir kere belirlendikten sonra değişmez. Yani:

dart
void main() {
  var yas = 25;
  yas = "yirmi beş"; // ❌ HATA! yas zaten int olarak belirlendi
}

Bu kod derlenmez — var "tipi sonradan istediğim gibi değiştirebileceğim" anlamına gelmiyor, sadece "tipi ilk değere göre otomatik belirlensin" anlamına geliyor. Bu, Dart'ın statik tip sisteminin bir sonucu — JavaScript'teki var ile karıştırılmamalı, çok farklı davranıyor.

final — Bir Kere Atanan, Sonra Değiştirilemeyen Değişken

dart
void main() {
  final sehir = "İstanbul";
  print(sehir); // İstanbul

  sehir = "Ankara"; // ❌ HATA! final değişken yeniden atanamaz
}

final, değişkene bir kere değer atamana izin verir; o değer atandıktan sonra bir daha değiştirilemez. var'dan farkı burada: var ile değeri istediğin kadar değiştirebilirsin, final ile sadece bir kere atayabilirsin.

Önemli nüans: final değişkenin değeri, çalışma zamanında (runtime) belirlenebilir:

dart
void main() {
  final simdikiSaat = DateTime.now(); // her çalıştırmada farklı bir değer
  print(simdikiSaat);
}

Bu geçerlidir çünkü final'in tek şartı "bir kere atanması" — o değerin programın derlenme anında mı yoksa çalışma anında mı belirlendiği önemli değil.

const — Derleme Zamanında Sabitlenen Değer

dart
void main() {
  const pi = 3.14159;
  print(pi);

  pi = 3.14; // ❌ HATA! const değiştirilemez
}

const da final gibi değiştirilemez, ama çok daha katı bir kuralı var: değeri derleme zamanında (compile-time) bilinmelidir.

dart
void main() {
  const simdikiSaat = DateTime.now(); // ❌ HATA!
  print(simdikiSaat);
}

Bu kod çalışmaz çünkü DateTime.now() programın her çalıştırılışında farklı bir sonuç üretir — bu değer ancak çalışma zamanında bilinebilir, derleme zamanında değil. const bunu kabul etmez.

Üçünü Karşılaştıralım

Özellik var final const
Değer değiştirilebilir mi? ✅ Evet ❌ Hayır (bir kere atanır) ❌ Hayır
Ne zaman değer bilinmeli? İstediğin zaman Runtime'da (çalışırken) olabilir Derleme zamanında (compile-time) olmalı
Tip çıkarımı yapılır mı? ✅ Evet ✅ Evet ✅ Evet

Hangisini Ne Zaman Kullanmalı?

Pratik bir kural: Varsayılan olarak final kullan. Değeri gerçekten sonradan değiştirmen gerekiyorsa var kullan. Değer, program çalışmadan önce (derleme anında) zaten belli, hiç değişmeyecek bir sabitse const kullan.

dart
void main() {
  const uygulamaAdi = "Sipariş Takip"; // hiç değişmeyecek bir sabit → const
  final baslangicZamani = DateTime.now(); // bir kere atanıyor ama runtime'da belirleniyor → final
  var siparisSayisi = 0; // her siparişte artacak → var

  siparisSayisi = siparisSayisi + 1;
  print("$uygulamaAdi - $siparisSayisi sipariş, başlangıç: $baslangicZamani");
}

Neden var yerine varsayılan olarak final önerilir? Bu bir yazılım mühendisliği prensibiyle ilgili: bir değişkenin değişmeyeceğini garanti altına almak, kodu okuyan (ve gelecekte bakımını yapan) kişi için büyük bir netlik sağlar. "Bu değer bir daha değişmeyecek" bilgisi, hata ayıklarken (debugging) işini çok kolaylaştırır. Flutter'da da bu pratiği sürekli göreceksin — özellikle widget'ların final alanlarında.

const ile İlgili İleri Bir Not (Şimdilik Bilgi Amaçlı)

const, sadece değişkenler için değil, nesneler için de kullanılabilir ve bu durumda özel bir performans avantajı sağlar — Dart, aynı const nesneyi bellekte sadece bir kere tutar (nesne değişmez olduğu için tekrar oluşturmaya gerek yoktur). Bunu Bölüm 13'te "memory model & performans" konusunda derinlemesine işleyeceğiz; Flutter'da da const Widget(...) şeklinde sürekli karşına çıkacak. Şimdilik sadece var olduğunu bil.

Sık Yapılan Hata: final ile const Karıştırmak

dart
final a = 10; // ✅ geçerli
const b = 10; // ✅ geçerli — çünkü 10 zaten derleme zamanında bilinen bir sabit

final liste = [1, 2, 3];
liste.add(4); // ✅ geçerli! final, listenin İÇERİĞİNİN değişmesini engellemiyor,
              // sadece "liste" değişkenine YENİ BİR liste atanmasını engelliyor
print(liste); // [1, 2, 3, 4]

Bu son örnek kafa karıştırıcı olabilir — final/const, değişkenin kendisinin yeniden atanmasını engeller, ama eğer o değişken bir liste/harita gibi değiştirilebilir (mutable) bir nesneyse, o nesnenin içeriği yine değiştirilebilir. Bunu koleksiyonlar konusunda (Bölüm 4) daha net göreceğiz.


🎯 Bu Dersten Çıkarılması Gerekenler

  • var: tipi otomatik belirlenir, değer istenildiği kadar değiştirilebilir.
  • final: bir kere atanır, runtime'da belirlenebilir, sonra değiştirilemez.
  • const: bir kere atanır, değeri derleme zamanında bilinmelidir, sonra değiştirilemez.
  • Pratik kural: varsayılan olarak final kullan, gerçekten değişmesi gerekiyorsa var, kesin sabitse const.
  • final/const değişkenin yeniden atanmasını engeller ama nesnenin içeriğinin değişmesini engellemeyebilir.

📝 Ödevler

  • [ ] var, final ve const ile birer değişken tanımla, hangisinin neden değiştirilemediğini yorum olarak açıkla.
  • [ ] Bir kişinin adı, yaşı, boyu ve öğrenci olup olmadığını tutan 4 değişken oluştur, tiplerini açıkça belirt.
  • [ ] const ile DateTime.now() atamayı dene, hatayı gözlemle; sonra aynı satırı final yaparak düzelt.
  • [ ] final bir liste tanımla, listeye eleman ekleyip çıkararak (.add(), .remove()) final'in listenin içeriğini değil, değişkenin kendisini koruduğunu göster.

Sıradaki konu: Bölüm 2 — Konu 6: Temel Tipler (int, double, String, bool)

6. bölüm

Bölüm 2 — Konu 6: Temel Tipler — `int`, `double`, `String`, `bool`

Dart'ta Her Şey Bir Nesnedir

Konuya girmeden önemli bir felsefi noktayı belirtelim: Dart'ta sayılar, string'ler, fonksiyonlar, hatta null bile birer nesnedir (object). Java gibi dillerde int ilkel (primitive) bir tiptir, ama Dart'ta int de aslında Object'ten türeyen bir sınıftır. Bu, ileride "her şey widget'tır" (Flutter) mantığını anlamana da zemin hazırlayacak — Dart'ta zaten "her şey nesnedir" mantığı var.

Bu pratikte şu anlama geliyor: bir int değişkeninin üzerinde doğrudan metod çağırabilirsin:

dart
void main() {
  int sayi = -5;
  print(sayi.abs()); // 5 — abs() metodu int sınıfının bir üyesi
}

Şimdi dört temel tipi tek tek inceleyelim.

int — Tam Sayılar

dart
void main() {
  int yas = 25;
  int negatifSayi = -10;
  int buyukSayi = 1000000;

  print(yas);
  print(yas + 5); // 30
  print(yas * 2); // 50
  print(yas ~/ 2); // 12 — tam sayı bölmesi (integer division)
  print(yas % 7); // 4 — mod (kalan)
}

Dikkat: ~/ operatörü, normal / bölmesinden farklıdır — sonucu tam sayıya yuvarlayarak (küsuratı atarak) döndürür. 25 / 2 sonucu 12.5 (double) verirken, 25 ~/ 2 sonucu 12 (int) verir. Bunu bir sonraki derste operatörler konusunda daha detaylı göreceğiz.

int sınıfının bazı faydalı özellik ve metodları:

dart
void main() {
  int sayi = -7;
  print(sayi.isNegative); // true
  print(sayi.isEven);     // false
  print(sayi.abs());      // 7
  print(sayi.toString()); // "-7" (String'e çevirir)
}

double — Ondalıklı Sayılar

dart
void main() {
  double boy = 1.75;
  double pi = 3.14159;
  double negatif = -0.5;

  print(boy);
  print(boy + 0.25); // 2.0
}

Önemli bir detay: int ve double işlemlerini karıştırdığında sonuç her zaman double olur:

dart
void main() {
  int a = 5;
  double b = 2.0;
  print(a + b); // 7.0 — double döner
}

double'ın da faydalı metodları var:

dart
void main() {
  double sayi = 3.7;
  print(sayi.round());  // 4 — en yakın tam sayıya yuvarlar
  print(sayi.floor());  // 3 — aşağı yuvarlar
  print(sayi.ceil());   // 4 — yukarı yuvarlar
  print(sayi.toInt());  // 3 — küsuratı direkt atar
}

num — İkisinin Ortak Üst Tipi

Dart'ta hem int hem double'ın ortak bir üst tipi (superclass) vardır: num. Eğer bir değişkenin tam sayı mı ondalıklı mı olacağı baştan belli değilse (ya da her ikisi de olabilecekse), num kullanılabilir:

dart
void main() {
  num deger = 10;    // şu an int
  deger = 10.5;       // şimdi double — num buna izin verir
  print(deger);
}

Bunu sınıf hiyerarşisi (kalıtım) konusuna girdiğimizde (Bölüm 7) daha iyi anlayacaksın — şimdilik num'un "hem int hem double olabilir" anlamına geldiğini bil.

String — Metinler

dart
void main() {
  String tekTirnak = 'Merhaba';
  String ciftTirnak = "Merhaba"; // ikisi de aynı, fark yok

  print(tekTirnak);
}

Dart'ta tek tırnak (') ve çift tırnak (") arasında fonksiyonel bir fark yoktur, ikisi de string tanımlamak için kullanılır. Genel pratikte tutarlı bir seçim yapıp onu kullanmak önerilir (topluluğun çoğu tek tırnağı tercih eder, ama bu tamamen stil tercihidir).

String interpolation (değişkeni string içine gömme) — Bölüm 1'de gördüğün gibi:

dart
void main() {
  String isim = "Zeynep";
  int yas = 28;

  print("Adım $isim, yaşım $yas"); // basit değişken
  print("Yaşımın iki katı: ${yas * 2}"); // ifade (expression) için süslü parantez zorunlu
}

Kural: Tek bir değişkeni yazdırırken $degisken yeterli, ama bir ifade (işlem, metod çağrısı vb.) yazdırmak istiyorsan ${ifade} şeklinde süslü parantez kullanmalısın.

Çok satırlı string'ler:

dart
void main() {
  String mesaj = """
  Bu birden fazla
  satıra yayılan
  bir string.
  """;
  print(mesaj);
}

Faydalı String metodları:

dart
void main() {
  String metin = "  Merhaba Dünya  ";
  print(metin.trim());               // "Merhaba Dünya" — başta/sondaki boşlukları siler
  print(metin.toUpperCase());        // "  MERHABA DÜNYA  "
  print(metin.toLowerCase());        // "  merhaba dünya  "
  print(metin.contains("Dünya"));    // true
  print(metin.replaceAll("Dünya", "Türkiye")); // "  Merhaba Türkiye  "
  print(metin.trim().split(" "));    // [Merhaba, Dünya] — bir listeye böler
  print(metin.trim().length);        // 14 — karakter sayısı
}

bool — Mantıksal Değerler

dart
void main() {
  bool ogrenciMi = true;
  bool calisiyorMu = false;

  print(ogrenciMi);
  print(!ogrenciMi); // false — ! ile tersini alırsın
}

bool sadece iki değer alabilir: true veya false. Genelde karşılaştırma işlemlerinin sonucu olarak karşımıza çıkar:

dart
void main() {
  int yas = 20;
  bool reşitMi = yas >= 18;
  print(reşitMi); // true
}

Önemli: Dart'ta, C/JavaScript'in aksine, 0 veya boş string gibi değerler otomatik olarak false'a çevrilmez. Yani:

dart
void main() {
  int sayi = 0;
  if (sayi) {   // ❌ HATA! int, bool bekleyen yere konulamaz
    print("Çalışmaz");
  }
}

Bu, Dart'ın güçlü tip sisteminin bir sonucu — if her zaman gerçek bir bool ifadesi bekler, "0 = false gibi davranır" gibi örtük (implicit) dönüşümlere izin vermez. Bu, birçok gizli hatayı (bug) baştan engeller.

Tip Kontrolü ve Dönüşümü

Bir değişkenin tipini kontrol etmek için is operatörü kullanılır:

dart
void main() {
  var deger = 42;
  print(deger is int);    // true
  print(deger is String); // false
}

Tipler arası dönüşüm için özel metodlar kullanılır (otomatik/örtük dönüşüm yoktur):

dart
void main() {
  String sayiMetni = "123";
  int sayi = int.parse(sayiMetni); // String → int
  print(sayi + 1); // 124

  double ondalik = double.parse("3.14"); // String → double
  print(ondalik);

  int tamSayi = 99;
  String metin = tamSayi.toString(); // int → String
  print(metin);
}

Dikkat: int.parse() geçersiz bir string ile çağrılırsa hata (FormatException) fırlatır:

dart
void main() {
  int sayi = int.parse("merhaba"); // ❌ FormatException fırlatır
}

Bunu Bölüm 8'de hata yönetimi (try/catch) konusunda nasıl güvenli şekilde ele alacağımızı göreceğiz.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ta her şey (sayılar dahil) bir nesnedir, bu yüzden int/double üzerinde doğrudan metod çağırabilirsin.
  • int: tam sayı, double: ondalıklı sayı, ikisinin ortak üst tipi num.
  • ~/ tam sayı bölmesi yapar, / her zaman double döner.
  • String interpolation: basit değişken için $degisken, ifade için ${ifade}.
  • bool sadece true/false alır, Dart'ta örtük (implicit) bool dönüşümü yoktur.
  • Tip dönüşümleri açık (explicit) yapılır: int.parse(), double.parse(), .toString().

📝 Ödevler

  • [ ] Bir sayının hem normal bölmesini (/) hem tam sayı bölmesini (~/) hem de modunu (%) hesaplayıp üçünün farkını yorumla.
  • [ ] Kullanıcıdan aldığını varsayacağın (elle yazacağın) bir string'i int.parse() ile sayıya çevirip 10 ile çarp.
  • [ ] Bir cümledeki tüm kelimeleri büyük harfe çevirip, sonra split(" ") ile kelimelere ayırıp kaç kelime olduğunu yazdır.
  • [ ] is operatörü ile 3 farklı değişkenin (int, String, bool) tipini kontrol eden bir program yaz.
  • [ ] int.parse("abc") çağırıp ne tür bir hata aldığını gözlemle (henüz try/catch bilmiyoruz, sadece hatayı oku).

Sıradaki konu: Bölüm 2 — Konu 7: Tip Çıkarımı (Type Inference) ve Açık Tip Belirtme

7. bölüm

Bölüm 2 — Konu 7: Tip Çıkarımı (Type Inference) ve Açık Tip Belirtme

Tip Çıkarımı Nedir?

Önceki derslerde var kullaniciAdi = "Ahmet"; gibi örnekler yazdık ama hiç String yazmadık — buna rağmen Dart, kullaniciAdi'nin bir String olduğunu biliyor. Bu, tip çıkarımı (type inference) sayesinde oluyor: derleyici, verdiğin ilk değere bakarak tipi kendisi belirliyor.

dart
void main() {
  var isim = "Elif";     // Dart bunun String olduğunu anlar
  var yas = 30;           // Dart bunun int olduğunu anlar
  var boy = 1.65;         // Dart bunun double olduğunu anlar
  var aktif = true;       // Dart bunun bool olduğunu anlar
}

Bunu doğrulamak istersen, VS Code'da bir değişkenin üzerine fare ile gelirsen (hover), Dart eklentisi sana o değişkenin çıkarılmış tipini gösterir — kod içinde yazılı olmasa bile.

Açık (Explicit) Tip Belirtme

var yerine, tipi doğrudan sen de yazabilirsin:

dart
void main() {
  String isim = "Elif";
  int yas = 30;
  double boy = 1.65;
  bool aktif = true;
}

Bu iki yaklaşım (tip çıkarımı vs açık belirtme) fonksiyonel olarak tamamen aynı sonucu verir — ikisinde de değişken statik olarak tiplendirilmiştir, ikisinde de derleme zamanında tip kontrolü yapılır. Fark sadece sözdizimseldir (syntactic), yani nasıl yazdığınla ilgilidir.

Peki Hangisini Ne Zaman Kullanmalı?

Bu, Dart topluluğunda biraz tartışmalı bir stil konusudur, ama genel kabul gören pratikler şunlar:

var kullan, eğer:

  • Değişkenin tipi, atadığın değerden zaten apaçık belliyse:
    dart
    var kullaniciAdi = "mehmet123"; // String olduğu zaten çok açık

Açık tip belirt, eğer:

  • Tip, ilk bakışta belli değilse veya kodun okunabilirliğini artıracaksa:
    dart
    double hesaplaOrtalama(List<int> sayilar) {
    double toplam = 0; // burada "double" yazmak, "bu bir tam sayı değil" diye netlik katıyor
    for (var s in sayilar) {
      toplam += s;
    }
    return toplam / sayilar.length;
    }
  • Bir fonksiyonun parametrelerinde ve dönüş tipinde her zaman açık tip belirtilir (bu zorunludur, var fonksiyon imzasında kullanılmaz — bunu Bölüm 5'te fonksiyonlar konusunda detaylı göreceğiz).

var ≠ dynamic — Kritik Bir Ayrım

Yeni başlayanların en çok karıştırdığı nokta budur. var ile tanımlanan bir değişken statik olarak tiplendirilmiştir — tip, derleme zamanında sabitlenir ve bir daha değişmez:

dart
void main() {
  var mesaj = "Merhaba";
  mesaj = 42; // ❌ HATA! mesaj zaten String olarak sabitlendi
}

Bunu bir sonraki konuda (dynamic ve Object) çok daha net göreceğiz — orada gerçekten "tipi çalışma zamanında değişebilen" bir değişken türünü işleyeceğiz. Şimdilik şunu bil: var, "tipsiz değişken" demek değildir — "tipi otomatik belirlenen değişken" demektir.

Tip Çıkarımı Fonksiyonlarda da Çalışır

dart
selamVer(isim) {
  return "Merhaba, $isim!";
}

Yukarıdaki gibi bir fonksiyon yazarsan, Dart parametrenin ve dönüş değerinin tipini dynamic olarak kabul eder (bu iyi bir pratik değildir — bir sonraki derste neden kaçınılması gerektiğini göreceğiz). Doğrusu:

dart
String selamVer(String isim) {
  return "Merhaba, $isim!";
}

Fonksiyonlarda tip çıkarımı dönüş tipi için de kullanılabilir (=> ile yazılan arrow function'larda derleyici çıkarım yapabilir), ama en iyi pratik, fonksiyon imzalarında tipleri her zaman açıkça yazmaktır — çünkü bir fonksiyonu çağıran başka bir geliştirici (ya da gelecekteki sen), parametrenin ne beklediğini kod içine bakmadan, sadece imzayı okuyarak anlayabilmeli.

Koleksiyonlarda Tip Çıkarımı — Küçük Bir Önizleme

Bölüm 4'te koleksiyonları detaylı işleyeceğiz ama tip çıkarımının orada da çalıştığını görmen faydalı:

dart
void main() {
  var sayilar = [1, 2, 3]; // Dart bunun List<int> olduğunu anlar
  var isimler = ["Ali", "Veli"]; // List<String>
}

Yine burada var kullanmak yaygın bir pratiktir çünkü liste içeriğinden tip zaten belli oluyor.

Bir Kural Daha: Tutarlılık

Bir projede/takımda hangi yaklaşım seçilirse seçilsin (bazıları her yerde açık tip yazmayı, bazıları mümkün olduğunca var kullanmayı tercih eder), önemli olan tutarlı olmaktır. dart analyze aracı (Bölüm 13'te detaylandıracağız), projene özel lint kuralları tanımlayarak bu tutarlılığı zorunlu kılmana bile izin verir.

Küçük Bir Karşılaştırma Örneği

dart
// Yaklaşım 1: Tip çıkarımı (var)
void main() {
  var toplamPuan = 0;
  var ogrenciSayisi = 25;
  var ortalama = toplamPuan / ogrenciSayisi;
  print(ortalama);
}

// Yaklaşım 2: Açık tip belirtme
void main() {
  int toplamPuan = 0;
  int ogrenciSayisi = 25;
  double ortalama = toplamPuan / ogrenciSayisi;
  print(ortalama);
}

İki kod da tamamen aynı şekilde çalışır, aynı hataları yakalar (örneğin toplamPuan'a bir String atamaya çalışırsan ikisi de hata verir). Fark tamamen okunabilirlik tercihi.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Tip çıkarımı, var ile tanımlanan değişkenin tipini ilk değerden otomatik belirler.
  • var ile açık tip belirtme fonksiyonel olarak aynıdır, sadece sözdizimsel bir tercih.
  • var, dynamic değildir — tip bir kere belirlenir ve sabitlenir.
  • Fonksiyon parametrelerinde ve dönüş tiplerinde açık tip belirtmek en iyi pratiktir.
  • Önemli olan, seçtiğin yaklaşımda tutarlı olmak.

📝 Ödevler

  • [ ] Aynı 4 değişkeni (isim, yaş, boy, öğrenci mi) bir kere var ile bir kere açık tip belirterek iki ayrı main() fonksiyonunda tanımla, ikisinin de aynı şekilde çalıştığını doğrula.
  • [ ] var ile tanımladığın bir değişkene, tanımlandığı tipten farklı bir değer atamayı dene (örn. var x = 5; x = "beş";), hatayı oku ve yorumla.
  • [ ] VS Code'da bir var değişkeninin üzerine fare ile gelip Dart eklentisinin gösterdiği çıkarılmış tipi kontrol et.
  • [ ] Parametre ve dönüş tipi açıkça belirtilmiş bir fonksiyon yaz (örn. iki sayının ortalamasını double olarak döndüren), fonksiyonları henüz detaylı işlemedik ama bu basit örneği dene.

Sıradaki konu: Bölüm 2 — Konu 8: dynamic ve Object — Ne Zaman Kullanılır, Ne Zaman Kaçınılır

8. bölüm

Bölüm 2 — Konu 8: `dynamic` ve `Object` — Ne Zaman Kullanılır, Ne Zaman Kaçınılır

Dart'ın Tip Hiyerarşisine Kısa Bir Bakış

Önceki derste var'ın dynamic olmadığını vurgulamıştık. Şimdi bu ikisini ve Object'i netleştirelim. Önce şu gerçeği bilmen gerekiyor: Dart'ta her tip, kök bir tipten türer. Bu köke Object (ya da null safety ile birlikte Object?) denir.

metin
Object?
 ├── Object
 │     ├── num
 │     │    ├── int
 │     │    └── double
 │     ├── String
 │     ├── bool
 │     ├── List
 │     ├── ... (diğer tüm sınıflar)
 │     
 └── Null

dynamic ise bu hiyerarşinin biraz dışında, özel bir role sahip.

Object — "Herhangi Bir Şey Olabilir Ama Tip Güvenli"

dart
void main() {
  Object deger = "Merhaba";
  print(deger); // Merhaba

  deger = 42; // ✅ geçerli, çünkü int de Object'ten türer
  print(deger); // 42
}

Object tipinde bir değişken, herhangi bir tipte değer tutabilir (çünkü her şey zaten Object'ten türer). Ama önemli bir kısıtlama var:

dart
void main() {
  Object deger = "Merhaba Dünya";
  print(deger.toUpperCase()); // ❌ HATA!
}

Bu kod derlenmez! Çünkü Object sınıfının kendisinde toUpperCase() metodu yoktur — o metod String sınıfına özgüdür. Dart, deger değişkeninin statik tipini Object olarak bildiği için, çalışma zamanında içinde gerçekten bir String olduğunu bilse bile, derleme zamanında String'e özgü metodları çağırmana izin vermez.

Bunu kullanabilmek için tip dönüşümü (cast) yapman gerekir:

dart
void main() {
  Object deger = "Merhaba Dünya";
  String metin = deger as String; // açık tip dönüşümü
  print(metin.toUpperCase()); // MERHABA DÜNYA
}

Ya da daha güvenli bir yöntem, is ile kontrol edip Dart'ın otomatik tip daraltmasından (type promotion) faydalanmak:

dart
void main() {
  Object deger = "Merhaba Dünya";
  if (deger is String) {
    print(deger.toUpperCase()); // ✅ artık deger, bu blok içinde String olarak biliniyor
  }
}

dynamic — "Herhangi Bir Şey Olabilir, Tip Kontrolü Kapalı"

dart
void main() {
  dynamic deger = "Merhaba Dünya";
  print(deger.toUpperCase()); // ✅ çalışır! Derleme zamanında kontrol edilmez

  deger = 42;
  print(deger.toUpperCase()); // ❌ Bu sefer RUNTIME HATASI verir! int'te toUpperCase yok
}

dynamic, Object'ten temelde farklı davranır: derleme zamanı tip kontrolünü tamamen kapatır. Bir dynamic değişken üzerinde istediğin metodu çağırabilirsin, derleyici seni durdurmaz — ama eğer o metod, değişkenin o anki gerçek tipinde yoksa, çalışma zamanında (runtime) hata alırsın.

Object ile dynamic Arasındaki Fark — Özet Tablo

Özellik Object dynamic
Herhangi bir değer tutabilir mi? ✅ Evet ✅ Evet
Derleme zamanı tip kontrolü ✅ Var (sadece Object'in kendi metodları çağrılabilir) ❌ Yok (her metod çağrısına izin verilir)
Hatalar ne zaman ortaya çıkar? Derleme zamanında (compile-time) Çalışma zamanında (runtime)
Güvenlik seviyesi Yüksek Düşük

Bu fark kritik önemde. Object kullanırsan, hatalı bir metod çağrısını IDE'de hemen, kodu çalıştırmadan görürsün. dynamic kullanırsan, o hata ancak programı çalıştırdığında (belki de üretim ortamında, kullanıcı o kod yolunu tetiklediğinde) ortaya çıkar.

Ne Zaman Hangisi Kullanılır?

dynamic'ten mümkün olduğunca kaçın. Bu, Dart'ın ve Flutter topluluğunun neredeyse evrensel görüşüdür. dynamic kullanmak, dilin sağladığı en büyük güvenlik ağını (tip güvenliği) devre dışı bırakmak demektir.

dynamic'in meşru olduğu birkaç nadir durum:

  • JSON gibi, tipi baştan bilinmeyen, dışarıdan gelen veriyle çalışırken (geçici olarak — genelde sonra somut bir tipe/modele çevrilir, bunu Bölüm 5'te JSON serialization konusunda göreceğiz)
  • Çok düşük seviyeli, generic olmayan kütüphane kodu yazarken

Object ne zaman kullanılır? Gerçekten "bu değişken farklı tiplerde değer alabilmeli ama yine de tip güvenliğini korumak istiyorum" dediğin durumlarda. Ama pratikte bile bu durumlar azdır — genelde daha iyi bir çözüm generics'tir (Bölüm 9'da işleyeceğiz), çünkü generics hem esneklik hem de tam tip güvenliği sağlar.

Somut Bir Karşılaştırma Örneği

dart
// KÖTÜ pratik — dynamic ile
void yazdirBuyukHarf(dynamic deger) {
  print(deger.toUpperCase()); // deger int gelirse RUNTIME'da patlar
}

void main() {
  yazdirBuyukHarf("merhaba"); // çalışır
  yazdirBuyukHarf(42);        // çalışır gibi görünür ama runtime'da çöker!
}
dart
// İYİ pratik — açık tip ile
void yazdirBuyukHarf(String deger) {
  print(deger.toUpperCase());
}

void main() {
  yazdirBuyukHarf("merhaba"); // çalışır
  yazdirBuyukHarf(42);        // ❌ DERLEME ZAMANINDA hata verir, hiç çalıştırmana bile gerek kalmaz
}

İkinci yaklaşımda, hata çok daha erken (kodu yazarken, IDE üzerinde anında) yakalanıyor. Bu, "fail fast" (erken başarısız ol) prensibinin somut bir örneği — hatayı ne kadar erken yakalarsan, düzeltmesi o kadar ucuz ve kolay olur.

var vs dynamic — Son Bir Netleştirme

dart
void main() {
  var a = "Merhaba"; // statik olarak String'e sabitlenir
  a = 42; // ❌ HATA — derleme zamanında yakalanır

  dynamic b = "Merhaba"; // tip kontrolü kapalı
  b = 42; // ✅ hata vermez, çünkü dynamic her tipi kabul eder
}

Bu, iki dersi birbirine bağlayan önemli nokta: var, tip çıkarımı yapar ve sonucu sabitler (statik tiptir). dynamic ise tip kontrolünü tamamen kapatır (her an her tipe dönüşebilir). Bunlar birbirinden çok farklı araçlardır — var, güvenli ve önerilen bir kısayoldur; dynamic, bilinçli ve nadiren kullanılması gereken bir kaçış kapısıdır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ta her tip Object'ten türer (tip hiyerarşisinin köküdür).
  • Object: herhangi bir değer tutabilir ama sadece Object'in kendi metodları derleme zamanında çağrılabilir; spesifik tip metodları için as ile cast veya is ile kontrol gerekir.
  • dynamic: derleme zamanı tip kontrolünü tamamen kapatır, hatalar runtime'a ertelenir.
  • Genel kural: dynamic'ten kaçın, mümkün olduğunca somut tipler veya generics kullan.
  • var ile dynamic çok farklıdır — var tipi sabitler, dynamic tip kontrolünü kapatır.

📝 Ödevler

  • [ ] Object tipinde bir değişkene önce String, sonra int ata; her ikisinde de is kontrolü yaparak tipine özgü bir metod çağır (örn. String ise toUpperCase(), int ise abs()).
  • [ ] dynamic tipinde bir değişken tanımla, ona bilerek yanlış bir metod çağrısı yaptır (örn. bir int'e .toUpperCase() çağır), runtime hatasını oku ve yorumla.
  • [ ] Aynı işlevi gören iki fonksiyon yaz — biri dynamic parametre alsın, diğeri somut bir tip (örn. String) alsın. İkisine de yanlış tipte veri göndermeyi dene, hatanın ne zaman (derleme mi çalışma zamanı mı) ortaya çıktığını karşılaştır.
  • [ ] Object tipinde bir değişkeni as String ile cast edip, cast'in başarısız olduğu bir senaryo (örn. içi aslında int olan bir Object'i String'e cast etmeye çalışmak) yaz ve hatayı gözlemle.

Sıradaki konu: Bölüm 2 — Konu 9: Null Safety Temelleri (?, !, late'e Giriş)

9. bölüm

Bölüm 2 — Konu 9: Null Safety Temelleri (`?`, `!`, `late`'e Giriş)

Bölüm 2'nin son konusundayız — ve bu, Dart'ın en önemli özelliklerinden birine giriş: sound null safety. Bu konu, Dart'ın diğer birçok dile göre öne çıktığı en kritik noktalardan biri, o yüzden dikkatlice ilerleyelim.

"Null Reference" Sorunu Nedir?

Programlamanın en yaygın hatalarından biri, olmayan (null) bir değer üzerinde işlem yapmaya çalışmaktır. Java, JavaScript gibi birçok dilde şuna benzer bir hata sıkça karşına çıkar:

metin
NullPointerException: Cannot invoke method on null object

Bu hatalar genelde çalışma zamanında, hiç beklenmedik bir anda (genelde üretimde, kullanıcı karşısında) ortaya çıkar. Bu o kadar yaygın bir problemdir ki, bunu icat eden bilgisayar bilimci Tony Hoare bunu "bir milyar dolarlık hatam" olarak tanımlamıştır.

Dart, 2.12 sürümünden itibaren (2021) bu problemi derleme zamanında çözen bir sistem getirdi: sound null safety.

Varsayılan Olarak Hiçbir Şey Null Olamaz

Dart'ta, null safety ile birlikte, bir değişken varsayılan olarak null değer alamaz:

dart
void main() {
  String isim = "Ahmet";
  isim = null; // ❌ HATA! String tipi null kabul etmez
}

Bu kod derlenmez. String isim yazdığında, Dart bunu "bu değişken kesinlikle bir String tutacak, asla null olmayacak" olarak yorumlar. Bu, birçok hatayı daha kod çalışmadan yakalamanı sağlar.

? — Bir Tipin Null Olabileceğini Belirtmek

Eğer gerçekten bir değişkenin null olabilmesini istiyorsan, tipin sonuna ? eklersin:

dart
void main() {
  String? isim = "Ahmet"; // isim, String VEYA null olabilir
  isim = null; // ✅ şimdi geçerli
  print(isim); // null
}

String? ile String birbirinden tamamen farklı tiplerdir aslında — String?, "ya String ya da null" anlamına gelir. Bu, Dart'ın tip sisteminde Null tipinin de Object? hiyerarşisine dahil edilmesiyle mümkün olur (bir önceki derste gördüğümüz tip ağacını hatırla).

Nullable Bir Değişkenle Çalışırken Dikkat Edilmesi Gerekenler

dart
void main() {
  String? isim = "Ahmet";
  print(isim.length); // ❌ HATA! isim null olabilir, doğrudan .length çağıramazsın
}

Dart, isim değişkeninin potansiyel olarak null olabileceğini bildiği için, üzerinde doğrudan metod/özellik çağırmana izin vermez — çünkü eğer gerçekten null olsaydı, bu çalışma zamanında çökerdi. Dart bunu, çalışmadan önce sana bildiriyor.

Bunu güvenli şekilde kullanmanın birkaç yolu var:

1. Null kontrolü (if) ile

dart
void main() {
  String? isim = "Ahmet";

  if (isim != null) {
    print(isim.length); // ✅ artık isim, bu blok içinde String (null değil) olarak biliniyor
  }
}

Bu, Dart'ın type promotion (tip daraltma) özelliğidir — if (isim != null) kontrolünden sonra, o blok içinde Dart, isim'in artık kesinlikle String (null olmayan) olduğunu bilir.

2. ?. — Null-aware erişim operatörü

dart
void main() {
  String? isim = "Ahmet";
  print(isim?.length); // isim null değilse .length'i çağırır, null ise sonucu null olur

  isim = null;
  print(isim?.length); // null — hata vermez, sadece null döner
}

?., "eğer bu değer null değilse şu işlemi yap, null ise tüm ifadeyi null olarak değerlendir" anlamına gelir. Bu, çok satırlı if kontrolleri yazmak yerine tek satırda güvenli erişim sağlar.

3. ?? — Varsayılan değer belirleme

dart
void main() {
  String? isim;
  print(isim ?? "İsimsiz"); // isim null olduğu için "İsimsiz" yazdırılır

  isim = "Ahmet";
  print(isim ?? "İsimsiz"); // isim null değil, "Ahmet" yazdırılır
}

??, sol taraftaki değer null ise sağ taraftaki değeri kullanır. Bu, bir önceki dersimizde (Bölüm 3'te göreceğiz aslında, burada önizleme) operatörler konusunda daha detaylı işlenecek ama null safety ile doğrudan bağlantılı olduğu için burada da bahsetmek gerekiyordu.

4. ! — "Bana Güven, Bu Null Değil" (Null Assertion)

dart
void main() {
  String? isim = "Ahmet";
  print(isim!.length); // "isim'in null olmadığından eminim" diyorsun
}

! operatörü (null assertion / bang operator), Dart'a "bu değerin null olmadığından eminim, kontrolü atla" demektir. Bu tehlikeli bir operatördür — eğer yanılıyorsan (değer gerçekten null ise), program çalışma zamanında çöker:

dart
void main() {
  String? isim;
  print(isim!.length); // ❌ RUNTIME HATASI! isim gerçekten null, ! seni kurtaramaz
}

Genel kural: ! operatöründen mümkün olduğunca kaçın. Bunu kullanmak, aslında null safety'nin sana sağladığı güvenlik ağını manuel olarak devre dışı bırakmak demektir. ! kullanman gerektiğini düşündüğün her yerde, önce "gerçekten bu değerin null olamayacağından %100 emin miyim, yoksa ?. veya ?? ile daha güvenli bir yol var mı" diye sor.

late — "Şimdi Değil Ama Kesinlikle Sonra Atanacak"

Bazen bir değişkeni tanımladığın anda değer atayamazsın, ama yine de o değişkenin non-nullable (null olmayan) bir tip olmasını istersin. İşte late burada devreye girer:

dart
class Kullanici {
  late String isim; // şimdi değer yok ama String (null değil) olacak

  void ismiAyarla(String yeniIsim) {
    isim = yeniIsim;
  }
}

late ile işaretlenen bir değişken, tanımlandığı anda değer almak zorunda değildir, ama kullanılmadan önce mutlaka bir değer atanmış olmalıdır. Eğer değer atanmadan kullanmaya çalışırsan:

dart
void main() {
  late String mesaj;
  print(mesaj); // ❌ RUNTIME HATASI! mesaj hiç atanmadı
}

Bu hata alınır: LateInitializationError.

late'in gerçek kullanım senaryolarını (özellikle sınıflarda constructor ile ilişkili kullanımını) Bölüm 6'da sınıflar konusuna geldiğimizde çok daha net göreceğiz — çünkü late'in en yaygın kullanım alanı, bir sınıfın alanının constructor'da değil, başka bir metodda (örneğin initState benzeri bir yerde, Flutter'da sıkça karşına çıkacak) atanmasıdır.

Özet Tablo — Null Safety Araçları

Araç Ne Yapar Risk Seviyesi
Tip? Değişkenin null olabileceğini belirtir Güvenli — açık ve dürüst
if (x != null) Null kontrolü yapar, type promotion sağlar Çok güvenli
?. Null ise işlemi atlar, sonucu null yapar Güvenli
?? Null ise varsayılan değer kullanır Güvenli
! "Null değil" diye zorla kabul ettirir ⚠️ Riskli — dikkatli kullan
late Geç atamaya izin verir ama non-nullable kalır Kullanım yerine göre değişir

Neden Bu Kadar Önemli?

Bu konuyu bu kadar detaylı işlememizin sebebi şu: null safety, Dart'ın günlük yazdığın hemen hemen her satırını etkiler. Flutter'da her widget, her API cevabı, her kullanıcı girdisi bu sistemle iç içe çalışacak. Bu temeli şimdi sağlam kurmak, ileride "neden bu hata çıkıyor" diye saatlerce debug etmeni engelleyecek.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ta varsayılan olarak hiçbir tip null olamaz; nullable yapmak için tipin sonuna ? eklenir.
  • ?.: null-aware erişim, null ise işlemi atlar.
  • ??: null ise varsayılan değer sağlar.
  • !: "bu null değil" diye zorlar — riskli, dikkatli kullanılmalı.
  • late: değişkeni hemen atamadan tanımlamana izin verir ama kullanılmadan önce mutlaka atanmış olmalıdır.

📝 Ödevler

  • [ ] Nullable bir String? değişken tanımla, if (x != null) ile kontrol ederek güvenli şekilde .length özelliğine eriş.
  • [ ] Aynı işlemi ?. operatörüyle tekrar yaz, iki yaklaşımı karşılaştır.
  • [ ] ?? operatörünü kullanarak, null olan bir kullanıcı adı yerine "Misafir" yazdıran bir örnek yaz.
  • [ ] ! operatörünü bilerek yanlış kullanarak (gerçekten null olan bir değişkende) bir RuntimeError oluştur, hatayı oku ve yorumla.
  • [ ] late ile bir değişken tanımla, değer atamadan önce kullanmayı dene, LateInitializationError hatasını gözlemle; sonra değer atayıp düzelt.

🏁 Bölüm 2 Tamamlandı!

Artık değişken tanımlama yollarını (var/final/const), temel tipleri, tip çıkarımını, dynamic/Object farkını ve null safety temellerini biliyorsun. Bu, Dart'ın en kritik temel taşlarıydı.

Sıradaki durak Bölüm 3 — Operatörler & Kontrol Akışı: aritmetik/mantıksal operatörler, if/else, switch, döngüler ile devam edeceğiz — burada gerçek anlamda "mantık kurmaya" başlayacağız.

10. bölüm

Bölüm 3 — Konu 10: Aritmetik, Atama, Karşılaştırma, Mantıksal Operatörler

Bölüm 3'e hoş geldin — bu bölümde gerçek anlamda "mantık kurmaya" başlıyoruz. İlk durağımız, tüm kontrol akışının (if, döngüler vb.) temelini oluşturan operatörler.

1. Aritmetik Operatörler

dart
void main() {
  int a = 10;
  int b = 3;

  print(a + b);  // 13 — toplama
  print(a - b);  // 7  — çıkarma
  print(a * b);  // 30 — çarpma
  print(a / b);  // 3.3333333333333335 — bölme, HER ZAMAN double döner
  print(a ~/ b); // 3  — tam sayı bölmesi (integer division)
  print(a % b);  // 1  — mod (kalan)
}

Bölüm 2'de ~/ ve %'e kısaca değinmiştik, burada pekiştirelim:

dart
void main() {
  print(17 ~/ 5); // 3 — 17'nin 5'e tam bölümü
  print(17 % 5);  // 2 — kalan

  // Doğrulama: (bölüm * bölen) + kalan = orijinal sayı
  print((3 * 5) + 2); // 17 ✓
}

Artırma/Azaltma operatörleri:

dart
void main() {
  int sayac = 5;

  sayac++; // sayac = sayac + 1
  print(sayac); // 6

  sayac--; // sayac = sayac - 1
  print(sayac); // 5

  print(sayac++); // 5 yazdırır, SONRA artırır (post-increment)
  print(sayac);   // 6

  print(++sayac); // ÖNCE artırır, SONRA 7 yazdırır (pre-increment)
  print(sayac);   // 7
}

Bu ++x ile x++ farkı sık karıştırılır: x++ önce mevcut değeri kullanır, sonra artırır. ++x önce artırır, sonra yeni değeri kullanır.

2. Bileşik Atama Operatörleri (Compound Assignment)

dart
void main() {
  int puan = 100;

  puan += 10; // puan = puan + 10
  print(puan); // 110

  puan -= 20; // puan = puan - 20
  print(puan); // 90

  puan *= 2;  // puan = puan * 2
  print(puan); // 180

  puan ~/= 3; // puan = puan ~/ 3
  print(puan); // 60
}

Bunlar, puan = puan + 10 yazmanın kısayoludur — Dart'a özgü değil, C ailesindeki hemen her dilde bulunur.

3. Karşılaştırma Operatörleri

dart
void main() {
  int a = 10;
  int b = 20;

  print(a == b); // false — eşit mi?
  print(a != b); // true  — eşit değil mi?
  print(a < b);  // true  — küçük mü?
  print(a > b);  // false — büyük mü?
  print(a <= b); // true  — küçük veya eşit mi?
  print(a >= b); // false — büyük veya eşit mi?
}

Bunların hepsi bir bool sonuç döndürür — bu yüzden genelde if koşullarında kullanılırlar (bir sonraki konuda işleyeceğiz).

Önemli detay — == ile nesne karşılaştırması:

dart
void main() {
  String isim1 = "Ahmet";
  String isim2 = "Ahmet";
  print(isim1 == isim2); // true — içerik karşılaştırılır
}

Dart'ta == operatörü, ilkel tipler (int, double, String, bool) için içerik karşılaştırması yapar (Java'daki gibi referans karşılaştırması değil). Kendi yazacağın sınıflar için bu davranışı özelleştirebilirsin — bunu Bölüm 6'da göreceğiz.

4. Mantıksal Operatörler

dart
void main() {
  bool ogrenciMi = true;
  bool calisiyorMu = false;

  print(ogrenciMi && calisiyorMu); // false — VE (AND): ikisi de true olmalı
  print(ogrenciMi || calisiyorMu); // true  — VEYA (OR): en az biri true olmalı
  print(!ogrenciMi);               // false — DEĞİL (NOT): tersini alır
}

Kısa devre değerlendirmesi (Short-circuit evaluation):

dart
bool pahaliIslem() {
  print("pahaliIslem çağrıldı");
  return true;
}

void main() {
  bool sonuc = false && pahaliIslem();
  // "pahaliIslem çağrıldı" YAZDIRILMAZ!
  // Çünkü && operatöründe sol taraf false ise, sağ taraf hiç değerlendirilmez

  print(sonuc); // false
}

Bu davranış önemli bir performans/mantık aracıdır: && operatöründe sol taraf false ise, Dart sağ tarafı hiç çalıştırmaz (çünkü sonucun zaten false olacağı belli). Benzer şekilde || operatöründe sol taraf true ise sağ taraf çalıştırılmaz.

Bu, null kontrolü gibi durumlarda pratik bir kullanım sağlar:

dart
void main() {
  String? isim;

  if (isim != null && isim.length > 3) {
    print("Uzun isim");
  } else {
    print("Kısa isim veya null");
  }
}

isim != null false ise, isim.length > 3 kısmı hiç çalıştırılmaz — bu sayede isim null olsa bile hata almayız (eğer sıra tersine çevrilseydi, yani isim.length > 3 && isim != null yazsaydık, null olduğunda önce .length'e erişmeye çalışırdı ve hata verirdi).

5. Operatör Önceliği (Precedence)

Matematikte olduğu gibi, Dart'ta da operatörlerin bir öncelik sırası vardır:

dart
void main() {
  int sonuc = 2 + 3 * 4; // çarpma önce yapılır
  print(sonuc); // 14, (2 + (3*4)) — 20 değil!

  int sonuc2 = (2 + 3) * 4; // parantez önceliği değiştirir
  print(sonuc2); // 20
}

Genel öncelik sırası (yüksekten düşüğe, basitleştirilmiş):

  1. () parantezler
  2. !, ++, -- (unary operatörler)
  3. *, /, ~/, %
  4. +, -
  5. <, >, <=, >=
  6. ==, !=
  7. &&
  8. ||
  9. ??
  10. =, +=, -= vb. (atama operatörleri)

Pratik tavsiye: Öncelik sırasını ezbere bilmek yerine, karmaşık ifadelerde her zaman parantez kullan. Bu hem hatayı önler hem de kodu okuyan başka birinin niyetini yanlış anlamasını engeller:

dart
// Belirsiz — önceliği bilmeyen biri yanlış anlayabilir
bool sonuc = a && b || c;

// Net — parantez ile niyet açık
bool sonuc2 = (a && b) || c;

6. is ve is! — Tip Kontrolü Operatörleri

Bölüm 2'de kısaca gördüğümüz is operatörünü burada tam bir mantıksal operatör olarak da hatırlayalım:

dart
void main() {
  Object deger = "Merhaba";

  print(deger is String);  // true
  print(deger is! String); // false — "değil" versiyonu
  print(deger is int);     // false
}

🎯 Bu Dersten Çıkarılması Gerekenler

  • Aritmetik: + - * / ~/ %, ~/ tam sayı bölmesi yapar, / her zaman double döner.
  • x++ mevcut değeri kullanıp sonra artırır, ++x önce artırıp yeni değeri kullanır.
  • Bileşik atama: += -= *= ~/= gibi kısayollar.
  • Karşılaştırma: == != < > <= >=, hepsi bool döner.
  • Mantıksal: && || !, kısa devre değerlendirmesi önemli bir davranıştır (null kontrollerinde kritik).
  • Operatör önceliği matematikteki gibi işler — belirsiz durumlarda parantez kullan.

📝 Ödevler

  • [ ] İki sayı al (elle tanımla), tüm aritmetik operatörleri (+ - * / ~/ %) uygulayıp sonuçlarını yazdır.
  • [ ] x++ ile ++x arasındaki farkı gösteren, aynı değişkeni her ikisiyle de kullanan bir örnek yaz.
  • [ ] Kısa devre değerlendirmesini kanıtlayan bir örnek yaz: false && pahaliBirFonksiyon() çağrısında fonksiyonun hiç çalışmadığını print ile göster.
  • [ ] Nullable bir değişkenle güvenli bir && zinciri kur (örn. isim != null && isim.length > 5), sırayı bilerek tersine çevirip hatayı gözlemle.
  • [ ] Parantezsiz ve parantezli iki versiyonunu yazdığın bir ifadeyle (2 + 3 * 4 gibi) operatör önceliğinin sonucu nasıl değiştirdiğini göster.

Sıradaki konu: Bölüm 3 — Konu 11: if / else if / else

11. bölüm

Bölüm 3 — Konu 11: `if / else if / else`

Temel if Yapısı

dart
void main() {
  int yas = 20;

  if (yas >= 18) {
    print("Reşitsin");
  }
}

if, parantez içindeki ifade true ise süslü parantez içindeki bloğu çalıştırır. İfade false ise, blok tamamen atlanır.

Önemli: Dart'ta if'in parantezi içindeki ifade kesinlikle bool tipinde olmalıdır. Bölüm 2'de değindiğimiz gibi, 0 veya boş string gibi değerler otomatik olarak false'a çevrilmez:

dart
void main() {
  int sayi = 0;
  if (sayi) { // ❌ HATA! int, bool bekleyen yere konulamaz
    print("Çalışmaz");
  }

  if (sayi == 0) { // ✅ doğrusu — gerçek bir bool ifade
    print("Sayı sıfır");
  }
}

else — Alternatif Durum

dart
void main() {
  int yas = 15;

  if (yas >= 18) {
    print("Reşitsin");
  } else {
    print("Reşit değilsin");
  }
}

else if — Birden Fazla Koşul Zinciri

dart
void main() {
  int not = 75;

  if (not >= 90) {
    print("AA");
  } else if (not >= 80) {
    print("BA");
  } else if (not >= 70) {
    print("BB");
  } else if (not >= 60) {
    print("CB");
  } else {
    print("FF");
  }
}

Nasıl çalışır: Dart, koşulları yukarıdan aşağıya sırayla kontrol eder. İlk true olan koşulun bloğu çalıştırılır ve geri kalan koşullar hiç kontrol edilmez — bu önemli bir detay.

dart
void main() {
  int not = 95;

  if (not >= 90) {
    print("AA"); // Bu çalışır
  } else if (not >= 60) {
    print("Geçti"); // 95 >= 60 de true olduğu halde bu ASLA çalışmaz
  }
}

Bu yüzden else if zincirlerinde koşulları doğru sırada yazmak kritik önemdedir. Yukarıdaki örnekte eğer sıralamayı ters yapsaydın (>= 60 önce gelseydi), 95 puan alan biri hep "Geçti" yazardı, hiçbir zaman "AA"ya ulaşamazdı.

İç İçe (Nested) if Yapıları

dart
void main() {
  bool girisYapildiMi = true;
  int yas = 16;

  if (girisYapildiMi) {
    if (yas >= 18) {
      print("İçeriğe erişebilirsin");
    } else {
      print("Yaş sınırından dolayı erişemezsin");
    }
  } else {
    print("Önce giriş yapmalısın");
  }
}

İç içe if'ler bazen gereklidir ama okunabilirliği hızla düşürür. Genelde, mantıksal operatörlerle (bir önceki derste gördüğümüz &&) birleştirmek daha temiz olur:

dart
void main() {
  bool girisYapildiMi = true;
  int yas = 16;

  if (girisYapildiMi && yas >= 18) {
    print("İçeriğe erişebilirsin");
  } else if (!girisYapildiMi) {
    print("Önce giriş yapmalısın");
  } else {
    print("Yaş sınırından dolayı erişemezsin");
  }
}

Bu iki yaklaşım da geçerlidir; hangisinin daha okunabilir olduğu duruma göre değişir. Genel tavsiye: 2-3 seviyeden fazla iç içe geçen if yapıları görürsen, bunu ayrı bir fonksiyona bölmeyi veya mantığı basitleştirmeyi düşün (bu, "erken dönüş" / early return prensibiyle ilgili, birazdan göreceğiz).

Tek Satırlık if (Süslü Parantezsiz) — Önerilmez

dart
void main() {
  int yas = 20;
  if (yas >= 18) print("Reşitsin"); // süslü parantez olmadan da çalışır
}

Bu geçerli bir sözdizimidir ama önerilmez, çünkü ileride bloğa ikinci bir satır eklemek istediğinde kolayca hataya yol açabilir:

dart
void main() {
  int yas = 15;
  if (yas >= 18) 
    print("Reşitsin");
    print("Bu satır HER ZAMAN çalışır!"); // ❌ if bloğuna dahil değil, yanıltıcı görünüyor
}

Girinti seni yanıltabilir — ikinci print satırı görsel olarak if bloğunun içindeymiş gibi dursa da, süslü parantez olmadığı için aslında if'e dahil değildir, her zaman çalışır. Bu yüzden her zaman süslü parantez kullanmak en güvenli pratiktir.

Ternary Operatör'e Küçük Bir Önizleme

Bir sonraki konuda detaylı işleyeceğiz ama basit if/else durumlarının kısa bir alternatifi olduğunu bilmen faydalı:

dart
void main() {
  int yas = 20;

  // Uzun hali:
  String durum;
  if (yas >= 18) {
    durum = "Reşit";
  } else {
    durum = "Reşit değil";
  }

  // Kısa hali (ternary) — bir sonraki derste detaylandıracağız:
  String durum2 = yas >= 18 ? "Reşit" : "Reşit değil";

  print(durum2);
}

Erken Dönüş (Early Return) Prensibi — Önemli Bir Pratik

Fonksiyonları henüz detaylı işlemedik (Bölüm 5'te göreceğiz) ama bu prensip if yapılarıyla o kadar yakından ilişkili ki, şimdiden bir örnek görmek faydalı:

dart
String yasKontrolEt(int yas) {
  // Kötü pratik — gereksiz iç içe geçme
  String sonuc;
  if (yas >= 0) {
    if (yas < 18) {
      sonuc = "Çocuk";
    } else {
      sonuc = "Yetişkin";
    }
  } else {
    sonuc = "Geçersiz yaş";
  }
  return sonuc;
}

String yasKontrolEtV2(int yas) {
  // İyi pratik — erken dönüş, iç içe geçme yok
  if (yas < 0) return "Geçersiz yaş";
  if (yas < 18) return "Çocuk";
  return "Yetişkin";
}

İkinci yaklaşım (yasKontrolEtV2), "geçersiz/istisnai durumları en başta ele al ve fonksiyondan çık, ana mantığı en sonda ve iç içe geçmeden bırak" prensibini gösteriyor. Bu, kodun okunabilirliğini ciddi şekilde artırır — Flutter'da widget build metodlarında bu deseni çok sık göreceksin.


🎯 Bu Dersten Çıkarılması Gerekenler

  • if koşulu kesinlikle bool olmalı, Dart örtük dönüşüm yapmaz.
  • else if zincirlerinde koşullar yukarıdan aşağıya sırayla kontrol edilir, ilk true olan çalışır, gerisi atlanır — sıralama önemlidir.
  • İç içe if yapıları yerine mümkün olduğunca &&/|| ile birleştirmek veya erken dönüş kullanmak okunabilirliği artırır.
  • Süslü parantezsiz tek satırlık if teknik olarak çalışır ama hataya açıktır, önerilmez.

📝 Ödevler

  • [ ] Bir notu (0-100) alıp AA/BA/BB/CB/FF harf notuna çeviren bir else if zinciri yaz; koşulları bilerek yanlış sırada yazıp (küçükten büyüğe) sonucun nasıl bozulduğunu gözlemle, sonra düzelt.
  • [ ] Üç değişken (giriş yapıldı mı, yaş, üyelik aktif mi) alıp iç içe if ile bir erişim kontrolü yaz; sonra aynı mantığı &&/|| kullanarak iç içe geçmeden tekrar yaz.
  • [ ] Bir sayının pozitif, negatif veya sıfır olduğunu "erken dönüş" prensibiyle (iç içe if kullanmadan) belirleyen bir fonksiyon yaz.
  • [ ] Süslü parantezsiz bir if yazıp altına bilerek ikinci bir satır ekle, bu satırın if koşulundan bağımsız her zaman çalıştığını göster.

Sıradaki konu: Bölüm 3 — Konu 12: switch / switch expression (Modern Dart)

12. bölüm

Bölüm 3 — Konu 12: `switch` / `switch expression` (Modern Dart)

Neden switch Var? if/else if Yetmiyor mu?

Teknik olarak her switch bir if/else if zinciriyle de yazılabilir. Ama tek bir değeri birden çok sabit değerle karşılaştıracağın durumlarda switch, hem daha okunabilir hem de (Dart 3 ile) derleyicinin eksik durumları sana haber vermesini sağlayan bir yapıdır.

Klasik switch İfadesi (Statement)

dart
void main() {
  String gun = "Pazartesi";

  switch (gun) {
    case "Pazartesi":
      print("Haftanın ilk günü");
      break;
    case "Cumartesi":
    case "Pazar":
      print("Haftasonu");
      break;
    default:
      print("Normal bir gün");
  }
}

Yapıyı parçalayalım:

  • switch (gun) — karşılaştırılacak değeri belirtir.
  • case "Pazartesi": — değer bu case ile eşleşirse, altındaki kod çalışır.
  • break; — bu case'in bittiğini belirtir.
  • case "Cumartesi": case "Pazar": — birden fazla case, aralarında hiç kod olmadan art arda yazılırsa, aynı bloğu paylaşırlar (bu case'lerden herhangi biri eşleşirse aynı kod çalışır). Bu, aşağıda anlatılacak fall-through kuralının tek istisnasıdır.
  • default: — hiçbir case eşleşmezse çalışacak yedek blok (else gibi düşünebilirsin).

break Neden Zorunlu? Dart'ta Fall-Through Aslında Yok

C, Java veya JavaScript gibi dillere aşinaysan muhtemelen "fall-through" kavramını biliyorsundur: o dillerde bir case'in sonuna break koymazsan kontrol sessizce bir sonraki case'e "düşer" ve bu sık karşılaşılan bir hata kaynağıdır.

Dart bu davranışı baştan itibaren (bu bir Dart 3 değişikliği değil) engeller. Dart'ta, içinde kod bulunan (boş olmayan) bir case bloğu, break, continue, return veya throw gibi bir "çıkış" ifadesi olmadan bitiyorsa, bu bir derleme zamanı hatasıdır — kod hiç çalışmaz, hiç derlenmez. Yani aşağıdaki kod:

dart
void main() {
  int sayi = 1;

  switch (sayi) {
    case 1:
      print("Bir");
      // break yok!
    case 2:
      print("İki");
      break;
    default:
      print("Diğer");
  }
}

derlenmez. Dart analizörü şuna benzer bir hata verir:

metin
Error: The 'case' should end with a statement like 'break', 'continue', 'return' or 'throw'.
Try adding one of the statements before the next 'case'.

Yani "önce yanlışlıkla iki satır yazdırılır, sonra derleyici bunu fark edip uyarır" gibi bir şey olmuyor — kod derlenme aşamasında reddediliyor, hiç çalışma şansı bulamıyor. Bu, Dart'ın C/Java tarzı dillerin en klasik hata kaynaklarından birini tasarım gereği ortadan kaldırdığı anlamına gelir: unutulan bir break senin projende sessiz bir bug olarak değil, derleyicinin anında durdurduğu bir hata olarak karşına çıkar.

Peki hiç fall-through yapamaz mısın? Yapabilirsin — ama bunun için kasıtlı ve açık olman gerekir. Dart, continue anahtar kelimesini bir case etiketiyle birlikte kullanmana izin verir:

dart
void main() {
  int sayi = 1;

  switch (sayi) {
    case 1:
      print("Bir");
      continue iki; // açıkça "case iki'ye devam et" diyoruz
    iki:
    case 2:
      print("İki");
      break;
    default:
      print("Diğer");
  }
}

Çıktı:

metin
Bir
İki

Burada iki: bir etiket (label), case 2'nin hemen üstüne konmuş. continue iki; ifadesi derleyiciye "buradan case 2'ye bilerek geçiyorum, bu bir hata değil" diyor. Bu özellik nadiren kullanılır ama var olduğunu bilmen yeterli — pratikte çoğu zaman aynı işi case "Cumartesi": case "Pazar": örneğindeki gibi boş case birleştirme ile ya da fonksiyona çıkarma ile daha okunabilir şekilde çözersin.

Dart 3 — switch Expression (İfade Olarak Switch)

Dart 3 ile gelen en kullanışlı yeniliklerden biri: switch'i bir ifade (expression) olarak kullanabilmek, yani doğrudan bir değer üretip değişkene atayabilmek:

dart
void main() {
  String gun = "Pazartesi";

  String mesaj = switch (gun) {
    "Pazartesi" => "Haftanın ilk günü",
    "Cumartesi" || "Pazar" => "Haftasonu",
    _ => "Normal bir gün",
  };

  print(mesaj);
}

Klasik switch statement ile farkları:

  • case kelimesi yok, doğrudan değer yazılır.
  • : yerine => kullanılır (arrow function'a benzer sözdizimi).
  • break gerekmez — her kol zaten tek bir değer üretir, fall-through riski yoktur.
  • Birden fazla değer için || kullanılır (case "Cumartesi": case "Pazar": yerine "Cumartesi" || "Pazar" =>).
  • default yerine _ (alt çizgi, "her şeyi eşleştir" anlamında) kullanılır.
  • Sonunda virgülle biten her kol, bir sonraki koldan virgülle ayrılır.

Bu yeni sözdizimi, özellikle bir değer üretmek istediğinde (klasik switch'te olduğu gibi ayrı bir değişken tanımlayıp her case'de ona atama yapmak yerine) çok daha temiz bir kod sağlar.

Karşılaştırma — Ne Zaman Hangisi?

dart
// Klasik switch statement — YAN ETKİ üretmek için (print, API çağrısı vb.)
void gunBilgisiYazdir(String gun) {
  switch (gun) {
    case "Pazartesi":
      print("Toplantı günü");
      break;
    default:
      print("Normal gün");
  }
}

// switch expression — DEĞER üretmek için
String gunTipi(String gun) {
  return switch (gun) {
    "Cumartesi" || "Pazar" => "Haftasonu",
    _ => "Haftaiçi",
  };
}

Genel kural: Eğer amacın bir değer üretip döndürmek ise (fonksiyondan return etmek, bir değişkene atamak), switch expression kullan — daha kısa ve güvenlidir. Eğer amacın birkaç farklı yan etki (side effect — print, API çağrısı, state değiştirme vb.) tetiklemekse, klasik switch statement daha uygun olabilir.

Exhaustiveness (Kapsayıcılık) Kontrolü — Enum'larla Küçük Bir Önizleme

Enum'ları henüz detaylı işlemedik (Bölüm 7'de göreceğiz) ama switch'in en güçlü yanlarından biri, enum'larla kullanıldığında ortaya çıkıyor:

dart
enum TrafikIsigi { kirmizi, sari, yesil }

String eylemBelirle(TrafikIsigi isik) {
  return switch (isik) {
    TrafikIsigi.kirmizi => "Dur",
    TrafikIsigi.sari => "Hazırlan",
    TrafikIsigi.yesil => "Geç",
  };
}

Burada default (_) yazmadık — ve Dart buna izin veriyor çünkü TrafikIsigi enum'unun tüm olası değerlerini (kirmizi, sari, yesil) kapsadık. Eğer enum'a yeni bir değer eklenirse (örneğin TrafikIsigi.turuncu), Dart derleyicisi bu switch ifadesinin artık eksik (non-exhaustive) olduğunu sana derleme zamanında söyler — böylece unutkanlıktan kaynaklanan hataları baştan önler. Bu özelliği Dart 3'ün sealed class yapılarıyla birlikte Bölüm 13'te çok daha derinlemesine işleyeceğiz; bu sadece bir önizlemeydi.

Sayılarla switch Kullanımı

dart
void main() {
  int puan = 85;

  String harfNotu = switch (puan) {
    >= 90 => "AA",
    >= 80 => "BA",
    >= 70 => "BB",
    >= 60 => "CB",
    _ => "FF",
  };

  print(harfNotu); // BA
}

Dikkat et — burada case değerleri artık sabit değil, >= 90 gibi bir karşılaştırma ifadesi. Bu da Dart 3'ün switch expression'a kazandırdığı güçlü bir özellik (pattern matching'in bir parçası) — klasik switch statement'ta bu mümkün değildi, sadece sabit değerlerle eşleştirme yapılabilirdi.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Klasik switch statement: içinde kod olan her case, break (veya continue/return/throw) ile bitmek zorundadır — bunu atlamak Dart'ta çalışma zamanı hatası değil, derleme zamanı hatasıdır. Bu, Dart 3'e özgü değil, dilin en başından beri var olan bir kuraldır.
  • Sessiz fall-through Dart'ta yoktur; kasıtlı fall-through istersen continue etiketliCase; sözdizimini açıkça kullanman gerekir.
  • Art arda gelen tamamen boş case'ler (case "Cumartesi": case "Pazar":) aynı bloğu paylaşabilir — bu fall-through değil, birden fazla case'i tek bir sonuca bağlamanın kasıtlı bir yoludur.
  • Dart 3 switch expression: => ile değer üretir, _ ile varsayılan durum, || ile çoklu eşleşme.
  • Değer üretmek için switch expression, yan etki tetiklemek için klasik switch statement tercih edilir.
  • Enum'larla kullanıldığında, tüm değerler kapsandığında default gerekmez ve derleyici eksik durumları yakalar (exhaustiveness).
  • switch expression'da karşılaştırma ifadeleri (>= 90 gibi) de kullanılabilir.

📝 Ödevler

  • [ ] Bir haftanın günlerini ("Pazartesi"'den "Pazar"'a) alıp haftaiçi/haftasonu ayrımı yapan hem klasik switch statement hem de switch expression versiyonunu yaz, ikisini karşılaştır.
  • [ ] Bilerek bir case'in sonuna break koymadan derlemeyi dene ve derleyicinin sana verdiği hata mesajını oku — ardından continue etiketliCase; sözdizimiyle kasıtlı bir fall-through örneği yaz.
  • [ ] Bir notu (0-100) alıp harf notuna çeviren switch expression'ı, karşılaştırma ifadeleriyle (>= 90 gibi) yaz.
  • [ ] Basit bir enum (örn. mevsimler: ilkbahar, yaz, sonbahar, kis) tanımla, her mevsim için bir mesaj döndüren exhaustive bir switch expression yaz — default kullanmadan.

Sıradaki konu: Bölüm 3 — Konu 13: Ternary Operatör, ??, ??=, ?.

13. bölüm

Bölüm 3 — Konu 13: Ternary Operatör, `??`, `??=`, `?.`

Bu derste, daha önce bazılarına kısaca değindiğimiz operatörleri toparlayıp derinlemesine işleyeceğiz — bunlar Dart kodunda gerçekten çok sık karşına çıkacak, o yüzden rahat kullanabilmen önemli.

Ternary Operatör (? :) — Koşullu İfade

Bölüm 3 Konu 11'de kısaca önizlemesini görmüştük, şimdi tam olarak işleyelim:

dart
void main() {
  int yas = 20;

  String durum = yas >= 18 ? "Reşit" : "Reşit değil";
  print(durum); // Reşit
}

Sözdizimi: koşul ? koşulTrueİseDeğer : koşulFalseİseDeğer

Bu, kısa if/else'in yerine geçer — ama sadece bir değer üretmek istediğinde kullanılır, yan etki (print, fonksiyon çağrısı vb.) için değil (teknik olarak mümkün ama önerilmez, birazdan göreceğiz).

İç içe ternary — dikkatli kullanılmalı:

dart
void main() {
  int not = 75;

  String harfNotu = not >= 90 
      ? "AA" 
      : not >= 80 
          ? "BA" 
          : not >= 70 
              ? "BB" 
              : "FF";

  print(harfNotu); // BB
}

Bu çalışır ama okunabilirliği hızla düşer. Genel kural: ternary'yi tek seviyede tut. Birden fazla koşul zincirlemen gerekiyorsa, bir önceki derste gördüğümüz switch expression çok daha okunabilir bir alternatiftir:

dart
void main() {
  int not = 75;

  String harfNotu = switch (not) {
    >= 90 => "AA",
    >= 80 => "BA",
    >= 70 => "BB",
    _ => "FF",
  };

  print(harfNotu); // BB
}

Ternary'yi yan etki için kullanmak — kaçınılması gereken bir pratik:

dart
void main() {
  bool girisYapildi = true;

  // ❌ Kötü pratik — ternary bir değer üretmiyor, sadece yan etki tetikliyor
  girisYapildi ? print("Hoş geldin") : print("Lütfen giriş yapın");

  // ✅ Doğrusu — yan etki için if/else kullan
  if (girisYapildi) {
    print("Hoş geldin");
  } else {
    print("Lütfen giriş yapın");
  }
}

İlk örnek teknik olarak çalışır ama ternary'nin amacı bu değil — bu kullanım, kodu okuyanları yanıltabilir ("bu bir değer mi üretiyor, yoksa sadece yan etki mi?" sorusunu akla getirir).

?? — Null Coalescing (Null Birleştirme) Operatörü

Bölüm 2'de null safety konusunda görmüştük, burada pekiştirelim:

dart
void main() {
  String? takmaAd;
  String gercekAd = "Ahmet";

  String gosterilecekAd = takmaAd ?? gercekAd;
  print(gosterilecekAd); // Ahmet — çünkü takmaAd null

  takmaAd = "Ahi";
  String gosterilecekAd2 = takmaAd ?? gercekAd;
  print(gosterilecekAd2); // Ahi — artık takmaAd null değil
}

Sözdizimi: solTaraf ?? sağTaraf → sol taraf null değilse sol tarafı, null ise sağ tarafı kullanır.

Zincirleme kullanım:

dart
void main() {
  String? a;
  String? b;
  String c = "Varsayılan";

  String sonuc = a ?? b ?? c;
  print(sonuc); // Varsayılan — hem a hem b null, sırayla kontrol edilip sonunda c kullanılır
}

??= — Null İse Ata (Null-Aware Assignment)

dart
void main() {
  String? kullaniciAdi;

  kullaniciAdi ??= "Misafir"; // kullaniciAdi null olduğu için "Misafir" atanır
  print(kullaniciAdi); // Misafir

  kullaniciAdi ??= "BaşkaBirİsim"; // kullaniciAdi artık null değil, atama YAPILMAZ
  print(kullaniciAdi); // Misafir (değişmedi!)
}

Sözdizimi: degisken ??= deger → degisken null ise deger'i ata, null değilse hiçbir şey yapma.

Bu, şu uzun yazımın kısayoludur:

dart
if (kullaniciAdi == null) {
  kullaniciAdi = "Misafir";
}

??= genelde "eğer bu değişkene henüz bir değer atanmadıysa, varsayılan bir değer ata" senaryolarında kullanılır — örneğin bir önbellek (cache) mekanizmasında ilk erişimde değeri hesaplayıp saklamak gibi.

?. — Null-Aware Erişim Operatörü (Tekrar, Derinlemesine)

Bölüm 2'de görmüştük, burada daha karmaşık senaryolarla pekiştirelim:

dart
void main() {
  String? isim = "Ahmet";
  print(isim?.length); // 5

  isim = null;
  print(isim?.length); // null — hata vermez
}

Zincirleme ?. kullanımı:

dart
class Adres {
  String? sehir;
  Adres({this.sehir});
}

class Kullanici {
  Adres? adres;
  Kullanici({this.adres});
}

void main() {
  Kullanici kullanici = Kullanici(adres: Adres(sehir: "İstanbul"));
  print(kullanici.adres?.sehir); // İstanbul

  Kullanici kullanici2 = Kullanici(); // adres yok
  print(kullanici2.adres?.sehir); // null — hata vermez, zincir güvenli şekilde kırılır
}

Sınıfları henüz detaylı işlemedik (Bölüm 6) ama bu örnek, ?.'nin gerçek gücünü gösteriyor: zincirleme erişimlerde, herhangi bir noktada null olursa, tüm zincir güvenli şekilde null sonucuna düşer — tek tek if (x != null) kontrolleri yazmana gerek kalmaz.

Bu Operatörleri Birlikte Kullanmak

Gerçek kodda bu operatörler genelde birlikte kullanılır:

dart
class Kullanici {
  String? takmaAd;
  Kullanici({this.takmaAd});
}

void main() {
  Kullanici? kullanici = Kullanici(takmaAd: "Ahi");

  String gosterilecekIsim = kullanici?.takmaAd ?? "Misafir";
  print(gosterilecekIsim); // Ahi

  kullanici = null;
  String gosterilecekIsim2 = kullanici?.takmaAd ?? "Misafir";
  print(gosterilecekIsim2); // Misafir
}

Bu satır — kullanici?.takmaAd ?? "Misafir" — çok yaygın bir Dart/Flutter kalıbıdır: "Eğer kullanıcı varsa ve takma adı varsa onu göster, yoksa (herhangi bir noktada null ise) 'Misafir' göster." Bunu ileride Flutter'da kullanıcı profili gösteren widget'larda sürekli göreceksin.

Özet Karşılaştırma Tablosu

Operatör Ne İşe Yarar Örnek
? : (ternary) Koşula göre iki değerden birini seçer yas >= 18 ? "Reşit" : "Değil"
?? Null ise varsayılan değer kullanır isim ?? "Misafir"
??= Null ise değişkene ata (değilse dokunma) isim ??= "Misafir"
?. Null ise erişimi atlar, sonucu null yapar kullanici?.isim

🎯 Bu Dersten Çıkarılması Gerekenler

  • Ternary (? :) kısa if/else gibidir, değer üretmek için kullanılır; yan etki için if/else tercih edilmeli.
  • İç içe ternary okunabilirliği düşürür — birden fazla koşul için switch expression daha uygun.
  • ??: null ise varsayılan değer sağlar, zincirlenebilir (a ?? b ?? c).
  • ??=: null ise ata, değilse dokunma.
  • ?.: zincirleme erişimlerde herhangi bir noktada null olursa güvenli şekilde null sonucuna düşer.
  • kullanici?.alan ?? "varsayılan" kalıbı, Dart/Flutter'da çok sık kullanılan bir desendir.

📝 Ödevler

  • [ ] Bir yaşı kontrol edip ternary ile "Reşit"/"Reşit değil" döndüren bir örnek yaz.
  • [ ] Aynı örneği bilerek 3 seviyeli iç içe ternary ile yazıp okunabilirliğinin nasıl düştüğünü gözlemle, sonra switch expression ile tekrar yaz.
  • [ ] Nullable bir değişkenle ??= kullanarak "sadece ilk kez null ise ata" davranışını iki farklı atama denemesiyle göster.
  • [ ] Nullable bir sınıf alanı zincirinde (örn. kullanici?.adres?.sehir) en az iki seviyeli ?. kullanarak güvenli erişim örneği yaz (sınıfları detaylı işlemedik ama basit bir örnek deneyebilirsin).
  • [ ] kullanici?.takmaAd ?? "Misafir" kalıbını kullanan, hem kullanıcı hem takma ad null olduğunda hem de olmadığında test eden bir örnek yaz.

Sıradaki konu: Bölüm 3 — Konu 14: for, while, do-while Döngüleri

14. bölüm

Bölüm 3 — Konu 14: `for`, `while`, `do-while` Döngüleri

for Döngüsü — Klasik Sayaç Tabanlı Döngü

dart
void main() {
  for (int i = 0; i < 5; i++) {
    print(i); // 0, 1, 2, 3, 4
  }
}

Yapıyı üç parçaya ayıralım:

  • int i = 0 — başlangıç ifadesi, döngü başlamadan önce bir kere çalışır.
  • i < 5 — koşul, her iterasyon başında kontrol edilir; true olduğu sürece döngü devam eder.
  • i++ — güncelleme ifadesi, her iterasyon sonunda çalışır.

Akış şöyle işler: başlangıç (bir kere) → koşul kontrolü → (true ise) gövde çalışır → güncelleme → koşul kontrolü → ... (false olana kadar tekrar).

Geriye doğru sayma:

dart
void main() {
  for (int i = 10; i > 0; i--) {
    print(i); // 10, 9, 8, ..., 1
  }
}

Adım büyüklüğünü değiştirme:

dart
void main() {
  for (int i = 0; i <= 20; i += 5) {
    print(i); // 0, 5, 10, 15, 20
  }
}

for-in — Koleksiyonlar Üzerinde Gezinme

Koleksiyonları detaylı Bölüm 4'te işleyeceğiz ama for-in yapısını burada tanıyalım, çünkü döngülerin en yaygın kullanım alanlarından biri bu:

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  for (var meyve in meyveler) {
    print(meyve); // Elma, Armut, Muz (sırayla)
  }
}

for-in, bir koleksiyonun (liste, set vb.) her elemanı üzerinde, sayaç yönetimiyle uğraşmadan gezinmeni sağlar. Klasik for ile aynı işi de yapabilirsin (for (int i = 0; i < meyveler.length; i++) { print(meyveler[i]); }) ama for-in çok daha okunabilirdir — indeks numarasına ihtiyacın yoksa for-in tercih edilmelidir.

while Döngüsü — Koşul Önce Kontrol Edilir

dart
void main() {
  int sayac = 0;

  while (sayac < 5) {
    print(sayac);
    sayac++;
  }
}

while, koşul true olduğu sürece gövdeyi tekrar tekrar çalıştırır. Koşul, her iterasyondan önce kontrol edilir — eğer koşul baştan false ise, döngü gövdesi hiç çalışmaz:

dart
void main() {
  int sayac = 10;

  while (sayac < 5) {
    print("Bu asla yazdırılmaz");
  }

  print("Döngü bitti"); // doğrudan buraya atlar
}

for mu, while mı kullanmalı?

  • Kaç kere döneceğin önceden belliyse (bir sayaç veya koleksiyon üzerinde) → for
  • Kaç kere döneceğin belirsizse, bir koşul sağlanana kadar devam etmesi gerekiyorsa (örn. kullanıcı doğru şifreyi girene kadar, bir dosyanın sonuna gelene kadar) → while

do-while Döngüsü — Gövde En Az Bir Kez Çalışır

dart
void main() {
  int sayac = 10;

  do {
    print(sayac); // 10 — bir kere çalışır, koşul sonradan kontrol edilir
    sayac++;
  } while (sayac < 5);
}

do-while ile while arasındaki kritik fark: do-while'da koşul, gövde çalıştıktan SONRA kontrol edilir. Bu yüzden koşul baştan false olsa bile, gövde en az bir kere çalışır.

dart
void main() {
  int sayac = 0;

  // while — koşul baştan false, hiç çalışmaz
  while (sayac > 10) {
    print("while: çalışmaz");
  }

  // do-while — koşul baştan false olsa da bir kere çalışır
  do {
    print("do-while: en az bir kere çalışır");
  } while (sayac > 10);
}

Ne zaman do-while kullanılır? Klasik örnek: bir menü sistemi — kullanıcıya en az bir kere seçenekleri göstermen gerekir (henüz hiçbir girdi almadan), sonra kullanıcının girdisine göre devam edip etmeyeceğine karar verirsin.

break — Döngüyü Erken Sonlandırma

dart
void main() {
  for (int i = 0; i < 10; i++) {
    if (i == 5) {
      break; // döngüyü tamamen durdurur
    }
    print(i); // 0, 1, 2, 3, 4
  }
}

break, içinde bulunduğu döngüyü tamamen sonlandırır — kontrol, döngüden sonraki ilk satıra atlar.

continue — Sadece Mevcut İterasyonu Atlama

dart
void main() {
  for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
      continue; // çift sayıları atla, döngü devam eder
    }
    print(i); // 1, 3, 5, 7, 9
  }
}

continue, break'ten farklı olarak döngüyü durdurmaz — sadece mevcut iterasyonun geri kalanını atlar ve bir sonraki iterasyona geçer.

break vs continue — Görsel Özet:

dart
void main() {
  print("--- break örneği ---");
  for (int i = 0; i < 5; i++) {
    if (i == 3) break;
    print(i); // 0, 1, 2 (3'e gelince tamamen durur)
  }

  print("--- continue örneği ---");
  for (int i = 0; i < 5; i++) {
    if (i == 3) continue;
    print(i); // 0, 1, 2, 4 (sadece 3 atlanır, döngü devam eder)
  }
}

İç İçe Döngüler (Nested Loops)

dart
void main() {
  for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
      print("i=$i, j=$j");
    }
  }
}

Çıktı, dış döngünün her adımında iç döngünün baştan sona çalışması şeklinde ilerler: i=1,j=1 → i=1,j=2 → i=1,j=3 → i=2,j=1 → ... Bu, örneğin bir 2 boyutlu tablo (satır-sütun) işlerken çok kullanılan bir kalıptır — Flutter'da GridView mantığını anlarken de bu kavram işine yarayacak.

İç içe döngülerde break/continue dikkat gerektirir: break/continue, sadece kendi bulundukları döngüyü etkiler, dıştaki döngüyü değil:

dart
void main() {
  for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
      if (j == 2) break; // sadece İÇ döngüyü durdurur
      print("i=$i, j=$j");
    }
  }
  // Çıktı: i=1,j=1 / i=2,j=1 / i=3,j=1
  // Dış döngü etkilenmez, her i için iç döngü j=2'de durur ama dış döngü devam eder
}

Sonsuz Döngü — Dikkatli Kullan

dart
void main() {
  int sayac = 0;
  while (true) {
    print(sayac);
    sayac++;
    if (sayac >= 5) {
      break; // çıkış koşulu MUTLAKA olmalı
    }
  }
}

while (true) teknik olarak sonsuza kadar çalışır — bir çıkış koşulu (break) koymadıysan, program hiç durmaz ve donar (Flutter'da bu, uygulamanın tamamen kilitlenmesi anlamına gelir). Bu yapı genelde belirli senaryolarda (örneğin bir sunucunun sürekli istek dinlemesi) bilinçli olarak kullanılır, ama her while (true) yazdığında mutlaka bir çıkış yolu olduğundan emin ol.


🎯 Bu Dersten Çıkarılması Gerekenler

  • for: kaç kere döneceğin önceden belliyse kullanılır (başlangıç, koşul, güncelleme).
  • for-in: koleksiyon elemanları üzerinde indeks yönetmeden gezinmeyi sağlar.
  • while: koşul önce kontrol edilir, baştan false ise gövde hiç çalışmaz.
  • do-while: koşul sonra kontrol edilir, gövde en az bir kere çalışır.
  • break: döngüyü tamamen durdurur. continue: sadece mevcut iterasyonu atlar, döngü devam eder.
  • İç içe döngülerde break/continue sadece kendi bulunduğu döngüyü etkiler.
  • while (true) kullanırken mutlaka bir çıkış koşulu (break) olmalı.

📝 Ödevler

  • [ ] for ile 1'den 10'a kadar sayıların toplamını hesapla.
  • [ ] while ile kullanıcıdan alındığını varsaydığın (elle atadığın) bir sayı 0 olana kadar geriye sayan bir döngü yaz.
  • [ ] do-while ile, koşulu baştan false olan ama yine de bir kere çalışan bir örnek yaz, while ile aynı koşulu denediğinde hiç çalışmadığını göster.
  • [ ] 1'den 50'ye kadar olan sayılardan sadece 3'e bölünebilenleri continue kullanarak, 30'dan büyük olanları da break ile durdurarak yazdır.
  • [ ] İç içe iki döngü ile 3x3'lük bir çarpım tablosu (i * j) yazdır.

🏁 Bölüm 3 Tamamlandı!

Artık tüm temel operatörleri, koşullu yapıları (if, switch) ve döngüleri (for, while, do-while) biliyorsun — bu, "mantık kurma" becerisinin temelidir ve buraya kadar öğrendiklerinle artık gerçek algoritmalar yazabilirsin.

Sıradaki durak Bölüm 4 — Koleksiyonlar: List, Set, Map ile veri gruplarını nasıl yöneteceğini öğreneceğiz — bu, neredeyse her Dart/Flutter programının omurgasını oluşturan bir konu.

15. bölüm

Bölüm 4 — Konu 16: `List` — Oluşturma, Erişim, Temel Metodlar

Bölüm 4'e hoş geldin. Bu bölümde koleksiyonları — birden fazla veriyi bir arada tutan yapıları — işleyeceğiz. İlk durağımız, en sık kullanılan koleksiyon tipi: List.

List Nedir?

List, sıralı (ordered) bir eleman dizisidir — her elemanın bir indeksi (sıra numarası, 0'dan başlar) vardır ve aynı değer birden fazla kez listede bulunabilir. Diğer dillerdeki "array" veya "dizi" kavramına karşılık gelir.

Liste Oluşturma

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];
  print(meyveler); // [Elma, Armut, Muz]

  var sayilar = [1, 2, 3, 4, 5]; // tip çıkarımı ile List<int>
  print(sayilar);

  List<int> bosListe = []; // boş liste
  print(bosListe); // []
}

List<String> ifadesindeki <String> kısmı, listenin hangi tipte elemanlar tutacağını belirtir — buna generic tip parametresi denir (Bölüm 9'da generics konusunda derinlemesine işleyeceğiz). Şimdilik "bu liste sadece String tutabilir" anlamına geldiğini bilmen yeterli.

Tip güvenliği burada da geçerli:

dart
void main() {
  List<String> meyveler = ["Elma", "Armut"];
  meyveler.add(42); // ❌ HATA! int, List<String>'e eklenemez
}

Elemanlara Erişim — İndeks Kullanımı

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  print(meyveler[0]); // Elma — ilk eleman, indeks 0'dan başlar
  print(meyveler[1]); // Armut
  print(meyveler[2]); // Muz
}

Sınır dışı erişim (out of bounds) hatası:

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];
  print(meyveler[5]); // ❌ RUNTIME HATASI! RangeError
}

Bu hata derleme zamanında yakalanmaz — Dart, listenin çalışma zamanındaki gerçek uzunluğunu bilmediği için, geçersiz bir indekse erişmeye çalıştığında ancak program çalışırken hata verir. Bu yüzden indeks kullanırken listenin uzunluğunu kontrol etmek önemlidir.

length — Liste Uzunluğu

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];
  print(meyveler.length); // 3

  print(meyveler[meyveler.length - 1]); // Muz — son eleman
}

meyveler.length - 1, listenin son elemanının indeksidir (çünkü indeksler 0'dan başlar, 3 elemanlı bir listenin son indeksi 2'dir, yani length - 1).

Eleman Ekleme

dart
void main() {
  List<String> meyveler = ["Elma", "Armut"];

  meyveler.add("Muz"); // sona ekler
  print(meyveler); // [Elma, Armut, Muz]

  meyveler.insert(1, "Çilek"); // belirli bir indekse ekler
  print(meyveler); // [Elma, Çilek, Armut, Muz]

  meyveler.addAll(["Kiraz", "Üzüm"]); // birden fazla eleman ekler
  print(meyveler); // [Elma, Çilek, Armut, Muz, Kiraz, Üzüm]
}

Eleman Çıkarma

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz", "Elma"];

  meyveler.remove("Elma"); // İLK eşleşen "Elma"yı siler
  print(meyveler); // [Armut, Muz, Elma]

  meyveler.removeAt(0); // indeks 0'daki elemanı siler
  print(meyveler); // [Muz, Elma]

  meyveler.removeLast(); // son elemanı siler
  print(meyveler); // [Muz]

  meyveler.clear(); // tüm elemanları siler
  print(meyveler); // []
}

Elemanı Güncelleme

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];
  meyveler[1] = "Çilek"; // indeks 1'deki elemanı değiştirir
  print(meyveler); // [Elma, Çilek, Muz]
}

Arama ve Kontrol Metodları

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  print(meyveler.contains("Armut")); // true
  print(meyveler.indexOf("Muz"));    // 2 — bulunamazsa -1 döner
  print(meyveler.isEmpty);            // false
  print(meyveler.isNotEmpty);         // true
  print(meyveler.first);              // Elma
  print(meyveler.last);               // Muz
}

List.filled ve List.generate — Belirli Boyutta Liste Oluşturma

dart
void main() {
  // Belirli boyutta, sabit değerle dolu liste
  List<int> sifirlar = List.filled(5, 0);
  print(sifirlar); // [0, 0, 0, 0, 0]

  // Bir fonksiyonla üretilen liste
  List<int> kareler = List.generate(5, (index) => index * index);
  print(kareler); // [0, 1, 4, 9, 16]
}

List.generate, ikinci parametre olarak bir fonksiyon alır — bu fonksiyon her indeks için çağrılır ve dönen değer o indekse yerleştirilir. Fonksiyonları henüz detaylı işlemedik (Bölüm 5) ama (index) => index * index şeklindeki kısa yazımı ("arrow function") burada bir önizleme olarak gördün.

Değişebilir (Mutable) vs Değişmez (Immutable, const/unmodifiable) Listeler

dart
void main() {
  List<int> degisebilirListe = [1, 2, 3];
  degisebilirListe.add(4); // ✅ çalışır
  print(degisebilirListe); // [1, 2, 3, 4]

  const sabitListe = [1, 2, 3];
  sabitListe.add(4); // ❌ HATA! const liste değiştirilemez
}

Bölüm 2'de final/const konusunda değindiğimiz "değişkenin kendisi mi, içeriği mi sabit" ayrımını burada net görüyorsun: const ile tanımlanan bir liste, hem değişkeni yeniden atamaya hem de içeriğini değiştirmeye kapalıdır. final ise sadece değişkenin yeniden atanmasını engeller, içeriği (add/remove) yine değiştirilebilir.

dart
void main() {
  final liste = [1, 2, 3];
  liste.add(4); // ✅ çalışır — final sadece yeniden atamayı engeller
  print(liste); // [1, 2, 3, 4]

  liste = [5, 6]; // ❌ HATA! final değişken yeniden atanamaz
}

List.unmodifiable — Var Olan Bir Listeyi Değiştirilemez Yapma

dart
void main() {
  List<int> orijinal = [1, 2, 3];
  List<int> degistirilemez = List.unmodifiable(orijinal);

  degistirilemez.add(4); // ❌ RUNTIME HATASI! UnsupportedError
}

Bu, bir listeyi başka bir kod parçasına "sadece okuma amaçlı" olarak vermek istediğinde kullanışlıdır — alıcı tarafın listeyi yanlışlıkla değiştirmesini engeller.


🎯 Bu Dersten Çıkarılması Gerekenler

  • List, sıralı ve indeksli bir koleksiyondur, indeksler 0'dan başlar.
  • Sınır dışı indeks erişimi runtime'da RangeError verir — derleme zamanında yakalanmaz.
  • Temel metodlar: add, insert, addAll, remove, removeAt, removeLast, clear.
  • Arama/kontrol: contains, indexOf, isEmpty, isNotEmpty, first, last.
  • List.filled ve List.generate ile belirli boyutta liste oluşturulabilir.
  • const liste hem değişkeni hem içeriği kilitler; final sadece değişkeni kilitler, içerik değişebilir; List.unmodifiable var olan bir listeyi sonradan salt-okunur yapar.

📝 Ödevler

  • [ ] 5 elemanlı bir sayı listesi oluştur, for-in ile tüm elemanları yazdır.
  • [ ] Bir listeye eleman ekle, belirli bir indekse eleman ekle, bir elemanı sil ve son halini yazdır.
  • [ ] contains ve indexOf kullanarak bir listede belirli bir elemanın olup olmadığını ve konumunu kontrol et.
  • [ ] List.generate kullanarak 1'den 10'a kadar sayıların küplerini içeren bir liste oluştur.
  • [ ] final bir liste ile const bir listeyi karşılaştır: ikisine de .add() çağırmayı dene, farkı gözlemle ve yorumla.

Sıradaki konu: Bölüm 4 — Konu 17: Set — Benzersiz Eleman Mantığı

16. bölüm

Bölüm 4 — Konu 17: `Set` — Benzersiz Eleman Mantığı

Set Nedir?

Set, List'e benzer ama iki kritik farkla: her eleman benzersizdir (tekrar edemez) ve sırasızdır (elemanların garantili bir sırası yoktur — Dart'ın LinkedHashSet implementasyonu pratikte ekleme sırasını korur ama bu, List'in indeksli erişimiyle aynı garanti değildir).

Set Oluşturma

dart
void main() {
  Set<String> renkler = {"Kırmızı", "Mavi", "Yeşil"};
  print(renkler); // {Kırmızı, Mavi, Yeşil}

  var sayilar = {1, 2, 3}; // tip çıkarımı ile Set<int>
  print(sayilar);
}

Dikkat et — Set de süslü parantez { } kullanır, tıpkı bir sonraki konuda göreceğimiz Map gibi. Dart, boş bir {} gördüğünde bunu varsayılan olarak Map sayar (çünkü Map daha yaygın kullanılır), bu yüzden boş bir Set oluştururken tipi açıkça belirtmen gerekir:

dart
void main() {
  var boşSet = <String>{}; // Set<String> olarak belirtilmeli
  print(boşSet); // {}
  print(boşSet.runtimeType); // Set<String>

  var boşMap = {}; // bu varsayılan olarak Map<dynamic, dynamic> olur
  print(boşMap.runtimeType); // Map<dynamic, dynamic>
}

Otomatik Tekrar Eleme (Deduplication)

Set'in en belirgin özelliği budur:

dart
void main() {
  Set<String> renkler = {"Kırmızı", "Mavi", "Kırmızı", "Yeşil", "Mavi"};
  print(renkler); // {Kırmızı, Mavi, Yeşil} — tekrarlar otomatik silinir!
  print(renkler.length); // 3
}

Bir listeyi Set'e çevirerek tekrar eden elemanları temizlemek, çok yaygın bir kullanım kalıbıdır:

dart
void main() {
  List<String> isimlerListesi = ["Ali", "Veli", "Ali", "Ayşe", "Veli"];
  Set<String> tekrarsizIsimler = isimlerListesi.toSet();
  print(tekrarsizIsimler); // {Ali, Veli, Ayşe}

  // İstersen tekrar listeye çevirebilirsin
  List<String> temizListe = tekrarsizIsimler.toList();
  print(temizListe); // [Ali, Veli, Ayşe]
}

Eleman Ekleme ve Çıkarma

dart
void main() {
  Set<String> renkler = {"Kırmızı", "Mavi"};

  renkler.add("Yeşil");
  print(renkler); // {Kırmızı, Mavi, Yeşil}

  renkler.add("Kırmızı"); // zaten var, hiçbir şey olmaz (hata da vermez)
  print(renkler); // {Kırmızı, Mavi, Yeşil} — değişmedi

  renkler.remove("Mavi");
  print(renkler); // {Kırmızı, Yeşil}
}

Neden List Değil de Set İndeksle Erişilemiyor?

dart
void main() {
  Set<String> renkler = {"Kırmızı", "Mavi", "Yeşil"};
  print(renkler[0]); // ❌ HATA! Set'te indeksli erişim yoktur
}

Bu, Set'in doğasından kaynaklanır — sırası garanti edilmediği (ve öncelik olarak "hızlı arama" için optimize edildiği) için, "0. eleman" gibi bir kavram anlamlı değildir. Eğer elemanlara erişmen gerekiyorsa, for-in ile gezinebilir veya .toList() ile listeye çevirip indeksli erişim kazanabilirsin.

Küme (Set) Matematik Operasyonları

Set, matematikteki küme kavramından geliyor, bu yüzden küme işlemlerini de destekler:

dart
void main() {
  Set<int> setA = {1, 2, 3, 4};
  Set<int> setB = {3, 4, 5, 6};

  // Kesişim (intersection) — ikisinde de olanlar
  print(setA.intersection(setB)); // {3, 4}

  // Birleşim (union) — ikisinde de olan, tekrar etmeyen tüm elemanlar
  print(setA.union(setB)); // {1, 2, 3, 4, 5, 6}

  // Fark (difference) — setA'da olup setB'de olmayanlar
  print(setA.difference(setB)); // {1, 2}
}

Bu operasyonlar, örneğin "iki kullanıcı grubunun ortak ilgi alanlarını bulmak" veya "bir listeden başka bir listede olmayan elemanları çıkarmak" gibi senaryolarda çok kullanışlıdır — bunları List ile yapmak çok daha fazla manuel kod gerektirirdi.

Arama ve Kontrol Metodları

dart
void main() {
  Set<String> renkler = {"Kırmızı", "Mavi", "Yeşil"};

  print(renkler.contains("Mavi")); // true
  print(renkler.isEmpty);          // false
  print(renkler.isNotEmpty);       // true
  print(renkler.length);           // 3
}

Önemli performans notu: Set.contains(), ortalama olarak List.contains()'ten çok daha hızlıdır — özellikle büyük veri kümelerinde. List.contains(), elemanı bulmak için listeyi baştan sona taramak zorundadır (O(n) karmaşıklık), Set.contains() ise iç yapısı (hash tabanlı) sayesinde bunu ortalama sabit zamanda yapabilir (O(1)). Bu yüzden "bu eleman bu koleksiyonda var mı" kontrolünü sık sık yapacaksan ve sıralama/tekrar önemli değilse, Set performans açısından daha iyi bir seçimdir.

List mi Set mi? — Karar Verme

Kriter List Set
Sıra önemli mi? ✅ Evet, korunur ❌ Garanti yok
Tekrar eden elemanlar olmalı mı? ✅ Olabilir ❌ Otomatik silinir
İndeksle erişim gerekiyor mu? ✅ liste[0] ❌ Yok
Sık "içinde var mı" kontrolü yapılacak mı? Yavaş (O(n)) Hızlı (O(1) ortalama)
Küme işlemleri (kesişim, birleşim) gerekiyor mu? ❌ Manuel yazman gerekir ✅ Doğrudan destekli

🎯 Bu Dersten Çıkarılması Gerekenler

  • Set: benzersiz elemanlar tutar, sırası garanti edilmez, indeksle erişilemez.
  • List.toSet() ile tekrar eden elemanları temizleyebilirsin, .toList() ile geri listeye çevirebilirsin.
  • Küme operasyonları: intersection (kesişim), union (birleşim), difference (fark).
  • Set.contains(), büyük veri kümelerinde List.contains()'ten performans olarak daha avantajlıdır.
  • Boş bir Set oluştururken tip belirtmen gerekir (<String>{}), yoksa Dart bunu Map sanır.

📝 Ödevler

  • [ ] Tekrar eden isimler içeren bir liste oluştur, .toSet() ile tekrarları temizle, sonra tekrar .toList() yap.
  • [ ] İki farklı Set<int> oluştur (bazı ortak elemanlarla), intersection, union ve difference sonuçlarını sırayla yazdır ve yorumla.
  • [ ] Set ve List ile aynı 1000 elemanlı bir koleksiyonda .contains() çağırıp (performans farkını gözlemlemek için yorumla, ölçmesi bu seviyede zor olabilir ama mantığını açıkla).
  • [ ] Bir öğrenci sınıfındaki (varsayımsal) ders seçimlerini Set<String> ile modelle, iki öğrencinin ortak derslerini intersection ile bul.

Sıradaki konu: Bölüm 4 — Konu 18: Map — Key-Value Yapılar

17. bölüm

Bölüm 4 — Konu 18: `Map` — Key-Value Yapılar

Map Nedir?

Map, her elemanın bir anahtar (key) ve o anahtara karşılık gelen bir değer (value) ile tutulduğu bir koleksiyondur. Diğer dillerde "dictionary", "hash map" veya "associative array" olarak da bilinir. List'te elemanlara sayısal indeksle erişirken, Map'te elemanlara anahtarla erişirsin.

Map Oluşturma

dart
void main() {
  Map<String, int> yaslar = {
    "Ahmet": 25,
    "Ayşe": 30,
    "Mehmet": 28,
  };

  print(yaslar); // {Ahmet: 25, Ayşe: 30, Mehmet: 28}
}

Map<String, int> ifadesi, "anahtarlar String, değerler int" anlamına gelir. Anahtar ve değer tipleri farklı olabilir — hatta anahtarlar arasında bile kendi içinde tutarlı olmak kaydıyla farklı tipler kullanılabilir (ama pratikte genelde tek tip anahtar ve tek tip değer kullanılır).

Boş Map oluşturma:

dart
void main() {
  Map<String, int> bosMap = {};
  // veya
  var digerBosMap = <String, int>{};

  print(bosMap); // {}
}

Değerlere Erişim

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25, "Ayşe": 30};

  print(yaslar["Ahmet"]); // 25
  print(yaslar["Olmayan"]); // null — hata vermez, olmayan anahtar null döner
}

Önemli null safety detayı: Map üzerinde [] ile erişim, her zaman nullable bir sonuç döndürür (int? gibi), çünkü Dart, o anahtarın gerçekten var olup olmadığını derleme zamanında bilemez:

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25};

  int yas = yaslar["Ahmet"]; // ❌ HATA! int? değeri int'e atanamaz
  int? yasNullable = yaslar["Ahmet"]; // ✅ doğrusu

  // ya da varsayılan değerle:
  int yasVarsayilan = yaslar["Olmayan"] ?? 0; // ?? operatörünü hatırla!
  print(yasVarsayilan); // 0
}

Bu, Bölüm 2/3'te işlediğimiz ?? operatörünün gerçek dünyada en sık kullanıldığı yerlerden biridir.

Değer Ekleme ve Güncelleme

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25};

  yaslar["Ayşe"] = 30; // yeni anahtar → ekler
  print(yaslar); // {Ahmet: 25, Ayşe: 30}

  yaslar["Ahmet"] = 26; // var olan anahtar → günceller
  print(yaslar); // {Ahmet: 26, Ayşe: 30}
}

Dikkat: []= operatörü hem ekleme hem güncelleme için kullanılır — Dart, anahtar zaten varsa değerini günceller, yoksa yeni bir çift ekler.

Anahtar Silme

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25, "Ayşe": 30};

  yaslar.remove("Ahmet");
  print(yaslar); // {Ayşe: 30}
}

Kontrol Metodları

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25, "Ayşe": 30};

  print(yaslar.containsKey("Ahmet"));   // true
  print(yaslar.containsValue(30));      // true
  print(yaslar.isEmpty);                // false
  print(yaslar.length);                 // 2

  print(yaslar.keys);   // (Ahmet, Ayşe) — Iterable<String>
  print(yaslar.values); // (25, 30) — Iterable<int>
}

keys ve values, sırasıyla tüm anahtarları ve tüm değerleri bir Iterable olarak döndürür (Bölüm 11'de "Iterable" kavramını derinlemesine işleyeceğiz). Şimdilik bunları .toList() ile bir listeye çevirebileceğini veya doğrudan for-in ile gezebileceğini bil.

Map Üzerinde Gezinme (Iteration)

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25, "Ayşe": 30};

  // Sadece anahtarlar üzerinde
  for (var isim in yaslar.keys) {
    print(isim); // Ahmet, Ayşe
  }

  // Sadece değerler üzerinde
  for (var yas in yaslar.values) {
    print(yas); // 25, 30
  }

  // Hem anahtar hem değer birlikte — forEach ile
  yaslar.forEach((isim, yas) {
    print("$isim: $yas yaşında");
  });
  // Ahmet: 25 yaşında
  // Ayşe: 30 yaşında

  // entries ile de yapılabilir
  for (var giris in yaslar.entries) {
    print("${giris.key}: ${giris.value}");
  }
}

forEach, bir fonksiyonu (burada anonim/lambda fonksiyon, Bölüm 5'te detaylı göreceğiz) her anahtar-değer çifti için çağırır — bu, en yaygın ve en okunabilir gezinme yöntemidir.

putIfAbsent — Yoksa Ekle Kalıbı

dart
void main() {
  Map<String, int> ziyaretSayisi = {};

  ziyaretSayisi.putIfAbsent("Anasayfa", () => 0);
  ziyaretSayisi["Anasayfa"] = ziyaretSayisi["Anasayfa"]! + 1;
  print(ziyaretSayisi); // {Anasayfa: 1}

  ziyaretSayisi.putIfAbsent("Anasayfa", () => 0); // zaten var, dokunmaz
  print(ziyaretSayisi); // {Anasayfa: 1} — değişmedi
}

Bu kalıp, "eğer bu anahtar hiç yoksa varsayılan bir değerle başlat, varsa dokunma" senaryolarında kullanışlıdır — örneğin bir sayaç mekanizmasında.

update — Var Olan Değeri Güncelleme

dart
void main() {
  Map<String, int> stok = {"Elma": 10, "Armut": 5};

  stok.update("Elma", (mevcutDeger) => mevcutDeger - 3);
  print(stok); // {Elma: 7, Armut: 5}

  // Anahtar yoksa, ifAbsent ile varsayılan bir davranış belirlenebilir
  stok.update("Muz", (mevcutDeger) => mevcutDeger - 1, ifAbsent: () => 0);
  print(stok); // {Elma: 7, Armut: 5, Muz: 0}
}

Gerçek Dünya Örneği — JSON Benzeri Veri

Map, gerçek uygulamalarda genelde JSON verisini temsil etmek için kullanılır (Bölüm 5'te JSON serialization konusunda tam olarak göreceğiz, burada bir önizleme):

dart
void main() {
  Map<String, dynamic> kullanici = {
    "isim": "Elif",
    "yas": 28,
    "aktif": true,
    "ilgiAlanlari": ["kitap", "müzik"],
  };

  print(kullanici["isim"]); // Elif
  print(kullanici["yas"]);  // 28
}

Burada Map<String, dynamic> kullandık çünkü değerler farklı tiplerde (String, int, bool, List) — bu, JSON verisiyle çalışırken çok yaygın bir kalıptır. Bir önceki bölümde dynamic'ten kaçınmayı önermiştik, ama JSON gibi dışarıdan gelen, tipi baştan bilinmeyen veriyle çalışırken bu meşru bir kullanım alanı — özellikle bu veriyi kısa süre sonra somut bir model sınıfına çevireceksen (Bölüm 5'te tam olarak göreceğiz).


🎯 Bu Dersten Çıkarılması Gerekenler

  • Map<K, V>, anahtar-değer çiftleri tutar; [] ile erişim, güncelleme için de kullanılır.
  • map[anahtar] her zaman nullable sonuç döner — olmayan anahtar null verir, hata fırlatmaz.
  • containsKey, containsValue, keys, values, entries ile koleksiyon üzerinde sorgu/gezinme yapılır.
  • forEach, hem anahtar hem değeri birlikte işlemek için en okunabilir yöntemdir.
  • putIfAbsent ve update, yaygın "varsa güncelle, yoksa ekle" kalıplarını kolaylaştırır.
  • Map<String, dynamic>, JSON benzeri, karma tipli veriler için meşru bir dynamic kullanım alanıdır.

📝 Ödevler

  • [ ] Ürün adı → fiyat şeklinde bir Map<String, double> oluştur, forEach ile tüm ürünleri "ürün: fiyat" formatında yazdır.
  • [ ] Olmayan bir anahtara [] ile eriş, sonucun null olduğunu göster; sonra ?? ile varsayılan bir değer kullan.
  • [ ] putIfAbsent kullanarak bir kelimenin geçiş sayısını tutan basit bir sayaç mekanizması kur (aynı kelimeyi birkaç kez "sayarak" test et).
  • [ ] Bir Map<String, int> üzerinde keys, values ve entries kullanarak üç farklı gezinme örneği yaz.
  • [ ] Map<String, dynamic> ile basit bir "kullanıcı profili" oluştur (isim, yaş, aktif mi, hobiler listesi), her alana ayrı ayrı eriş.

Sıradaki konu: Bölüm 4 — Konu 19: Koleksiyon Üzerinde for-in, forEach

18. bölüm

Bölüm 4 — Konu 19: Koleksiyon Üzerinde `for-in`, `forEach`

Önceki üç derste List, Set ve Map üzerinde gezinme örneklerini zaten gördün. Bu derste bu iki yaklaşımı (for-in ve forEach) doğrudan karşılaştırıp aralarındaki kritik farkları netleştireceğiz — çünkü bu fark, ileride hata ayıklarken kafa karıştırabilir.

for-in — Dil Yapısı (Language Construct)

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  for (var meyve in meyveler) {
    print(meyve);
  }
}

for-in, Dart dilinin kendi sözdizimine ait bir yapıdır (if, while gibi). Bu, önemli bir sonuç doğurur: for-in içinde break ve continue kullanılabilir.

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

  for (var sayi in sayilar) {
    if (sayi == 3) break; // ✅ çalışır
    print(sayi); // 1, 2
  }
}

forEach — Bir Metod (Higher-Order Function)

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  meyveler.forEach((meyve) {
    print(meyve);
  });
}

forEach ise for-in'in aksine bir dil yapısı değil, List/Set/Map sınıflarının bir metodudur. Parametre olarak bir fonksiyon alır ve bu fonksiyonu her eleman için çağırır. Bunun kritik bir sonucu var: forEach içinde break veya continue kullanamazsın:

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

  sayilar.forEach((sayi) {
    if (sayi == 3) break; // ❌ HATA! forEach içinde break kullanılamaz
    print(sayi);
  });
}

Neden? Çünkü break/continue, sadece gerçek döngü yapılarında (for, while, do-while, for-in) anlamlıdır — forEach'e verdiğin şey aslında sıradan bir fonksiyondur, ve bir fonksiyonun içinden "dışarıdaki döngüyü durdur" demenin dilde bir karşılığı yoktur. Eğer forEach içinde erken çıkmak istiyorsan, return kullanabilirsin ama bu sadece o anki fonksiyon çağrısını sonlandırır, tüm döngüyü değil:

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

  sayilar.forEach((sayi) {
    if (sayi == 3) return; // sadece bu iterasyonu atlar, continue gibi davranır
    print(sayi); // 1, 2, 4, 5 (3 atlanır ama döngü durmaz)
  });
}

Bu davranış continue'ya benzer ama break'in bir karşılığı yoktur — eğer gerçekten erken çıkmak istiyorsan, forEach yerine for-in kullanmalısın.

Ne Zaman Hangisi Kullanılır?

Durum Önerilen
Erken çıkış (break) gerekebilir for-in
Belirli elemanları atlamak (continue mantığı) yeterli İkisi de olur, forEach biraz daha kısa
Sadece her elemanla bir işlem yapmak, akışı değiştirmeye gerek yok forEach — daha fonksiyonel/kısa okunur
İndekse de ihtiyaç var Aşağıda göreceğimiz asMap() veya klasik for

İndeksle Birlikte Gezinme — asMap() Kalıbı

for-in ve forEach, sana doğrudan elemanın indeksini vermez. Eğer hem elemana hem indeksine ihtiyacın varsa birkaç seçeneğin var:

1. Klasik for ile (indeks zaten elinde):

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  for (int i = 0; i < meyveler.length; i++) {
    print("$i: ${meyveler[i]}");
  }
}

2. asMap() ile (daha fonksiyonel bir yaklaşım):

dart
void main() {
  List<String> meyveler = ["Elma", "Armut", "Muz"];

  meyveler.asMap().forEach((index, meyve) {
    print("$index: $meyve");
  });
  // 0: Elma
  // 1: Armut
  // 2: Muz
}

asMap(), listeyi geçici olarak bir Map<int, String>'e çevirir (anahtarlar indeksler, değerler elemanlar olur), böylece forEach ile hem indekse hem değere erişebilirsin.

Map Üzerinde forEach — Tekrar Hatırlatma

Bir önceki derste gördüğümüz gibi, Map.forEach iki parametreli bir fonksiyon alır:

dart
void main() {
  Map<String, int> yaslar = {"Ahmet": 25, "Ayşe": 30};

  yaslar.forEach((isim, yas) {
    print("$isim: $yas");
  });
}

Burada da aynı kural geçerli — break/continue kullanılamaz, sadece return ile o iterasyon atlanabilir.

Performans Notu

Pratikte, for-in ile forEach arasında büyük bir performans farkı genelde yoktur — ikisi de benzer verimlilikte çalışır. Seçim genelde okunabilirlik ve ihtiyaca göre yapılır: erken çıkış gerekiyorsa for-in, yoksa forEach daha "fonksiyonel" ve kısa bir stil sunar. Bölüm 11'de göreceğimiz map, where, reduce gibi fonksiyonel metodlarla birlikte forEach, Dart'ın fonksiyonel programlama yaklaşımının bir parçasıdır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • for-in: dil yapısıdır, break/continue kullanılabilir.
  • forEach: bir metoddur (fonksiyon alır), break/continue kullanılamaz — sadece return ile o iterasyon atlanabilir (continue gibi davranır, break'in karşılığı yoktur).
  • Erken çıkış ihtiyacı varsa kesinlikle for-in kullanılmalı.
  • İndekse ihtiyaç varsa klasik for veya asMap().forEach() kullanılabilir.
  • İkisi arasında performans farkı genelde önemsizdir — seçim okunabilirlik ve ihtiyaca göre yapılır.

📝 Ödevler

  • [ ] Bir sayı listesinde for-in kullanarak, 50'den büyük ilk sayıyı bulduğunda break ile döngüyü durduran bir örnek yaz.
  • [ ] Aynı senaryoyu forEach ile yapmaya çalış, break'in neden çalışmadığını gözlemle ve hatayı yorumla.
  • [ ] asMap().forEach() kullanarak bir liste üzerinde hem indeks hem değeri aynı anda yazdır.
  • [ ] Bir Map üzerinde forEach içinde return kullanarak belirli bir anahtarı (örn. değeri 0 olanları) atlayan bir örnek yaz.

Artık üç temel koleksiyon tipini (List, Set, Map) ve üzerlerinde gezinme yöntemlerini biliyorsun. Bölüm 4'ün son konusu olan spread operatörü ve collection if/for, koleksiyonları daha da esnek ve kısa şekilde oluşturmanı sağlayacak — özellikle Flutter'da widget listeleri oluştururken çok sık kullanacağın bir özellik.

Sıradaki konu: Bölüm 4 — Konu 20: Spread Operatörü (..., ...?) ve Collection If/For

19. bölüm

Bölüm 4 — Konu 20: Spread Operatörü (`...`, `...?`) ve Collection If/For

Bölüm 4'ün son konusundayız. Bu konu, Flutter'da widget listeleri oluştururken her gün karşına çıkacak — o yüzden burada sağlam bir temel kurmak gerçekten değerli.

Spread Operatörü (...) — Bir Koleksiyonu Diğerinin İçine "Yaymak"

dart
void main() {
  List<int> ilkListe = [1, 2, 3];
  List<int> ikinciListe = [4, 5, 6];

  List<int> birlesikListe = [...ilkListe, ...ikinciListe];
  print(birlesikListe); // [1, 2, 3, 4, 5, 6]
}

... (üç nokta), bir koleksiyonun elemanlarını tek tek açıp, bulunduğu yere yerleştirir. ...ilkListe yazdığında, sanki 1, 2, 3 tek tek elle yazılmış gibi davranır.

Spread olmadan aynı işi yapmak isteseydik:

dart
void main() {
  List<int> ilkListe = [1, 2, 3];
  List<int> ikinciListe = [4, 5, 6];

  // Spread olmadan, addAll ile manuel birleştirme
  List<int> birlesikListe = [];
  birlesikListe.addAll(ilkListe);
  birlesikListe.addAll(ikinciListe);
  print(birlesikListe); // [1, 2, 3, 4, 5, 6]
}

Spread operatörü, bunu tek satırda ve daha okunabilir şekilde yapmanı sağlıyor.

Aradan Eleman Ekleyerek Kullanma

dart
void main() {
  List<int> ortaElemanlar = [3, 4, 5];

  List<int> tamListe = [1, 2, ...ortaElemanlar, 6, 7];
  print(tamListe); // [1, 2, 3, 4, 5, 6, 7]
}

Spread'i normal elemanlarla karıştırarak kullanabilirsin — listenin herhangi bir noktasında.

...? — Null-Aware Spread

Eğer yaymak istediğin koleksiyon null olabilir, spread etmeden önce kontrol etmen gerekir. ...? bunu otomatik yapar:

dart
void main() {
  List<int>? belkiVarListe; // null

  List<int> sonuc = [1, 2, ...?belkiVarListe, 3];
  print(sonuc); // [1, 2, 3] — null liste sessizce atlandı, hata vermedi
}

Eğer ...? yerine düz ... kullansaydın:

dart
void main() {
  List<int>? belkiVarListe;
  List<int> sonuc = [1, 2, ...belkiVarListe, 3]; // ❌ HATA! null spread edilemez
}

Bu, Bölüm 2-3'te işlediğimiz null safety felsefesinin koleksiyonlara uygulanmış hali — ?. ve ?? gibi, ...? de "bu değer null olabilir, güvenli şekilde ele al" demenin bir yolu.

Set ve Map'te Spread

dart
void main() {
  Set<String> setA = {"a", "b"};
  Set<String> setB = {"b", "c"};
  Set<String> birlesim = {...setA, ...setB};
  print(birlesim); // {a, b, c} — Set olduğu için tekrar otomatik silinir

  Map<String, int> mapA = {"x": 1, "y": 2};
  Map<String, int> mapB = {"z": 3};
  Map<String, int> birlesikMap = {...mapA, ...mapB};
  print(birlesikMap); // {x: 1, y: 2, z: 3}
}

Collection if — Koşullu Eleman Ekleme

Dart, koleksiyon tanımlarken içine doğrudan if yazmana izin verir:

dart
void main() {
  bool indirimVarMi = true;

  List<String> mesajlar = [
    "Hoş geldiniz",
    if (indirimVarMi) "Bugüne özel %20 indirim!",
    "İyi alışverişler",
  ];

  print(mesajlar);
  // [Hoş geldiniz, Bugüne özel %20 indirim!, İyi alışverişler]
}

Eğer indirimVarMi false olsaydı, o eleman listeye hiç eklenmezdi — koşullu olarak dahil edilir. Bunu klasik yoldan yapmak isteseydin:

dart
void main() {
  bool indirimVarMi = false;

  List<String> mesajlar = ["Hoş geldiniz"];
  if (indirimVarMi) {
    mesajlar.add("Bugüne özel %20 indirim!");
  }
  mesajlar.add("İyi alışverişler");

  print(mesajlar); // [Hoş geldiniz, İyi alışverişler]
}

Collection if, bunu çok daha kısa ve tek bir liste tanımı içinde yapmanı sağlıyor. Bu, Flutter'da bir widget listesine koşullu olarak bir widget eklemek istediğinde (örneğin "kullanıcı giriş yapmışsa şu butonu göster") sürekli kullanacağın bir kalıptır.

if-else de kullanılabilir:

dart
void main() {
  bool girisYapildi = false;

  List<String> menu = [
    "Anasayfa",
    if (girisYapildi) "Profilim" else "Giriş Yap",
    "Ayarlar",
  ];

  print(menu); // [Anasayfa, Giriş Yap, Ayarlar]
}

Collection for — Koleksiyondan Koleksiyon Üretme

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

  List<int> kareler = [
    for (var sayi in sayilar) sayi * sayi,
  ];

  print(kareler); // [1, 4, 9, 16]
}

Bu, aslında Bölüm 11'de göreceğimiz .map() fonksiyonuna çok benzer bir işlevi görür, ama sözdizimi olarak doğrudan koleksiyon tanımının içine gömülüdür. Klasik yoldan yapmak isteseydin:

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

  List<int> kareler = [];
  for (var sayi in sayilar) {
    kareler.add(sayi * sayi);
  }

  print(kareler); // [1, 4, 9, 16]
}

Collection for, bunu tek satırda ve daha bildirimsel (declarative) bir şekilde ifade etmeni sağlıyor.

Hepsini Bir Arada Kullanmak

dart
void main() {
  List<String> vipMusteriler = ["Zeynep", "Can"];
  List<String> normalMusteriler = ["Ali", "Veli", "Ayşe"];
  bool ozelGunMu = true;

  List<String> tumMesajlar = [
    "Mağazamıza hoş geldiniz",
    if (ozelGunMu) "Bugün özel gün, indirimler geçerli!",
    for (var musteri in vipMusteriler) "VIP: $musteri, size özel fırsatlar var",
    ...normalMusteriler.map((m) => "Merhaba $m"),
  ];

  tumMesajlar.forEach(print);
}

Bu örnek biraz ileri seviye görünebilir (.map() henüz işlemedik) ama amacım şu: spread, collection if ve collection for'un hepsi bir arada kullanılabilir, ve bu, Flutter'da bir widget ağacı (örneğin bir Column'un children listesi) oluştururken sürekli karşına çıkacak bir kalıptır — koşullu widget'lar, bir listeden üretilen widget'lar, sabit widget'lar hepsi aynı liste tanımında bir arada bulunur.


🎯 Bu Dersten Çıkarılması Gerekenler

  • ...: bir koleksiyonun elemanlarını başka bir koleksiyonun içine "yayar" (açar).
  • ...?: null olabilecek koleksiyonları güvenli şekilde yayar, null ise atlar.
  • Collection if: bir koşula göre bir elemanı koleksiyona dahil edip etmemeyi sağlar (if-else de desteklenir).
  • Collection for: bir koleksiyondan yeni bir koleksiyon üretmeyi, ayrı bir döngü yazmadan, doğrudan tanım içinde yapmayı sağlar.
  • Bu üç özellik birlikte kullanılabilir — Flutter'da widget listeleri oluştururken çok sık karşına çıkacak.

📝 Ödevler

  • [ ] İki ayrı listeyi spread operatörü ile birleştirip yeni bir liste oluştur.
  • [ ] Nullable bir listeyle ...? kullanarak, liste null olduğunda hata almadan başka bir listeye dahil et.
  • [ ] Bir kullanıcının "premium üye" olup olmamasına göre collection if ile bir menü listesine koşullu eleman ekle.
  • [ ] Bir sayı listesinden, collection for kullanarak her sayının iki katını içeren yeni bir liste üret.
  • [ ] Spread, collection if ve collection for'u aynı liste tanımında birlikte kullanan bir örnek yaz (örn. sabit elemanlar + koşullu eleman + bir listeden türetilmiş elemanlar).

🏁 Bölüm 4 Tamamlandı!

Artık List, Set, Map koleksiyonlarını oluşturabiliyor, üzerlerinde gezinebiliyor ve spread/collection if/for ile bunları esnek şekilde birleştirebiliyorsun. Bu, Flutter'da widget ağaçları kurarken en çok kullanacağın becerilerden biri olacak.

Sıradaki durak Bölüm 5 — Fonksiyonlar: parametreler, arrow function sözdizimi, closure kavramı ve fonksiyonların Dart'ta "birinci sınıf vatandaş" olması gibi konularla devam edeceğiz.

20. bölüm

Bölüm 5 — Konu 21: Fonksiyon Tanımlama, Parametreler (Positional, Named, Optional)

Bölüm 5'e hoş geldin. Bu bölümde fonksiyonları derinlemesine işleyeceğiz — bu, kodunu tekrar tekrar yazmak yerine yeniden kullanılabilir parçalara bölmenin temel yoludur.

Temel Fonksiyon Tanımlama

dart
void selamVer() {
  print("Merhaba!");
}

void main() {
  selamVer(); // çağırma
  selamVer(); // istediğin kadar tekrar çağırabilirsin
}

Yapı: dönüşTipi fonksiyonAdı(parametreler) { gövde }

void, bu fonksiyonun bir değer döndürmediğini belirtir (Bölüm 1'de main() ile zaten görmüştük).

Değer Döndüren Fonksiyonlar

dart
int topla(int a, int b) {
  return a + b;
}

void main() {
  int sonuc = topla(5, 3);
  print(sonuc); // 8
}

int dönüş tipi, fonksiyonun bir int değer döndüreceğini belirtir. return ifadesi, fonksiyonun çalışmasını sonlandırır ve belirtilen değeri çağıran yere geri gönderir.

Dönüş tipini belirtmek zorunlu mu? Teknik olarak hayır (Dart tip çıkarımı yapabilir) ama her zaman açıkça belirtmek şiddetle önerilir — Bölüm 2'de tip çıkarımı konusunda değindiğimiz gibi, fonksiyon imzaları okunabilirlik açısından kritik önemdedir.

Positional Parametreler — Sıraya Göre

Şimdiye kadar gördüğümüz topla(int a, int b) örneği, positional (konumsal) parametrelere bir örnektir — parametreler, çağrıldıkları sıraya göre eşleştirilir:

dart
void tanit(String isim, int yas) {
  print("$isim, $yas yaşında");
}

void main() {
  tanit("Ahmet", 25); // isim="Ahmet", yas=25
  tanit(25, "Ahmet"); // ❌ HATA! tip uyuşmazlığı — sıra önemli
}

Optional Positional Parametreler — [ ] ile

Bazı parametreleri isteğe bağlı (optional) yapmak istersen, köşeli parantez [ ] içine alırsın:

dart
void tanit(String isim, [int? yas]) {
  if (yas != null) {
    print("$isim, $yas yaşında");
  } else {
    print("$isim, yaşı belirtilmedi");
  }
}

void main() {
  tanit("Ahmet", 25); // Ahmet, 25 yaşında
  tanit("Ayşe");      // Ayşe, yaşı belirtilmedi — yas parametresi verilmedi
}

Dikkat: optional positional parametreler nullable olmalı (int?) veya bir varsayılan değer almalı (birazdan göreceğiz) — çünkü çağrıldığında hiç değer verilmeyebilir, ve Dart'ın null safety kuralı gereği bir int değişkeni asla null olamaz.

Varsayılan Değerli Optional Parametreler

dart
void tanit(String isim, [int yas = 18]) {
  print("$isim, $yas yaşında");
}

void main() {
  tanit("Ahmet", 25); // Ahmet, 25 yaşında
  tanit("Ayşe");      // Ayşe, 18 yaşında — varsayılan değer kullanıldı
}

Burada yas parametresi nullable olmak zorunda değil çünkü çağrılmadığında otomatik olarak 18 değerini alıyor — yani asla gerçekten null olmuyor.

Named Parametreler — İsimle Belirtme, { } ile

Named (isimlendirilmiş) parametreler, süslü parantez { } içine alınır ve çağrılırken parametre adı açıkça yazılarak verilir:

dart
void tanit({required String isim, int yas = 18}) {
  print("$isim, $yas yaşında");
}

void main() {
  tanit(isim: "Ahmet", yas: 25); // isim: ve yas: yazmak ZORUNLU
  tanit(isim: "Ayşe"); // yas verilmedi, varsayılan 18 kullanılır
}

Named parametrelerin avantajı — okunabilirlik:

dart
void main() {
  // Positional ile — hangi değerin ne olduğu belli değil
  tanit2("Ahmet", 25, true, false);

  // Named ile — her değerin ne anlama geldiği apaçık
  tanit3(isim: "Ahmet", yas: 25, aktif: true, dogrulanmis: false);
}

void tanit2(String isim, int yas, bool aktif, bool dogrulanmis) {}
void tanit3({required String isim, required int yas, required bool aktif, required bool dogrulanmis}) {}

Özellikle çok parametreli fonksiyonlarda (Flutter'da widget constructor'ları genelde 5-10+ parametre alır), named parametreler kodun okunabilirliğini muazzam artırır — çağıran kişi, her değerin hangi parametreye karşılık geldiğini kod içine bakmadan anlayabilir.

required Anahtar Kelimesi

Named parametreler varsayılan olarak optional'dır (verilmezse ve varsayılan değeri yoksa, nullable olmalıdır). Eğer bir named parametrenin mutlaka verilmesini istiyorsan, required anahtar kelimesini kullanırsın:

dart
void kayitOlustur({required String kullaniciAdi, String? email}) {
  print("Kullanıcı: $kullaniciAdi, Email: ${email ?? "Belirtilmedi"}");
}

void main() {
  kayitOlustur(kullaniciAdi: "ahmet123"); // ✅ email opsiyonel, verilmedi
  kayitOlustur(); // ❌ HATA! kullaniciAdi zorunlu (required), verilmedi
}

required ile işaretlenmiş bir named parametre verilmezse, derleme zamanında hata alırsın — bu, Bölüm 2'de öğrendiğimiz null safety'nin fonksiyon parametrelerine uygulanmış hali.

Positional ve Named Parametreleri Birlikte Kullanma

dart
void urunEkle(String urunAdi, double fiyat, {int adet = 1, String? aciklama}) {
  print("$adet x $urunAdi - $fiyat TL");
  if (aciklama != null) print("Not: $aciklama");
}

void main() {
  urunEkle("Kalem", 5.0); // positional zorunlu, named optional
  urunEkle("Defter", 15.0, adet: 3, aciklama: "Kırtasiye kampanyası");
}

Kural: Positional parametreler her zaman önce gelir, named parametreler sonra. Positional parametreler zorunludur (aksi belirtilmedikçe — [ ] ile optional yapılabilir), named parametreler required ile işaretlenmediği sürece optional'dır.

Üç Parametre Türünü Özetleyen Tablo

Tür Sözdizimi Zorunlu mu? Çağırma Şekli
Positional (zorunlu) String isim ✅ Evet fonksiyon("Ahmet")
Optional Positional [String? isim] ❌ Hayır fonksiyon() veya fonksiyon("Ahmet")
Named (optional) {String? isim} ❌ Hayır fonksiyon(isim: "Ahmet")
Named (zorunlu) {required String isim} ✅ Evet fonksiyon(isim: "Ahmet")

Neden Bu Kadar Önemli? — Flutter Bağlantısı

Flutter'da hemen her widget'ın constructor'ı named parametreler kullanır:

dart
// Bu, ileride göreceğin gerçek bir Flutter widget çağrısına çok benzer
Text(
  "Merhaba",
  style: TextStyle(fontSize: 20),
)

Burada "Merhaba" positional bir parametre, style: ise named bir parametredir. Şimdi öğrendiğin bu kavramlar, Flutter tutorial'ına geçtiğinde sana doğrudan yardımcı olacak.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Positional parametreler sıraya göre eşleşir ve varsayılan olarak zorunludur.
  • [ ] ile optional positional, { } ile named parametreler tanımlanır.
  • Named parametreler varsayılan olarak optional'dır; required ile zorunlu hale getirilebilir.
  • Optional parametreler ya nullable (int?) olmalı ya da bir varsayılan değer (= 18) almalıdır.
  • Positional ve named parametreler birlikte kullanılabilir; positional önce, named sonra tanımlanır.
  • Named parametreler, özellikle çok parametreli fonksiyonlarda okunabilirliği ciddi şekilde artırır.

📝 Ödevler

  • [ ] Sadece positional parametrelerle iki sayıyı çarpan bir fonksiyon yaz.
  • [ ] Optional positional parametre kullanarak, ikinci parametre verilmezse varsayılan bir değer kullanan bir fonksiyon yaz.
  • [ ] Named parametreli bir hesaplaBMI({required double kilo, required double boy}) fonksiyonu yaz, required olmadan çağırmayı deneyip hatayı gözlemle.
  • [ ] Hem positional hem named parametre içeren bir fonksiyon yaz (örn. bir sipariş oluşturma fonksiyonu — ürün adı positional, adet ve not named olsun).
  • [ ] Named bir parametreyi hem required ile hem varsayılan değerle (required olmadan) iki farklı versiyonda yazıp aralarındaki çağırma farkını göster.

Sıradaki konu: Bölüm 5 — Konu 22: Varsayılan Parametre Değerleri (Derinlemesine)

21. bölüm

Bölüm 5 — Konu 22: Varsayılan Parametre Değerleri (Derinlemesine)

Önceki derste varsayılan değerlere kısaca değinmiştik ([int yas = 18] gibi). Bu derste bunu derinlemesine işleyip, dikkat edilmesi gereken ince detayları göreceğiz.

Temel Kullanım — Hatırlatma

dart
void selamVer(String isim, [String selam = "Merhaba"]) {
  print("$selam, $isim!");
}

void main() {
  selamVer("Ahmet");           // Merhaba, Ahmet!
  selamVer("Ayşe", "Selam");   // Selam, Ayşe!
}

Named parametrelerde de aynı mantık geçerli:

dart
void selamVer2({String isim = "Misafir", String selam = "Merhaba"}) {
  print("$selam, $isim!");
}

void main() {
  selamVer2(); // Merhaba, Misafir!
  selamVer2(isim: "Can"); // Merhaba, Can!
}

Kritik Kural: Varsayılan Değer Derleme Zamanında Sabit Olmalı

Bu, Bölüm 2'de öğrendiğimiz const kavramıyla doğrudan ilişkilidir. Bir parametrenin varsayılan değeri, derleme zamanında bilinen bir sabit (compile-time constant) olmak zorundadır:

dart
void logMesaj(String mesaj, [DateTime? zaman]) {
  zaman ??= DateTime.now(); // ✅ doğrusu — fonksiyon GÖVDESİ içinde atama
  print("[$zaman] $mesaj");
}

Ama şunu yapamazsın:

dart
void logMesajYanlis(String mesaj, [DateTime zaman = DateTime.now()]) {
  // ❌ HATA! DateTime.now() derleme zamanında bilinen bir sabit değil
  print("[$zaman] $mesaj");
}

Neden? Çünkü varsayılan değerler, Dart derleyicisi tarafından fonksiyonun imzasının bir parçası olarak "gömülür" — bu değerin, programın her çalıştırılışında (yani derleme anında) aynı olması gerekir. DateTime.now() her çalıştırıldığında farklı bir sonuç verdiği için (runtime'da belirlenir), bu kural ihlal edilmiş olur.

Doğru pratik: Runtime'da belirlenmesi gereken bir "varsayılan" değer istiyorsan, parametreyi null yapıp gövde içinde ??= ile ata (yukarıdaki logMesaj örneğinde gördüğün gibi).

Koleksiyon Varsayılan Değerleri — Dikkat Edilmesi Gereken Bir Tuzak

dart
void listeyeEkle(String eleman, [List<String> hedefListe = const []]) {
  // hedefListe.add(eleman); // ❌ HATA! const liste değiştirilemez
  print(hedefListe);
}

Varsayılan bir liste/map/set kullanmak istediğinde, bunun const olması gerekir (çünkü yukarıdaki kuralı hatırla — derleme zamanı sabiti olmalı). Ama const bir koleksiyon, Bölüm 4'te gördüğümüz gibi değiştirilemez. Bu yüzden varsayılan olarak boş bir liste veren ve o listeyi değiştirmek isteyen bir fonksiyon yazarsan, dikkatli olmalısın:

dart
List<String> listeyeEkle(String eleman, [List<String>? hedefListe]) {
  hedefListe ??= []; // her çağrıda TAZE bir liste oluşturulur
  hedefListe.add(eleman);
  return hedefListe;
}

void main() {
  var sonuc1 = listeyeEkle("Elma");
  print(sonuc1); // [Elma]

  var sonuc2 = listeyeEkle("Armut");
  print(sonuc2); // [Armut] — sonuc1'i etkilemedi, çünkü her çağrıda yeni liste
}

Bu, birçok dilde (özellikle Python'da) yaygın bir hata kaynağıdır — "mutable default argument" tuzağı. Dart, const zorunluluğuyla bu tuzağın bir kısmını baştan engeller, ama yine de nullable + ??= kalıbını bilmek önemlidir.

Basit Tiplerle Varsayılan Değerler — Sorunsuz

dart
void ayarlaSes(int seviye, [bool sessiz = false, String mod = "normal"]) {
  print("Ses: $seviye, Sessiz: $sessiz, Mod: $mod");
}

void main() {
  ayarlaSes(50);
  ayarlaSes(80, true, "gece");
}

int, bool, String gibi ilkel tiplerin sabit değerleri (0, false, "normal" gibi) zaten doğal olarak derleme zamanı sabitleridir, bu yüzden bunlarla varsayılan değer kullanmak hiçbir sorun çıkarmaz.

null Varsayılan Değeri — Örtük mü, Açık mı?

Eğer bir optional parametreye hiç varsayılan değer vermezsen, Dart otomatik olarak null'ı varsayılan yapar (parametre nullable ise):

dart
void mesajYaz(String metin, [String? ekBilgi]) {
  print(metin);
  if (ekBilgi != null) print(ekBilgi);
}

void main() {
  mesajYaz("Merhaba"); // ekBilgi otomatik olarak null
}

Bu, [String? ekBilgi = null] yazmakla aynı anlama gelir — ama = null kısmını açıkça yazmak gereksizdir ve önerilmez (Dart bunu zaten varsayılan yapar, yazmak fazladan gürültü yaratır).


🎯 Bu Dersten Çıkarılması Gerekenler

  • Varsayılan değerler derleme zamanında bilinen sabitler olmalı — DateTime.now() gibi runtime değerleri kullanılamaz.
  • Runtime'da belirlenen bir "varsayılan" istiyorsan, parametreyi nullable yap ve gövde içinde ??= kullan.
  • Varsayılan koleksiyonlar const olmak zorundadır, bu yüzden değiştirilemez — mutable bir varsayılan istiyorsan nullable + ??= kalıbını kullan.
  • Basit tipler (int, bool, String) için varsayılan değer kullanımı sorunsuzdur.
  • Nullable bir optional parametreye varsayılan değer vermezsen, otomatik olarak null olur — bunu açıkça yazmaya gerek yoktur.

📝 Ödevler

  • [ ] DateTime.now()'ı doğrudan varsayılan değer olarak vermeyi dene, derleyicinin verdiği hatayı oku; sonra nullable parametre + ??= ile doğru şekilde düzelt.
  • [ ] Varsayılan olarak boş bir liste alan ve o listeye eleman ekleyen bir fonksiyon yaz — nullable + ??= kalıbıyla, her çağrıda "taze" bir liste oluştuğunu iki ayrı çağrıyla kanıtla.
  • [ ] İki basit tip (örn. int ve bool) için varsayılan değerli, üç parametreli bir fonksiyon yaz; parametreleri hiç vermeden, kısmen vererek ve tam vererek üç farklı şekilde çağır.
  • [ ] Named bir parametrede = null yazmanın gereksiz olduğunu gösteren (yazmadan da aynı davranışın oluştuğu) bir karşılaştırma örneği yap.

Sıradaki konu: Bölüm 5 — Konu 23: Arrow Function (=>) Sözdizimi

22. bölüm

Bölüm 5 — Konu 23: Arrow Function (`=>`) Sözdizimi

Arrow Function Nedir?

Bir fonksiyonun gövdesi tek bir ifadeden oluşuyorsa (tek bir değer hesaplayıp döndürüyorsa), Dart bunu çok daha kısa yazmana izin veren bir sözdizimi sunar: arrow function (=>).

dart
// Klasik yazım
int kare(int sayi) {
  return sayi * sayi;
}

// Arrow function ile
int kareKisa(int sayi) => sayi * sayi;

void main() {
  print(kare(5));      // 25
  print(kareKisa(5));  // 25 — aynı sonuç
}

Sözdizimi: dönüşTipi fonksiyonAdı(parametreler) => ifade;

Dikkat et — return kelimesi ve süslü parantezler yoktur. => işaretinden sonraki ifadenin sonucu, otomatik olarak fonksiyonun dönüş değeri olur. Sonunda yine noktalı virgül (;) gerekir.

Ne Zaman Kullanılabilir, Ne Zaman Kullanılamaz?

Kullanılabilir — gövde tek bir ifadeyse:

dart
bool cift(int sayi) => sayi % 2 == 0;
String selamla(String isim) => "Merhaba, $isim!";
double alan(double genislik, double yukseklik) => genislik * yukseklik;

Kullanılamaz — gövde birden fazla ifade/işlem içeriyorsa:

dart
// ❌ Bu arrow function ile YAZILAMAZ (birden fazla ifade var)
int hesapla(int a, int b) {
  int toplam = a + b;
  int carpim = a * b;
  return toplam + carpim;
}

Arrow function, sadece tek bir ifadenin sonucunu doğrudan döndürmek için tasarlanmıştır. Eğer ara değişkenler tanımlaman, koşullu mantık çalıştırman veya birden fazla adım gerekiyorsa, klasik { } yazımına dönmen gerekir.

void Fonksiyonlarda Arrow Kullanımı

Arrow function, sadece değer döndüren fonksiyonlarla sınırlı değildir — bir işlemi (yan etki) tek satırda yapan void fonksiyonlarda da kullanılabilir:

dart
void selamVer(String isim) => print("Merhaba, $isim!");

void main() {
  selamVer("Elif"); // Merhaba, Elif!
}

Burada print() çağrısının sonucu (aslında void) otomatik olarak fonksiyonun kendisinin de void dönüş tipine uyar.

Koşullu İfadelerle Arrow Function — Ternary ile Birleştirme

Bölüm 3'te öğrendiğimiz ternary operatörünü hatırlarsan, arrow function ile birlikte tek satırda koşullu mantık da yazabilirsin:

dart
String durumBelirle(int yas) => yas >= 18 ? "Yetişkin" : "Çocuk";

void main() {
  print(durumBelirle(20)); // Yetişkin
  print(durumBelirle(10)); // Çocuk
}

Ya da Bölüm 3'te gördüğümüz switch expression ile:

dart
String harfNotu(int puan) => switch (puan) {
  >= 90 => "AA",
  >= 80 => "BA",
  >= 70 => "BB",
  _ => "FF",
};

Bu, önceki bölümlerde öğrendiğin özelliklerin (ternary, switch expression) arrow function ile nasıl birleştiğini gösteriyor — Dart'ın modern sözdizimi, bu parçaları bir araya getirdiğinde çok güçlü ve kısa ifadeler kurmana izin veriyor.

Getter'larda Arrow Function — Küçük Bir Önizleme

Bölüm 6'da sınıflar konusunda "getter" kavramını detaylı işleyeceğiz, ama arrow function'ın orada da sıkça kullanıldığını bilmen faydalı:

dart
class Dikdortgen {
  double genislik;
  double yukseklik;

  Dikdortgen(this.genislik, this.yukseklik);

  double get alan => genislik * yukseklik; // arrow ile kısa getter
}

Neden Bu Kadar Yaygın Kullanılır?

Arrow function, Dart/Flutter kodunda inanılmaz derecede yaygındır çünkü:

  1. Kısalık — tek satırlık basit mantıklar için gereksiz görsel gürültüyü (süslü parantez, return) ortadan kaldırır.
  2. Fonksiyonel programlama stiline uygunluk — Bölüm 11'de göreceğimiz map, where, reduce gibi metodlara anonim fonksiyon (isimsiz fonksiyon) geçerken sürekli kullanılır:
dart
void main() {
  List<int> sayilar = [1, 2, 3, 4, 5];

  // where metoduna arrow function ile kısa bir fonksiyon geçiriyoruz
  List<int> ciftler = sayilar.where((sayi) => sayi % 2 == 0).toList();
  print(ciftler); // [2, 4]
}

Bu örnek, Bölüm 11'de detaylı işleyeceğimiz .where() metoduna bir önizleme — ama arrow function'ın parametre olarak geçilen fonksiyonlarda ne kadar doğal ve sık kullanıldığını göstermesi açısından önemli.

  1. Flutter'da widget build metodlarında — basit widget'lar döndüren fonksiyonlarda sürekli göreceksin:
dart
// Flutter'a ileride göreceğin bir örnek (şimdilik sadece sözdizimine bak)
Widget build(BuildContext context) => Text("Merhaba");

Klasik Yazım ile Arrow Yazımı — Ne Zaman Hangisi?

Pratik kural: Fonksiyonun gövdesi tek bir return ifadesinden ibaretse, arrow function kullan — daha temiz olur. Birden fazla adım, ara değişken veya koşullu blok (if/else blokları, döngüler) içeriyorsa, klasik { } yazımını kullan.

dart
// ✅ Arrow uygun — tek ifade
int ikiyleCarp(int x) => x * 2;

// ✅ Klasik uygun — birden fazla adım var
int karmasikHesap(int x) {
  int adim1 = x * 2;
  int adim2 = adim1 + 10;
  if (adim2 > 100) {
    return 100;
  }
  return adim2;
}

🎯 Bu Dersten Çıkarılması Gerekenler

  • Arrow function (=>), tek ifadelik fonksiyonları kısaltmak için kullanılır; return ve { } gerekmez.
  • Sadece tek bir ifade içeren fonksiyonlarda kullanılabilir — birden fazla adım gerekiyorsa klasik yazım şart.
  • void fonksiyonlarda da kullanılabilir (bir yan etkiyi tek satırda çalıştırmak için).
  • Ternary ve switch expression ile birleştirilerek tek satırda koşullu mantık kurulabilir.
  • Fonksiyonel programlama stilinde (map, where gibi metodlara fonksiyon geçerken) ve Flutter'da çok sık kullanılır.

📝 Ödevler

  • [ ] Üç farklı klasik fonksiyonu (örn. çift/tek kontrolü, iki sayının toplamı, bir string'i büyük harfe çevirme) arrow function'a dönüştür.
  • [ ] Birden fazla adım gerektiren bir fonksiyonu (örn. bir sayının hem karesini hem küpünü hesaplayıp toplayan) arrow function ile yazmayı dene, neden çalışmadığını yorumla.
  • [ ] Ternary operatörünü arrow function içinde kullanarak bir yaş kategorisi belirleyen fonksiyon yaz (çocuk/genç/yetişkin gibi 3 kategori).
  • [ ] void dönüş tipli, arrow function ile yazılmış, bir mesajı biçimlendirip yazdıran bir fonksiyon yaz.

Sıradaki konu: Bölüm 5 — Konu 24: Fonksiyonlar Birinci Sınıf Vatandaş — Değişkene Atama, Parametre Olarak Geçme

23. bölüm

Bölüm 5 — Konu 24: Fonksiyonlar Birinci Sınıf Vatandaş — Değişkene Atama, Parametre Olarak Geçme

"Birinci Sınıf Vatandaş" (First-Class Citizen) Ne Demek?

Bölüm 2'de "Dart'ta her şey bir nesnedir" demiştik. Bu, fonksiyonlar için de geçerlidir — Dart'ta fonksiyonlar, int veya String gibi birer değerdir. Bu, şu üç şeyi yapabileceğin anlamına gelir:

  1. Bir fonksiyonu bir değişkene atayabilirsin
  2. Bir fonksiyonu başka bir fonksiyona parametre olarak geçebilirsin
  3. Bir fonksiyon başka bir fonksiyondan döndürülebilir

Bu üç özelliğe sahip diller "fonksiyonları birinci sınıf vatandaş olarak kabul eder" denir. Dart bunlardan biridir (JavaScript, Python, Kotlin gibi diğer modern diller de öyledir).

1. Fonksiyonu Değişkene Atama

dart
int kare(int sayi) {
  return sayi * sayi;
}

void main() {
  var fonksiyonDegiskeni = kare; // fonksiyonun kendisini bir değişkene atadık (ÇAĞIRMADAN!)

  print(fonksiyonDegiskeni(5)); // 25 — değişken üzerinden çağırıyoruz
}

Dikkat: var fonksiyonDegiskeni = kare; satırında parantez yok — kare() değil kare yazdık. kare() yazsaydık, fonksiyonu çağırmış ve sonucunu (bir int) değişkene atamış olurduk. Parantezsiz kare, fonksiyonun kendisine bir referans almak anlamına gelir.

Değişkenin tipi ne olur?

dart
void main() {
  var fonksiyonDegiskeni = kare;
  print(fonksiyonDegiskeni.runtimeType); // int Function(int)
}

int kare(int sayi) => sayi * sayi;

Dart, bu değişkenin tipini int Function(int) olarak tanır — "bir int parametre alan ve int döndüren fonksiyon" anlamına gelir. Bunu Bölüm 9'da generics ve daha ileri tip kavramlarıyla birlikte tekrar göreceğiz.

2. Fonksiyonu Parametre Olarak Geçme (Higher-Order Functions)

Bir fonksiyonu parametre olarak alan fonksiyonlara "higher-order function" (yüksek dereceli fonksiyon) denir. Bunu Bölüm 4'te forEach ile zaten kullanmıştık — şimdi kendi higher-order fonksiyonunu yazalım:

dart
void uygula(int sayi, int Function(int) islem) {
  int sonuc = islem(sayi);
  print("Sonuç: $sonuc");
}

int kare(int x) => x * x;
int ikiyleCarp(int x) => x * 2;

void main() {
  uygula(5, kare);       // Sonuç: 25
  uygula(5, ikiyleCarp); // Sonuç: 10
}

Parametre tipi int Function(int) ne anlama geliyor? Bu, "bir int parametre alıp int döndüren herhangi bir fonksiyon" demek. uygula fonksiyonu, hangi işlemin yapılacağını kendisi bilmiyor — bunu çağıran taraf, hangi fonksiyonu geçtiğine göre belirliyor. Bu, kodun ne kadar esnek olabileceğini gösteren güçlü bir örnek.

Bunu Bölüm 4'te gördüğümüz List.generate'in ikinci parametresiyle karşılaştır — orada da aslında bir fonksiyon parametre olarak geçiyordu, şimdi bunun nasıl çalıştığını daha net anlıyorsun.

3. Fonksiyondan Fonksiyon Döndürme

dart
Function carpanOlustur(int carpan) {
  int carpici(int sayi) {
    return sayi * carpan;
  }
  return carpici;
}

void main() {
  var ikiyleCarpan = carpanOlustur(2);
  var ucleCarpan = carpanOlustur(3);

  print(ikiyleCarpan(5)); // 10
  print(ucleCarpan(5));   // 15
}

Bu örnek biraz daha ileri seviye görünebilir — carpanOlustur fonksiyonu, çağrıldığında yeni bir fonksiyon üretip döndürüyor. Her çağrıda, o anki carpan değerine "hafızası olan" farklı bir fonksiyon elde ediyoruz. Bu davranışın adı closure'dır ve bir sonraki derste bunu tam olarak işleyeceğiz — burada sadece "fonksiyonlar döndürülebilir" gerçeğini görmen yeterli.

Anonim Fonksiyonlar — İsimsiz Fonksiyonlar

Bir fonksiyonu sadece bir kere, başka bir yere parametre olarak geçmek için kullanacaksan, ona ayrı bir isim vermene gerek yoktur — anonim (isimsiz) fonksiyon yazabilirsin:

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

  // İsimli fonksiyonla
  bool ciftMi(int sayi) => sayi % 2 == 0;
  var ciftlerV1 = sayilar.where(ciftMi).toList();

  // Anonim fonksiyonla — direkt yerinde tanımlanır
  var ciftlerV2 = sayilar.where((sayi) => sayi % 2 == 0).toList();

  print(ciftlerV1); // [2, 4]
  print(ciftlerV2); // [2, 4] — aynı sonuç
}

(sayi) => sayi % 2 == 0 ifadesi, bir arrow function ama hiçbir isme sahip değil — doğrudan .where() metoduna, ihtiyaç anında yazılmış. Bu, Dart/Flutter kodunda son derece yaygın bir kalıptır; Bölüm 4'teki forEach örneklerinde de aslında hep anonim fonksiyon kullanmıştık, farkında olmadan.

Neden Bu Kavram Bu Kadar Önemli?

Bu, ileride göreceğin birçok şeyin temelini oluşturuyor:

  • Bölüm 11'de map, where, reduce, fold gibi fonksiyonel koleksiyon metodları, hep fonksiyonu parametre olarak alır.
  • Flutter'da onPressed: () { ... } gibi, bir butona tıklandığında çalışacak kodu doğrudan bir anonim fonksiyon olarak yazarsın.
  • Asenkron programlamada (Bölüm 10), .then((sonuc) { ... }) gibi yapılar da aynı prensibe dayanır.

Yani bugün öğrendiğin bu temel, Dart/Flutter'ın hemen her köşesinde karşına çıkacak.

Fonksiyon Tipini Değişken Tanımında Kullanma

dart
void main() {
  int Function(int, int) toplaFonksiyonu = (a, b) => a + b;
  print(toplaFonksiyonu(3, 4)); // 7
}

Burada int Function(int, int), "iki int parametre alıp int döndüren bir fonksiyon" tipini açıkça belirtiyor. Bu, özellikle bir sınıfın alanı olarak bir fonksiyon tutmak istediğinde (Bölüm 6'da göreceğiz) kullanışlı bir sözdizimidir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ta fonksiyonlar birer değerdir — değişkene atanabilir, parametre olarak geçilebilir, başka bir fonksiyondan döndürülebilir.
  • Bir fonksiyonu parantezsiz yazmak (kare vs kare()), fonksiyonun kendisine referans almak demektir, onu çağırmak değil.
  • Fonksiyon parametre alan fonksiyonlara "higher-order function" denir.
  • Anonim fonksiyonlar, sadece bir kere kullanılacak kısa fonksiyonlar için isim vermeden yazılabilir — Dart/Flutter'da çok yaygındır.
  • Fonksiyon tipleri dönüşTipi Function(parametreTipleri) şeklinde açıkça yazılabilir.

📝 Ödevler

  • [ ] Bir fonksiyonu bir değişkene atayıp, o değişken üzerinden çağıran bir örnek yaz.
  • [ ] Bir sayı listesi üzerinde, farklı bir işlemi (örn. karesini alma, ikiyle çarpma) parametre olarak geçen uygula benzeri bir higher-order fonksiyon yaz.
  • [ ] Aynı işlemi hem isimli fonksiyon hem anonim fonksiyon kullanarak iki farklı şekilde yaz, ikisini karşılaştır.
  • [ ] int Function(int) tipinde bir değişken tanımlayıp ona bir arrow function ata, sonra çağır.

Sıradaki konu: Bölüm 5 — Konu 25: Anonim Fonksiyonlar ve Closure Kavramı (Derinlemesine)

24. bölüm

Bölüm 5 — Konu 25: Anonim Fonksiyonlar ve Closure Kavramı (Derinlemesine)

Önceki derste anonim fonksiyonları ve bir fonksiyonun başka bir fonksiyon döndürebildiğini görmüştük. Bu derste, o örnekte gizlice karşımıza çıkan ama üzerinde durmadığımız çok önemli bir kavramı derinlemesine işleyeceğiz: closure.

Closure Nedir?

Closure, bir fonksiyonun, tanımlandığı ortamdaki (scope) değişkenleri "hatırlaması" ve o değişkenlere erişebilmesi durumudur — fonksiyon çalıştırıldığı yerden çok uzakta olsa bile.

Bunu somut bir örnekle görelim:

dart
Function sayacOlustur() {
  int sayac = 0; // bu değişken, sayacOlustur'un LOKAL scope'unda

  int sayacArtir() {
    sayac++; // dıştaki 'sayac' değişkenine erişiyor
    return sayac;
  }

  return sayacArtir; // fonksiyonu döndürüyoruz (henüz çağırmadan)
}

void main() {
  var sayac1 = sayacOlustur();

  print(sayac1()); // 1
  print(sayac1()); // 2
  print(sayac1()); // 3 — her çağrıda sayac değeri KORUNUYOR ve artıyor!
}

Burada olağanüstü olan ne? Normalde, bir fonksiyon çalışmasını bitirdiğinde, o fonksiyonun içindeki lokal değişkenler (sayac gibi) bellekten silinir. Ama burada sayacOlustur() çalışmasını bitirmiş olmasına rağmen, döndürdüğü sayacArtir fonksiyonu hâlâ sayac değişkenine erişebiliyor ve onu güncelleyebiliyor. Bu, sayacArtir'ın bir closure oluşturduğu anlamına gelir — kendi tanımlandığı ortamın (sayac değişkenini içeren scope) bir "kapsülünü" (closure) yanında taşıyor.

Her Çağrı Kendi Closure'ını Oluşturur

dart
void main() {
  var sayac1 = sayacOlustur();
  var sayac2 = sayacOlustur(); // AYRI bir çağrı, AYRI bir closure

  print(sayac1()); // 1
  print(sayac1()); // 2
  print(sayac2()); // 1 — sayac2'nin kendi bağımsız sayacı var, sayac1'den etkilenmedi!
  print(sayac1()); // 3 — sayac1 kendi sayacına devam ediyor
}

Function sayacOlustur() {
  int sayac = 0;
  return () {
    sayac++;
    return sayac;
  };
}

Bu, closure'ların en önemli özelliğidir: her fonksiyon çağrısı, kendi bağımsız değişken kopyasını "kilitler" (closure oluşturur). sayac1 ve sayac2, aynı sayacOlustur fonksiyonundan üretilmiş olsalar da, birbirinden tamamen bağımsız çalışırlar.

Closure'ın Pratik Kullanım Alanları

1. Özelleştirilmiş Fonksiyonlar Üretme

dart
Function carpanOlustur(int carpan) {
  return (int sayi) => sayi * carpan;
}

void main() {
  var ikiyleCarpan = carpanOlustur(2);
  var onlaCarpan = carpanOlustur(10);

  print(ikiyleCarpan(5));  // 10
  print(onlaCarpan(5));    // 50
}

Burada carpan parametresi, döndürülen anonim fonksiyon tarafından "hatırlanıyor" — her üretilen fonksiyon, kendi carpan değerine sahip, birbirinden bağımsız bir closure.

2. Callback Fonksiyonlarda Dış Değişkenlere Erişim

dart
void main() {
  String kullaniciAdi = "Ahmet";

  List<int> sayilar = [1, 2, 3];

  sayilar.forEach((sayi) {
    print("$kullaniciAdi için sayı: $sayi"); // dıştaki kullaniciAdi'ye erişiyor
  });
}

Bu, aslında closure'ın en sık karşına çıkacağı kullanım şeklidir — anonim bir fonksiyon (burada forEach'e geçirilen), kendi dışındaki bir değişkene (kullaniciAdi) doğrudan erişebiliyor, parametre olarak almasına bile gerek kalmadan.

3. State (Durum) Saklama — Flutter'a Doğrudan Bağlantı

dart
Function butonSayaci() {
  int tiklamaSayisi = 0;
  return () {
    tiklamaSayisi++;
    print("Tıklama sayısı: $tiklamaSayisi");
  };
}

void main() {
  var buton1Tikla = butonSayaci();
  buton1Tikla(); // Tıklama sayısı: 1
  buton1Tikla(); // Tıklama sayısı: 2
  buton1Tikla(); // Tıklama sayısı: 3
}

Bu kalıp, ileride Flutter'da onPressed: () { setState(() { sayac++; }); } gibi yapılar yazarken karşına çıkacak mantığın temelidir — bir buton her tıklandığında çalışacak fonksiyon, kendi dışındaki bir durumu (state) "hatırlayıp" güncelleyebiliyor.

Closure ile Değişken Yakalama — Dikkat Edilmesi Gereken Bir Nokta

dart
void main() {
  List<Function> fonksiyonlar = [];

  for (int i = 0; i < 3; i++) {
    fonksiyonlar.add(() => print(i));
  }

  for (var f in fonksiyonlar) {
    f();
  }
  // Çıktı: 0, 1, 2
}

Dart'ta her for iterasyonu, i için yeni bir kopya oluşturur (bu davranış dilden dile değişebilir — örneğin bazı eski JavaScript sürümlerinde var ile bu farklı çalışırdı, hepsi son değeri yazardı). Dart'ta bu doğru ve beklenen şekilde çalışır: her closure, oluşturulduğu anki i değerini doğru şekilde yakalar.

final/const ile Closure İlişkisi

Bölüm 2'de öğrendiğimiz final/const kavramları, closure'larla birlikte kullanıldığında da tutarlı davranır — bir closure, dış scope'taki bir final değişkenin değerini "yakaladığında", o değer değişmeyeceği için closure'ın davranışı da öngörülebilir olur. var ile tanımlanan ve closure içinde güncellenen değişkenlerde ise (yukarıdaki sayaç örneklerinde gördüğümüz gibi) değer gerçekten değişebilir — bu, closure'ın "canlı bir referans" tuttuğunu, "o anki değerin bir kopyasını" tutmadığını gösterir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Closure, bir fonksiyonun tanımlandığı ortamdaki değişkenlere, o ortam "kapanmış" (fonksiyon çalışmasını bitirmiş) olsa bile erişebilmesidir.
  • Her fonksiyon çağrısı kendi bağımsız closure'ını oluşturur — farklı çağrılar birbirinin durumunu etkilemez.
  • Closure'lar, özelleştirilmiş fonksiyonlar üretmek, callback'lerde dış değişkenlere erişmek ve durum (state) saklamak için kullanılır.
  • Dart'ta for döngülerinde her iterasyon kendi değişken kopyasını doğru şekilde closure'a yakalar.
  • Bu kavram, ileride Flutter'da state yönetimi ve callback fonksiyonları anlarken doğrudan işine yarayacak.

📝 Ödevler

  • [ ] sayacOlustur benzeri bir fonksiyon yaz, iki farklı sayaç oluşturup birbirinden bağımsız çalıştıklarını kanıtla.
  • [ ] Bir "çarpan üretici" fonksiyon yaz (carpanOlustur gibi), 3 farklı çarpanla 3 farklı fonksiyon üret ve hepsini test et.
  • [ ] Bir listeye closure içeren 5 farklı anonim fonksiyon ekleyen bir döngü yaz (yukarıdaki örneğe benzer), hepsini çalıştırıp doğru değerleri yakaladıklarını doğrula.
  • [ ] Dışarıdaki bir listeye, her çağrıda yeni bir eleman ekleyen bir closure fonksiyonu yaz (örn. logEkle fonksiyonu, çağrıldıkça dış bir listeye zaman damgası eklesin).

🏁 Bölüm 5'in Beşinci Konusu Tamamlandı!

Fonksiyonların temel yapısından, parametrelere, arrow function'a, birinci sınıf vatandaş olmalarına ve closure'lara kadar geniş bir yolculuk yaptık. Bölüm 5'in son konusu olan recursion (özyineleme) ile bu bölümü tamamlayacağız.

Sıradaki konu: Bölüm 5 — Konu 26: Recursion (Özyineleme)

25. bölüm

Bölüm 5 — Konu 26: Recursion (Özyineleme)

Bölüm 5'in son konusundayız. Recursion, bir fonksiyonun kendi kendini çağırması ile çalışan bir problem çözme tekniğidir.

Temel Kavram

dart
void geriSay(int n) {
  if (n <= 0) {
    print("Bitti!");
    return;
  }
  print(n);
  geriSay(n - 1); // fonksiyon kendini çağırıyor
}

void main() {
  geriSay(5);
}

Çıktı:

metin
5
4
3
2
1
Bitti!

Her recursive (özyinelemeli) fonksiyonun iki temel parçası olmalıdır:

  1. Base case (taban durumu): Fonksiyonun kendini çağırmayı durdurduğu koşul. Yukarıdaki örnekte n <= 0 durumu budur.
  2. Recursive case (özyinelemeli durum): Fonksiyonun kendini, problemi biraz daha "küçültülmüş" bir haliyle tekrar çağırdığı kısım. Yukarıda geriSay(n - 1) budur.

Base case olmadan ne olur?

dart
void sonsuzGeriSay(int n) {
  print(n);
  sonsuzGeriSay(n - 1); // base case yok — asla durmaz!
}

Bu fonksiyon, base case olmadığı için sonsuza kadar kendini çağırmaya devam eder. Pratikte bu, Stack Overflow hatasıyla sonuçlanır — çünkü her fonksiyon çağrısı, bellekte bir "çağrı yığını" (call stack) katmanı oluşturur ve bu yığın sonsuza kadar büyüyemez, bir noktada bellek sınırına ulaşılır ve program çöker.

Klasik Örnek: Faktöriyel

Faktöriyel (n!), recursion'ı öğretmek için en sık kullanılan matematiksel örnektir: 5! = 5 * 4 * 3 * 2 * 1 = 120

dart
int faktoriyel(int n) {
  if (n <= 1) return 1; // base case
  return n * faktoriyel(n - 1); // recursive case
}

void main() {
  print(faktoriyel(5)); // 120
}

Bu nasıl çalışıyor, adım adım görelim:

metin
faktoriyel(5)
= 5 * faktoriyel(4)
= 5 * (4 * faktoriyel(3))
= 5 * (4 * (3 * faktoriyel(2)))
= 5 * (4 * (3 * (2 * faktoriyel(1))))
= 5 * (4 * (3 * (2 * 1)))
= 5 * (4 * (3 * 2))
= 5 * (4 * 6)
= 5 * 24
= 120

Fonksiyon, önce en küçük probleme (faktoriyel(1)) inene kadar kendini çağırır, sonra o sonuçlar geri "yukarı doğru" katlanarak nihai sonuca ulaşır. Bu, recursion'ın karakteristik özelliğidir — problem, kendine benzer ama daha küçük alt problemlere bölünür.

Recursion vs Döngü (Iteration) — Aynı İşi Yapmanın İki Yolu

dart
// Recursive versiyon
int faktoriyelRecursive(int n) {
  if (n <= 1) return 1;
  return n * faktoriyelRecursive(n - 1);
}

// Iterative (döngü ile) versiyon
int faktoriyelIterative(int n) {
  int sonuc = 1;
  for (int i = 2; i <= n; i++) {
    sonuc *= i;
  }
  return sonuc;
}

void main() {
  print(faktoriyelRecursive(5)); // 120
  print(faktoriyelIterative(5)); // 120 — aynı sonuç
}

Hangisi daha iyi? Bu duruma göre değişir:

  • Recursion, problemi doğal olarak kendine benzer alt problemlere bölen durumlarda (ağaç yapıları, iç içe geçmiş veri, matematiksel tanımı zaten recursive olan problemler — faktöriyel, Fibonacci gibi) genelde daha okunabilir ve zarif bir çözüm sunar.
  • Döngü (iteration), genelde daha performanslıdır — çünkü her recursive çağrı, bellekte ekstra bir "çağrı yığını" katmanı oluşturur (fonksiyon çağırma maliyeti + bellek kullanımı), döngüde ise böyle bir ek yük yoktur.

Pratik tavsiye: Basit, doğrusal problemlerde (bir listeyi toplama, sayma gibi) döngü kullan. Problem doğası gereği "kendine benzer parçalara bölünüyorsa" (ağaç dolaşma, böl-ve-fethet algoritmaları gibi) recursion çok daha temiz bir çözüm sunar.

Başka Bir Klasik Örnek: Fibonacci Serisi

dart
int fibonacci(int n) {
  if (n <= 1) return n; // base case: fib(0)=0, fib(1)=1
  return fibonacci(n - 1) + fibonacci(n - 2); // recursive case
}

void main() {
  for (int i = 0; i < 8; i++) {
    print(fibonacci(i)); // 0, 1, 1, 2, 3, 5, 8, 13
  }
}

Fibonacci serisinde her sayı, kendinden önceki iki sayının toplamıdır — bu tanım zaten doğal olarak recursive'dir, bu yüzden kod da matematiksel tanıma neredeyse birebir uyuyor. Ama dikkat: bu naif Fibonacci implementasyonu, büyük n değerlerinde çok yavaştır çünkü aynı alt problemleri defalarca tekrar hesaplar (örneğin fibonacci(5), fibonacci(3)'ü birden fazla kez hesaplar). Bu performans sorununu çözmenin yolları (memoization gibi) daha ileri bir konu — şimdilik sadece bu tuzağın var olduğunu bilmen yeterli.

Recursive Fonksiyonlarda Koleksiyonlarla Çalışma

dart
int listeToplami(List<int> liste) {
  if (liste.isEmpty) return 0; // base case: boş liste
  return liste.first + listeToplami(liste.sublist(1)); // ilk eleman + kalanının toplamı
}

void main() {
  print(listeToplami([1, 2, 3, 4, 5])); // 15
}

liste.sublist(1), listenin ilk elemanı hariç geri kalanını yeni bir liste olarak döndürür. Bu örnek, "problemi küçültme" mantığının koleksiyonlarda nasıl işlediğini gösteriyor — her çağrıda liste bir eleman küçülür, ta ki boş listeye (base case) ulaşana kadar.

Bunu pratikte genelde .reduce() veya .fold() gibi metodlarla (Bölüm 11'de göreceğiz) yaparız çünkü onlar hem daha performanslı hem de daha yaygın kullanılan bir yaklaşımdır — ama recursion mantığını anlamak için bu örnek faydalı.

Ne Zaman Recursion Kullanmalı?

İyi kullanım alanları:

  • Ağaç/graf yapılarında dolaşma (örneğin bir dosya sisteminin tüm alt klasörlerini gezmek)
  • Böl-ve-fethet algoritmaları (binary search, merge sort gibi — Bölüm 13'te veya ileri konularda karşına çıkabilir)
  • Matematiksel olarak doğası gereği recursive tanımlanan problemler

Dikkatli olunması gereken durumlar:

  • Çok derin recursion (binlerce seviye), stack overflow riski taşır
  • Basit doğrusal problemler için gereksiz karmaşıklık katabilir — döngü yeterliyse döngü kullan

🎯 Bu Dersten Çıkarılması Gerekenler

  • Recursion, bir fonksiyonun kendini çağırmasıdır; her recursive fonksiyonda base case ve recursive case olmalıdır.
  • Base case olmadan (veya yanlış tanımlandığında) sonsuz özyineleme oluşur ve Stack Overflow hatası alınır.
  • Recursion, problemi kendine benzer küçük alt problemlere bölen durumlarda okunabilirlik açısından üstündür.
  • Döngü (iteration), genelde daha performanslıdır; basit doğrusal problemlerde tercih edilmelidir.
  • Naif recursive çözümler (örn. Fibonacci) bazı durumlarda tekrarlı hesaplamalar yüzünden verimsiz olabilir.

📝 Ödevler

  • [ ] Faktöriyel hesaplayan recursive bir fonksiyon yaz, faktoriyel(0) ve faktoriyel(1) durumlarını da test et.
  • [ ] Bilerek base case'i olmayan bir recursive fonksiyon yaz, çalıştırıp Stack Overflow hatasını gözlemle (dikkatli ol, büyük bir sayı vermeden önce ne olacağını tahmin et).
  • [ ] Bir sayının rakamlarının toplamını recursive olarak hesaplayan bir fonksiyon yaz (örn. rakamToplami(123) → 1+2+3=6).
  • [ ] Bir listenin en büyük elemanını recursive olarak bulan bir fonksiyon yaz (döngü kullanmadan).
  • [ ] Aynı problemi (örn. bir sayı aralığının toplamı) hem recursive hem iterative olarak yaz, ikisinin de aynı sonucu verdiğini doğrula.

🏁 Bölüm 5 Tamamlandı!

Fonksiyonların tüm temel yönlerini işledik: tanımlama, parametre türleri, arrow function, birinci sınıf vatandaş olma özelliği, closure ve recursion. Bu, kodunu düzenli, yeniden kullanılabilir parçalara bölmenin temelini oluşturuyor.

Sıradaki durak Bölüm 6 — Nesne Yönelimli Programlama (Temel): sınıflar, constructor'lar, getter/setter ile Dart'ın OOP dünyasına giriş yapacağız — bu, Flutter'ın widget mimarisini anlamak için kritik bir temel olacak.

26. bölüm

Bölüm 6 — Konu 27: Class Tanımlama, Constructor (Varsayılan, Named, Factory)

Bölüm 6'ya hoş geldin — Dart'ın nesne yönelimli programlama (OOP) dünyasına giriyoruz. Bu bölüm, Flutter'ın widget mimarisini anlamak için doğrudan temel oluşturacak, çünkü her widget aslında bir class'tır.

Class Nedir?

Bir class, gerçek dünyadaki bir "şeyi" (nesneyi) modellemek için kullanılan bir şablondur — o şeyin özelliklerini (alanlar/fields) ve davranışlarını (metodlar) bir arada tutar.

dart
class Kisi {
  String isim = "";
  int yas = 0;

  void selamVer() {
    print("Merhaba, ben $isim, $yas yaşındayım.");
  }
}

void main() {
  Kisi kisi1 = Kisi(); // nesne (instance) oluşturma
  kisi1.isim = "Ahmet";
  kisi1.yas = 25;
  kisi1.selamVer(); // Merhaba, ben Ahmet, 25 yaşındayım.
}

Temel terimler:

  • Class (sınıf): Şablonun kendisi (Kisi)
  • Instance (nesne/örnek): Class'tan üretilen gerçek bir varlık (kisi1)
  • Field (alan): Class'ın sahip olduğu veri (isim, yas)
  • Method (metod): Class'ın sahip olduğu davranış/fonksiyon (selamVer())

Constructor Nedir?

Yukarıdaki örnekte, Kisi() ile bir nesne oluşturduk ve sonra alanları teker teker doldurduk. Bu pratik değil — genelde bir nesneyi oluştururken, değerlerini aynı anda vermek isteriz. Bunu sağlayan yapıya constructor (yapıcı metod) denir.

Varsayılan (Default) Constructor

dart
class Kisi {
  String isim;
  int yas;

  Kisi(String isim, int yas) {
    this.isim = isim;
    this.yas = yas;
  }

  void selamVer() {
    print("Merhaba, ben $isim, $yas yaşındayım.");
  }
}

void main() {
  Kisi kisi1 = Kisi("Ahmet", 25);
  kisi1.selamVer(); // Merhaba, ben Ahmet, 25 yaşındayım.
}

this anahtar kelimesi ne işe yarıyor? Constructor'ın parametreleri (isim, yas) ile class'ın alanları (isim, yas) aynı isme sahip. this.isim, "bu nesnenin isim alanı" anlamına gelir — parametre olan isim'den ayırt etmek için kullanılır. this olmasaydı, isim = isim; yazmak anlamsız olurdu (Dart hangi isim'in kastedildiğini anlayamazdı).

Constructor Kısayolu — this.parametreAdi

Yukarıdaki yazım çok yaygın olduğu için, Dart bunun için özel bir kısayol sunar:

dart
class Kisi {
  String isim;
  int yas;

  Kisi(this.isim, this.yas); // constructor gövdesi bile yok!

  void selamVer() {
    print("Merhaba, ben $isim, $yas yaşındayım.");
  }
}

void main() {
  Kisi kisi1 = Kisi("Ahmet", 25);
  kisi1.selamVer();
}

Kisi(this.isim, this.yas); satırı, bir önceki örnekteki 4 satırlık constructor gövdesiyle tamamen aynı işi yapar. Bu kısayol o kadar yaygındır ki, Dart/Flutter kodunda constructor'ları neredeyse hep bu şekilde yazılmış göreceksin.

Named parametrelerle constructor:

dart
class Kisi {
  String isim;
  int yas;

  Kisi({required this.isim, required this.yas});
}

void main() {
  Kisi kisi1 = Kisi(isim: "Ayşe", yas: 30); // named parametre gibi çağrılır
  print(kisi1.isim); // Ayşe
}

Bölüm 5'te öğrendiğimiz required ve named parametre kavramları burada doğrudan uygulanıyor — ve bu, Flutter widget constructor'larının neredeyse tamamının yazıldığı şekildir.

Named Constructor — Alternatif Oluşturma Yolları

Bazen bir class'ı birden fazla farklı şekilde oluşturabilmek istersin. Dart, bunun için named constructor sunar:

dart
class Kisi {
  String isim;
  int yas;

  Kisi(this.isim, this.yas); // ana constructor

  Kisi.bebek(String isim) : isim = isim, yas = 0; // named constructor

  Kisi.bilinmeyen() : isim = "Bilinmiyor", yas = 0; // başka bir named constructor
}

void main() {
  Kisi kisi1 = Kisi("Ahmet", 25);
  Kisi kisi2 = Kisi.bebek("Yeni Doğan");
  Kisi kisi3 = Kisi.bilinmeyen();

  print(kisi2.isim); // Yeni Doğan
  print(kisi2.yas);  // 0
  print(kisi3.isim); // Bilinmiyor
}

Sözdizimi: ClassAdı.constructorAdı(parametreler) : alan1 = deger1, alan2 = deger2;

Bu, bir sonraki derste (initializer list) daha detaylı işleyeceğimiz bir sözdizimi — şimdilik "named constructor, class'ı farklı bir isimle ve farklı bir mantıkla oluşturmanın bir yolu" olarak bil.

Daha okunabilir bir named constructor örneği — this kısayoluyla:

dart
class Nokta {
  double x;
  double y;

  Nokta(this.x, this.y);

  Nokta.orijin() : x = 0, y = 0; // orijin noktası (0,0) için özel bir yol
}

void main() {
  Nokta n1 = Nokta(3, 4);
  Nokta n2 = Nokta.orijin();

  print("(${n1.x}, ${n1.y})"); // (3.0, 4.0)
  print("(${n2.x}, ${n2.y})"); // (0.0, 0.0)
}

Named constructor'lar, Flutter'da da çok sık karşına çıkacak — örneğin Text.rich(...) gibi, aynı widget'ı farklı senaryolar için farklı şekillerde oluşturmanı sağlayan yapılar bu prensiple çalışır.

Factory Constructor — Özel Oluşturma Mantığı

Normal bir constructor her zaman yeni bir nesne oluşturur. Ama bazen, oluşturma mantığının daha karmaşık olmasını istersin — örneğin, koşula göre farklı bir alt tip döndürmek, ya da var olan bir nesneyi (yeni oluşturmadan) döndürmek gibi. Bunun için factory constructor kullanılır:

dart
class Sekil {
  String tip;
  Sekil(this.tip);

  factory Sekil.dairesel() {
    print("Dairesel şekil oluşturuluyor...");
    return Sekil("Daire");
  }

  factory Sekil.koseli() {
    print("Köşeli şekil oluşturuluyor...");
    return Sekil("Kare");
  }
}

void main() {
  Sekil s1 = Sekil.dairesel();
  print(s1.tip); // Daire

  Sekil s2 = Sekil.koseli();
  print(s2.tip); // Kare
}

Normal constructor ile factory constructor arasındaki temel fark: Normal constructor, çağrıldığında her zaman yeni bir nesne (this) oluşturmak zorundadır. Factory constructor ise bir fonksiyon gibi davranır — içinde istediğin mantığı çalıştırabilir, var olan bir nesneyi (cache'den) döndürebilir, ya da koşula göre farklı bir alt sınıfın nesnesini döndürebilir. Bu ileri kullanımları (özellikle "singleton" deseni ve alt sınıf döndürme) Bölüm 7'de kalıtımı işledikten sonra çok daha anlamlı hale gelecek — şimdilik factory constructor'ın "oluşturma mantığını özelleştirebileceğin" bir araç olduğunu bilmen yeterli.

Nesne Oluşturma Sözdizimi — Eski vs Yeni

dart
void main() {
  // Eski Dart sürümlerinde 'new' anahtar kelimesi zorunluydu
  Kisi kisi1 = new Kisi("Ahmet", 25); // hâlâ çalışır ama...

  // Modern Dart'ta 'new' opsiyoneldir ve KULLANILMASI ÖNERİLMEZ
  Kisi kisi2 = Kisi("Ahmet", 25); // standart, tercih edilen yazım
}

class Kisi {
  String isim;
  int yas;
  Kisi(this.isim, this.yas);
}

Modern Dart kod tabanlarında new anahtar kelimesini görmeyeceksin — kaldırılması yönünde topluluk kararı alınmış ve artık gereksiz kabul ediliyor.


🎯 Bu Dersten Çıkarılması Gerekenler

  • class, bir nesnenin şablonudur; instance (örnek), o şablondan üretilen gerçek bir varlıktır.
  • Constructor, bir nesneyi oluştururken alanlarını doldurmayı sağlar.
  • this.alanAdi kısayolu, constructor gövdesi yazmadan alanları doğrudan doldurur.
  • Named constructor (Kisi.bebek() gibi), aynı class'ı farklı senaryolar için farklı yollarla oluşturmayı sağlar.
  • Factory constructor, oluşturma mantığını özelleştirmeye (cache, koşullu üretim, alt sınıf döndürme) izin verir.
  • Modern Dart'ta new anahtar kelimesi kullanılmaz.

📝 Ödevler

  • [ ] Bir Kitap sınıfı oluştur (başlık, yazar, sayfa sayısı alanları), this.alan kısayolu ile bir constructor yaz.
  • [ ] Aynı Kitap sınıfına, named parametreli (required ile) alternatif bir constructor daha ekle, ikisini de dene.
  • [ ] Kitap sınıfına Kitap.bosKitap() adında bir named constructor ekle — başlık "Bilinmiyor", yazar "Bilinmiyor", sayfa sayısı 0 olsun.
  • [ ] Basit bir factory constructor örneği yaz — örneğin bir Renk sınıfı için Renk.kirmizi(), Renk.mavi() gibi factory constructor'lar tanımla, her biri farklı bir hex değeriyle nesne döndürsün.
  • [ ] Kendi tanımladığın bir sınıftan 3 farklı nesne oluştur (varsayılan constructor, named constructor, factory constructor kullanarak), her birinin alanlarını yazdır.

Sıradaki konu: Bölüm 6 — Konu 28: Alanlar (Fields), Metodlar, this Kullanımı (Derinlemesine)

27. bölüm

Bölüm 6 — Konu 28: Alanlar (Fields), Metodlar, `this` Kullanımı (Derinlemesine)

Bir önceki derste class ve constructor'ların temelini gördük. Şimdi alanlar ve metodların daha ince detaylarına, ve this'in constructor dışındaki kullanımlarına odaklanalım.

Alan Tanımlama Yolları

dart
class Urun {
  String ad;           // constructor'da atanacak, zorunlu alan
  double fiyat;         // constructor'da atanacak, zorunlu alan
  int stokAdedi = 0;    // varsayılan değerle tanımlanan alan
  final String kategori; // final alan — bir kere atanır, değişmez

  Urun(this.ad, this.fiyat, this.kategori);
}

void main() {
  Urun urun1 = Urun("Kalem", 5.0, "Kırtasiye");
  print(urun1.stokAdedi); // 0 — varsayılan değer otomatik atandı
}

Dikkat edilmesi gerekenler:

  • String ad gibi varsayılan değeri olmayan bir alan, ya constructor'da atanmalı ya da nullable (String?) olmalı — Bölüm 2'de öğrendiğimiz null safety kuralı burada da geçerli.
  • int stokAdedi = 0 gibi bir alan, tanımlandığı anda varsayılan değer alır — constructor'da ayrıca belirtmesen bile bu değeri taşır.
  • final String kategori, Bölüm 2'de gördüğümüz final mantığının class alanlarına uygulanmış hali — bir kere atanır (constructor'da), sonra değiştirilemez.

final Alan — Neden Sık Kullanılır?

dart
class Kullanici {
  final String id; // benzersiz kimlik, asla değişmemeli
  String isim;      // bu değişebilir (kullanıcı adını güncelleyebilir)

  Kullanici(this.id, this.isim);
}

void main() {
  Kullanici k = Kullanici("USR001", "Ahmet");
  k.isim = "Ahmet Yılmaz"; // ✅ çalışır, isim final değil
  k.id = "USR002"; // ❌ HATA! id final, değiştirilemez
}

Bir alanın hiç değişmemesi gerektiğini biliyorsan (örneğin benzersiz bir ID, bir doğum tarihi), onu final yapmak hem güvenlik sağlar hem de niyetini net şekilde belgeler. Flutter'da widget'ların hemen tüm alanları final'dır — çünkü bir widget, bir kere oluşturulduktan sonra değişmez (immutable) olmalıdır; değişiklik gerektiğinde tamamen yeni bir widget oluşturulur (bunu Flutter tutorial'ında derinlemesine göreceğiz).

Metod Tanımlama ve this Kullanımı

dart
class HesapMakinesi {
  double sonuc = 0;

  void topla(double sayi) {
    this.sonuc = this.sonuc + sayi; // this ile açık erişim
  }

  void sifirla() {
    sonuc = 0; // this olmadan da çalışır (isim çakışması yoksa)
  }
}

void main() {
  HesapMakinesi hm = HesapMakinesi();
  hm.topla(5);
  hm.topla(3);
  print(hm.sonuc); // 8

  hm.sifirla();
  print(hm.sonuc); // 0
}

Önemli kural: Bir metod içinde, eğer parametre ile alan isim çakışması yoksa, this yazmak isteğe bağlıdır — Dart, sonuc yazdığında bunun class'ın alanı olduğunu otomatik anlar. this, sadece isim çakışması olduğunda (constructor'larda gördüğümüz gibi) zorunlu hale gelir. Yine de bazı geliştiriciler, netlik için metodlarda da this. yazmayı tercih eder — bu bir stil tercihidir.

Metodların Birbirini Çağırması

dart
class SepetHesaplayici {
  List<double> fiyatlar = [];

  void urunEkle(double fiyat) {
    fiyatlar.add(fiyat);
  }

  double araToplam() {
    double toplam = 0;
    for (var fiyat in fiyatlar) {
      toplam += fiyat;
    }
    return toplam;
  }

  double kdvDahilToplam() {
    return araToplam() * 1.20; // başka bir metodu çağırıyor
  }
}

void main() {
  SepetHesaplayici sepet = SepetHesaplayici();
  sepet.urunEkle(100);
  sepet.urunEkle(50);

  print(sepet.araToplam());       // 150.0
  print(sepet.kdvDahilToplam());  // 180.0
}

kdvDahilToplam() metodu içinde araToplam() çağrılırken this.araToplam() yazmadık — Dart, aynı class içindeki bir metodun başka bir metodu çağırdığını otomatik anlar, this yazmak gerekmez (ama yazmak da yanlış değildir, tamamen isteğe bağlı).

Metod Zincirleme (Method Chaining) — this Döndürme

dart
class MetinOlusturucu {
  String metin = "";

  MetinOlusturucu ekle(String parca) {
    metin += parca;
    return this; // kendi nesnesini döndürüyor
  }

  void yazdir() {
    print(metin);
  }
}

void main() {
  MetinOlusturucu().ekle("Merhaba").ekle(" ").ekle("Dünya").yazdir();
  // Merhaba Dünya
}

Burada ekle() metodu, işlemi yaptıktan sonra this (yani nesnenin kendisini) döndürüyor. Bu, method chaining (metod zincirleme) adı verilen bir kalıp — art arda birden fazla metodu, her seferinde ayrı bir değişkene atamadan, tek satırda çağırmanı sağlıyor. Bunu Flutter'da bazı API'lerde (özellikle StringBuffer gibi yardımcı sınıflarda) göreceksin.

toString() — Her Nesnenin Sahip Olduğu Metod

Bölüm 2'de "her şey bir nesnedir" demiştik — bunun bir sonucu, her class'ın (senin yazdıkların dahil) otomatik olarak bir toString() metoduna sahip olmasıdır:

dart
class Kisi {
  String isim;
  int yas;
  Kisi(this.isim, this.yas);
}

void main() {
  Kisi kisi = Kisi("Ahmet", 25);
  print(kisi); // Instance of 'Kisi' — pek faydalı değil!
}

Varsayılan toString(), pek okunabilir bir çıktı vermiyor. Bunu override ederek (bir üst sınıftan gelen davranışı kendi sınıfında değiştirerek — bunu Bölüm 7'de kalıtım konusunda tam olarak işleyeceğiz) daha anlamlı hale getirebiliriz:

dart
class Kisi {
  String isim;
  int yas;
  Kisi(this.isim, this.yas);

  @override
  String toString() {
    return "Kisi(isim: $isim, yas: $yas)";
  }
}

void main() {
  Kisi kisi = Kisi("Ahmet", 25);
  print(kisi); // Kisi(isim: Ahmet, yas: 25)
}

@override bir annotation'dır (Dart'a "bu metodu bilerek, üst sınıftan gelen bir davranışı değiştirmek için yazıyorum" diye bildirir). Bunu şimdilik sadece toString() bağlamında görüyoruz; Bölüm 7'de kalıtım konusunda çok daha kapsamlı işleyeceğiz.

Bir Sınıfın Metodları ile Fonksiyonlar Arasındaki İlişki

Aslında bir metod, "bir class'a bağlı bir fonksiyondur" diyebiliriz — Bölüm 5'te öğrendiğin her şey (parametreler, arrow function, closure mantığı) metodlar için de geçerlidir:

dart
class Matematik {
  int kare(int x) => x * x; // arrow function ile yazılmış bir metod

  int topla(int a, int b, {int carpan = 1}) => (a + b) * carpan; // named parametreli
}

void main() {
  Matematik m = Matematik();
  print(m.kare(5));               // 25
  print(m.topla(2, 3));           // 5
  print(m.topla(2, 3, carpan: 2)); // 10
}

🎯 Bu Dersten Çıkarılması Gerekenler

  • Alanlar varsayılan değerle, constructor ile veya nullable olarak tanımlanabilir; final alanlar bir kere atanır ve değişmez.
  • this, isim çakışması olmadığı sürece metodlarda isteğe bağlıdır (constructor'larda genelde zorunludur).
  • Bir class içindeki metodlar birbirini doğrudan çağırabilir, this yazmaya gerek yoktur.
  • Method chaining, bir metodun this döndürmesiyle art arda metod çağırmayı sağlar.
  • Her class'ın varsayılan bir toString() metodu vardır; @override ile bunu anlamlı hale getirebilirsin.
  • Metodlar, Bölüm 5'te öğrendiğimiz tüm fonksiyon özelliklerini (parametreler, arrow function vb.) taşır.

📝 Ödevler

  • [ ] Bir Dikdortgen sınıfı yaz — genislik ve yukseklik alanları normal, id alanı final olsun; final alana değer değiştirmeyi deneyip hatayı gözlemle.
  • [ ] Bir class içinde birbirini çağıran en az iki metod yaz (örn. araToplam() ve onu kullanan kdvDahilToplam()).
  • [ ] this döndüren, method chaining yapılabilen basit bir sınıf yaz (örn. bir Pizza sınıfı — .malzemeEkle("peynir").malzemeEkle("mantar") gibi zincirlenebilsin).
  • [ ] Kendi yazdığın bir sınıfa @override ile anlamlı bir toString() metodu ekle, print() ile test et.
  • [ ] Bir class içinde arrow function ile yazılmış, named parametreli bir metod tanımla.

Sıradaki konu: Bölüm 6 — Konu 29: Initializer List, Constructor Kısayolları (this.x) — Derinlemesine

28. bölüm

Bölüm 6 — Konu 29: Initializer List, Constructor Kısayolları (Derinlemesine)

Bir önceki derste named constructor'larda : işaretinden sonra gelen kısmı (Kisi.bebek(String isim) : isim = isim, yas = 0;) kısaca görmüştük. Şimdi bu initializer list (başlatıcı listesi) yapısını tam olarak işleyelim.

Initializer List Nedir?

Initializer list, bir constructor'ın gövdesi çalışmadan önce, alanlara değer atamak için kullanılan özel bir sözdizimidir:

dart
class Nokta {
  final double x;
  final double y;

  Nokta(double x, double y) : x = x, y = y; // initializer list
}

void main() {
  Nokta n = Nokta(3, 4);
  print("(${n.x}, ${n.y})"); // (3.0, 4.0)
}

Sözdizimi: ConstructorAdı(parametreler) : alan1 = ifade1, alan2 = ifade2 { gövde }

Bu örnekte gövde ({ }) bile yok çünkü tüm atama işi initializer list'te yapıldı.

Neden Initializer List'e İhtiyaç Var? — final Alanlarla İlişkisi

Bu, initializer list'in asıl var oluş sebebidir: final alanlar, normal bir constructor gövdesinde atanamaz!

dart
class Nokta {
  final double x;
  final double y;

  Nokta(double x, double y) {
    this.x = x; // ❌ HATA! final alan constructor GÖVDESİNDE atanamaz
    this.y = y;
  }
}

Neden? Çünkü Dart'ın kuralı gereği, final bir alan, nesnenin oluşturulma sürecinin tamamlanmasından önce (yani constructor gövdesi çalışmadan önce) atanmış olmalıdır. Initializer list, tam olarak bu ana denk gelir — gövdeden önce çalışır, bu yüzden final alanlara değer atamak için doğru yerdir.

Bu yüzden pratikte, final alanlı bir class'ta ya this.x kısayolunu (bir önceki derste gördüğümüz) ya da initializer list kullanman gerekir:

dart
class Nokta {
  final double x;
  final double y;

  // Yöntem 1: this.x kısayolu (Dart arka planda initializer list gibi davranır)
  Nokta(this.x, this.y);
}

Aslında this.x, this.y kısayolu, arka planda tam olarak initializer list'in yaptığı şeyi yapar — Dart bunu senin için otomatikleştirir. Initializer list'i elle yazman gereken durumlar, parametre adı ile alan adı farklı olduğunda veya atamadan önce bir hesaplama yapman gerektiğinde ortaya çıkar.

Initializer List'te Hesaplama Yapma

dart
class Dikdortgen {
  final double genislik;
  final double yukseklik;
  final double alan; // hesaplanan bir alan

  Dikdortgen(this.genislik, this.yukseklik) : alan = genislik * yukseklik;
}

void main() {
  Dikdortgen d = Dikdortgen(4, 5);
  print(d.alan); // 20.0 — constructor çağrıldığında otomatik hesaplandı
}

Burada alan, this.alan ile değil, initializer list'te bir ifade (genislik * yukseklik) ile atanıyor. Bu, this.x kısayolunun yapamayacağı bir şey — kısayol sadece "parametreyi doğrudan aynı isimli alana ata" der, ama burada alan parametre olarak gelmiyor, iki başka parametreden hesaplanıyor.

assert ile Initializer List İçinde Doğrulama

Bölüm 8'de assert'i detaylı işleyeceğiz ama initializer list ile birlikte kullanıldığını görmen faydalı:

dart
class Yas {
  final int deger;

  Yas(this.deger) : assert(deger >= 0, "Yaş negatif olamaz");
}

void main() {
  Yas y1 = Yas(25); // ✅ sorunsuz
  Yas y2 = Yas(-5); // ❌ assert hatası fırlatır (sadece debug modda aktif)
}

assert, initializer list'e eklenerek, nesne oluşturulurken bir koşulun sağlandığından emin olmayı sağlar — bu, geliştirme sürecinde hataları erken yakalamak için kullanışlı bir araçtır.

Redirecting Constructor — Bir Constructor'ın Başka Birini Çağırması

Bazen bir named constructor, ana constructor'ın aynı mantığını kullanmak ister, sadece bazı varsayılan değerlerle. Bunun için redirecting constructor (yönlendiren constructor) kullanılır:

dart
class Nokta {
  final double x;
  final double y;

  Nokta(this.x, this.y);

  // Bu constructor, doğrudan ana constructor'a YÖNLENDİRİYOR
  Nokta.orijin() : this(0, 0);
}

void main() {
  Nokta n = Nokta.orijin();
  print("(${n.x}, ${n.y})"); // (0.0, 0.0)
}

Sözdizimi: Nokta.orijin() : this(0, 0); — burada this(0, 0), ana constructor'ı x=0, y=0 parametreleriyle çağırıyor. Bu, kodu tekrar etmeden (aynı mantığı iki kere yazmadan) alternatif bir oluşturma yolu sağlamanın temiz bir yolu.

Önemli kural: Bir constructor ya initializer list ile alanlara doğrudan değer atayabilir ya da başka bir constructor'a yönlendirebilir (this(...)) — ikisini aynı anda yapamaz:

dart
class Nokta {
  final double x;
  final double y;

  Nokta(this.x, this.y);

  // ❌ HATA! Hem yönlendirme hem alan ataması aynı anda olamaz
  Nokta.hatali() : x = 1, this(0, 0);
}

Initializer List'te Birden Fazla Atama — Sıralama

dart
class Ogrenci {
  final String isim;
  final int numara;
  final String ozet;

  Ogrenci(this.isim, this.numara) : ozet = "$isim (No: $numara)";
}

void main() {
  Ogrenci o = Ogrenci("Elif", 42);
  print(o.ozet); // Elif (No: 42)
}

Initializer list'te birden fazla atama, virgülle ayrılarak yazılabilir. Burada ozet, diğer iki parametreden (this.isim, this.numara ile atanmış isim ve numara) hesaplanıyor — initializer list içinde, aynı listede daha önce atanmış alanlara erişebilirsin.

Özet — Ne Zaman Hangi Yöntem?

Senaryo Yöntem
Parametre adı = alan adı, doğrudan atama this.alanAdi kısayolu
Alan, parametrelerden hesaplanıyor Initializer list (: alan = ifade)
final alanlara atama gerekiyor this.x veya initializer list (ikisi de çalışır)
Alt sınıfın kendi mantığı var ama nesne oluşturmayı basitleştirmek istiyor Redirecting constructor (: this(...))
Nesne oluşturulurken bir koşul doğrulanmalı Initializer list içinde assert

🎯 Bu Dersten Çıkarılması Gerekenler

  • Initializer list, constructor gövdesinden önce çalışır ve final alanlara değer atamayı mümkün kılar.
  • this.x kısayolu, aslında arka planda initializer list gibi davranan bir kolaylıktır.
  • İnitializer list'te, parametrelerden hesaplanan değerler alanlara atanabilir.
  • assert, initializer list içinde nesne oluşturma anında doğrulama yapmak için kullanılabilir.
  • Redirecting constructor (this(...)), bir constructor'ın başka bir constructor'a yönlenmesini sağlar; initializer list ataması ile aynı anda kullanılamaz.

📝 Ödevler

  • [ ] final alanlı bir Renk sınıfı yaz (kırmızı, yeşil, mavi bileşenleri), initializer list kullanarak bu alanları ata.
  • [ ] Initializer list'te bir hesaplama yap — örneğin bir Cember sınıfında yaricap parametresinden cevre alanını (2 * 3.14159 * yaricap) hesapla.
  • [ ] Initializer list'te assert kullanarak, negatif bir değerin nesne oluşturulurken reddedildiği bir örnek yaz.
  • [ ] Redirecting constructor kullanarak, ana constructor'a yönlenen en az bir named constructor yaz (örn. Nokta.orijin() gibi).
  • [ ] Initializer list'te birden fazla alanı, biri diğerinden hesaplanacak şekilde (örn. tamAd = "$ad $soyad") atayan bir sınıf yaz.

Sıradaki konu: Bölüm 6 — Konu 30: Getter / Setter

29. bölüm

Bölüm 6 — Konu 30: Getter / Setter

Neden Getter/Setter'a İhtiyaç Var?

Bölüm 6'ya kadar, bir class'ın alanlarına doğrudan erişip değiştirebiliyorduk:

dart
class Dikdortgen {
  double genislik;
  double yukseklik;
  Dikdortgen(this.genislik, this.yukseklik);
}

void main() {
  Dikdortgen d = Dikdortgen(4, 5);
  d.genislik = -10; // ❌ mantıksal olarak hatalı ama Dart bunu engellemiyor!
  print(d.genislik); // -10 — negatif bir genişlik, anlamsız ama kabul edildi
}

Bu bir sorun — bir dikdörtgenin genişliği negatif olamaz, ama şu anki kodumuz bunu engelleyemiyor. Getter ve setter'lar, bir alana erişimi/değişimini kontrol altına almanı sağlayan mekanizmalardır.

Getter — Hesaplanmış Bir "Özellik" Tanımlama

dart
class Dikdortgen {
  double genislik;
  double yukseklik;

  Dikdortgen(this.genislik, this.yukseklik);

  double get alan {
    return genislik * yukseklik;
  }

  double get cevre => 2 * (genislik + yukseklik); // arrow ile kısa yazım
}

void main() {
  Dikdortgen d = Dikdortgen(4, 5);
  print(d.alan);  // 20.0 — parantez YOK, tıpkı bir alan gibi erişiliyor!
  print(d.cevre); // 18.0
}

Kritik detay: d.alan yazdık, d.alan() değil. Getter'lar, dışarıdan bakıldığında sıradan bir alan gibi görünür (parantezsiz erişilir), ama arka planda aslında bir metod gibi çalışır — her erişimde hesaplama yeniden yapılır.

Bunu neden bir alan olarak değil de getter olarak tanımlıyoruz? Çünkü alan, genislik ve yukseklik'ten türetilen bir değerdir — kendi başına saklanmasına gerek yoktur, her ihtiyaç duyulduğunda hesaplanabilir. Eğer alan'ı sıradan bir alan olarak tutsaydık, genislik her değiştiğinde alan'ı da elle güncellemen gerekirdi — bu, hataya çok açık bir yaklaşımdır (birini güncelleyip diğerini unutmak gibi). Getter, bu senkronizasyon sorununu tamamen ortadan kaldırır.

Setter — Bir Değeri Atarken Kontrol Uygulama

dart
class Dikdortgen {
  double _genislik; // alt çizgi ile başlıyor — "private" (birazdan açıklayacağız)

  Dikdortgen(this._genislik);

  double get genislik => _genislik;

  set genislik(double yeniDeger) {
    if (yeniDeger < 0) {
      print("Hata: Genişlik negatif olamaz, işlem reddedildi.");
      return;
    }
    _genislik = yeniDeger;
  }
}

void main() {
  Dikdortgen d = Dikdortgen(10);
  print(d.genislik); // 10.0

  d.genislik = 20; // setter çağrılıyor, parantez yok
  print(d.genislik); // 20.0

  d.genislik = -5; // setter içindeki kontrol devreye giriyor
  // Hata: Genişlik negatif olamaz, işlem reddedildi.
  print(d.genislik); // 20.0 — değişmedi!
}

Yapıyı parçalayalım:

  • _genislik — gerçek veriyi tutan private alan (alt çizgi ile başlıyor, birazdan açıklayacağız).
  • get genislik => _genislik; — dışarıya genislik adıyla okuma izni veren getter.
  • set genislik(double yeniDeger) { ... } — dışarıdan genislik'e yazma girişimini yakalayan, kontrol eden setter.

d.genislik = 20; yazdığında, aslında arka planda set genislik(20) metodun çalışıyor — ama sözdizimi olarak sanki doğrudan bir alana atama yapıyormuşsun gibi görünüyor. Bu, encapsulation (kapsülleme) dediğimiz OOP prensibinin temel bir uygulamasıdır: dış dünyaya basit bir arayüz (d.genislik) sunarken, arka planda kontrol mekanizmalarını gizli tutabiliyorsun.

_ (Alt Çizgi) — Private Alan/Metod Kuralı

Bölüm 1'de kısaca değindiğimiz alt çizgi kuralını burada tam olarak açıklayalım: Dart'ta, bir alan/metod/class adının başına _ koymak, onu o dosyaya (library) özel yapar — başka bir dosyadan doğrudan erişilemez hale gelir.

dart
// dikdortgen.dart dosyası
class Dikdortgen {
  double _genislik; // sadece bu dosya içinden erişilebilir
  Dikdortgen(this._genislik);
}
dart
// main.dart dosyası
import 'dikdortgen.dart';

void main() {
  Dikdortgen d = Dikdortgen(10);
  print(d._genislik); // ❌ HATA! Başka bir dosyadan private alana erişilemez
}

Bu, Java/C# gibi dillerdeki private anahtar kelimesine benzer bir işlev görür ama Dart'ta ayrı bir anahtar kelime yoktur — sadece isim kuralı (_ öneki) kullanılır. Bunun dosya (library) seviyesinde çalıştığını bilmen önemli — aynı dosya içindeki başka bir class, _genislik'e erişebilir, ama farklı bir dosyadaki class erişemez.

Neden Getter/Setter + Private Alan Kalıbı Bu Kadar Yaygın?

dart
class BankaHesabi {
  double _bakiye = 0;

  double get bakiye => _bakiye;

  void paraYatir(double miktar) {
    if (miktar <= 0) {
      print("Geçersiz miktar");
      return;
    }
    _bakiye += miktar;
  }

  void paraCek(double miktar) {
    if (miktar > _bakiye) {
      print("Yetersiz bakiye");
      return;
    }
    _bakiye -= miktar;
  }
}

void main() {
  BankaHesabi hesap = BankaHesabi();
  hesap.paraYatir(1000);
  print(hesap.bakiye); // 1000.0

  hesap.paraCek(2000); // Yetersiz bakiye
  print(hesap.bakiye); // 1000.0 — değişmedi

  hesap.bakiye = 5000; // ❌ HATA! bakiye için setter yok, sadece getter var
}

Bu örnek, çok önemli bir kalıbı gösteriyor: bakiye alanı için sadece getter tanımladık, setter tanımlamadık. Bu, bakiye'yi dışarıdan salt-okunur (read-only) yapıyor — değeri sadece paraYatir() ve paraCek() metodları aracılığıyla, kontrollü bir şekilde değiştirilebiliyor. Bu, gerçek dünyada bir banka hesabının nasıl çalışması gerektiğine çok benzer — bakiyeyi doğrudan "20000 yap" diyemezsin, sadece yatırma/çekme işlemleriyle değiştirebilirsin.

Getter/Setter Olmadan Sadece Getter Tanımlamak — Basit Kalıp

dart
class Kisi {
  final String ad;
  final String soyad;

  Kisi(this.ad, this.soyad);

  String get tamAd => "$ad $soyad"; // sadece getter, setter yok
}

void main() {
  Kisi k = Kisi("Ahmet", "Yılmaz");
  print(k.tamAd); // Ahmet Yılmaz

  k.tamAd = "Başka İsim"; // ❌ HATA! setter tanımlanmadı
}

tamAd, ad ve soyad'dan türetildiği için, ona doğrudan bir değer atamak zaten mantıksız olurdu — bu yüzden sadece getter tanımlamak, bu tür "salt hesaplanmış" özellikler için doğal ve doğru bir kalıptır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Getter (get), dışarıya bir alan gibi görünen ama aslında hesaplama yapan bir metoddur; parantezsiz çağrılır.
  • Setter (set), bir değeri atarken kontrol/doğrulama uygulamanı sağlar; nesne.alan = deger şeklinde çağrılır.
  • _ öneki, bir alan/metodu dosyaya (library) özel (private) yapar.
  • Yaygın kalıp: gerçek veriyi _alan olarak private tut, get/set ile kontrollü erişim sağla.
  • Sadece getter tanımlayıp setter tanımlamamak, bir özelliği dışarıdan salt-okunur yapmanın basit bir yoludur.

📝 Ödevler

  • [ ] Bir Daire sınıfı yaz — yaricap alanı olsun, alan ve cevre için getter'lar tanımla (hesaplanmış özellikler).
  • [ ] Bir Sicaklik sınıfı yaz — private bir _derece (Celsius) alanı olsun, negatif mutlak sıfırdan (-273.15) düşük bir değer atanmaya çalışıldığında reddeden bir setter yaz.
  • [ ] BankaHesabi örneğindeki gibi, sadece getter'ı olan (setter'ı olmayan) bir "salt-okunur" alan tasarla ve doğrudan atama yapmaya çalışarak hatayı gözlemle.
  • [ ] _ ile başlayan private bir alanı, aynı dosya içinde başka bir class'tan erişip erişemediğini test et (iki class'ı aynı dosyada tanımlayarak dene).
  • [ ] Sadece getter ile hesaplanan bir "tam ad" veya benzeri bir birleşik özellik tanımla, doğrudan atama yapmaya çalışıp hatayı gözlemle.

Sıradaki konu: Bölüm 6 — Konu 31: Statik Üyeler (static)

30. bölüm

Bölüm 6 — Konu 31: Statik Üyeler (`static`)

Bölüm 6'nın son konusundayız. Bu konu, "nesneye değil, class'ın kendisine ait" olan alan ve metodları işliyor.

Instance Üye vs Static Üye — Temel Fark

Şimdiye kadar gördüğümüz tüm alan ve metodlar instance üyesi idi — yani her nesnenin (instance) kendi kopyası vardı:

dart
class Kisi {
  String isim; // her nesnenin kendi 'isim'i var
  Kisi(this.isim);
}

void main() {
  Kisi k1 = Kisi("Ahmet");
  Kisi k2 = Kisi("Ayşe");

  print(k1.isim); // Ahmet
  print(k2.isim); // Ayşe — k1'den bağımsız, kendi değeri
}

Static bir üye ise, class'ın kendisine aittir — tüm nesneler arasında paylaşılır, her nesnenin ayrı bir kopyası olmaz:

dart
class Kisi {
  static int nesneSayisi = 0; // TÜM Kisi nesneleri arasında PAYLAŞILAN bir sayaç
  String isim;

  Kisi(this.isim) {
    nesneSayisi++; // her yeni nesne oluştuğunda paylaşılan sayaç artıyor
  }
}

void main() {
  print(Kisi.nesneSayisi); // 0 — henüz hiç nesne oluşturulmadı

  Kisi k1 = Kisi("Ahmet");
  print(Kisi.nesneSayisi); // 1

  Kisi k2 = Kisi("Ayşe");
  Kisi k3 = Kisi("Mehmet");
  print(Kisi.nesneSayisi); // 3
}

Kritik detay: Kisi.nesneSayisi şeklinde erişiyoruz — k1.nesneSayisi değil. Static üyelere, class adı üzerinden erişilir, çünkü onlar herhangi bir spesifik nesneye değil, class'ın kendisine aittir.

dart
void main() {
  Kisi k1 = Kisi("Ahmet");
  print(k1.nesneSayisi); // ❌ HATA! static üyeye nesne üzerinden erişilemez
}

Static Metod

dart
class MatematikYardimci {
  static int kare(int x) => x * x;
  static double pi = 3.14159;

  static double daireAlani(double yaricap) => pi * yaricap * yaricap;
}

void main() {
  print(MatematikYardimci.kare(5));          // 25
  print(MatematikYardimci.daireAlani(3));    // 28.27431
}

Static bir metod, hiçbir nesne oluşturmadan doğrudan class adı üzerinden çağrılabilir. Bunu, Dart'ın kendi standart kütüphanesinde de sürekli görmüştün aslında — int.parse(), double.parse() gibi metodlar (Bölüm 2'de gördüğümüz) aslında birer static metoddur!

dart
void main() {
  int sayi = int.parse("42"); // int.parse — static bir metod çağrısı
  print(sayi);
}

Ne Zaman static Kullanılır?

Static kullan, eğer:

  • Bir veri/davranış, belirli bir nesneye değil, tüm class'a ait bir kavramsa (örneğin MatematikYardimci.pi — pi sayısı, hiçbir spesifik "matematik nesnesine" ait değildir, evrensel bir sabittir).
  • Nesne oluşturmadan çağrılabilecek yardımcı (utility) fonksiyonlar yazıyorsan (örneğin bir dizi string işleme fonksiyonu).
  • Tüm nesneler arasında paylaşılması gereken bir sayaç/durum tutuyorsan (yukarıdaki nesneSayisi örneği gibi).

Static kullanma, eğer:

  • Veri, her nesneye özgüyse (örneğin bir kişinin isim'i — her kişinin kendi ismi olmalı, paylaşılmamalı).

Static Alan İçin Başlangıç Değeri

dart
class Ayarlar {
  static String uygulamaAdi = "Sipariş Takip"; // static alan, class yüklendiğinde bir kere ilklenir
  static const int maksimumDeneme = 3; // static const de sıkça kullanılır
}

void main() {
  print(Ayarlar.uygulamaAdi);      // Sipariş Takip
  print(Ayarlar.maksimumDeneme);   // 3
}

static const kombinasyonu, özellikle uygulama genelinde sabit kalması gereken değerler için çok yaygın bir kalıptır (örneğin bir API'nin base URL'i, maksimum dosya boyutu gibi sabitler).

Static Metod İçinde this Kullanılamaz

dart
class Ornek {
  int deger = 10;

  static void staticMetod() {
    print(this.deger); // ❌ HATA! static metod içinde 'this' yok
  }
}

Bu mantıklıdır — this, "şu anki nesne" anlamına gelir, ama static bir metod hiçbir nesneye bağlı değildir, doğrudan class üzerinden çağrılabilir. Bu yüzden static bir metod içinden, o class'ın instance alanlarına (nesneye özgü alanlara) doğrudan erişemezsin — çünkü "hangi nesnenin alanı?" sorusunun cevabı yoktur.

dart
class Ornek {
  int deger = 10;
  static int sayac = 0;

  static void staticMetod() {
    print(sayac); // ✅ çalışır — sayac da static, nesneye bağlı değil
    // print(deger); // ❌ HATA! deger instance alanı, static metoddan erişilemez
  }
}

Gerçek Dünya Örneği — Sabit Değerler Sınıfı (Constants Class)

Flutter projelerinde çok sık göreceğin bir kalıp:

dart
class AppRenkleri {
  static const int anaRenk = 0xFF2196F3; // hex renk kodu (şimdilik sadece bir int olarak düşün)
  static const int ikincilRenk = 0xFFFF5722;
}

class AppMetinleri {
  static const String hosgeldin = "Uygulamaya Hoş Geldiniz";
  static const String cikisOnay = "Çıkmak istediğinize emin misiniz?";
}

void main() {
  print(AppMetinleri.hosgeldin); // Uygulamaya Hoş Geldiniz
}

Bu kalıp, projenin her yerinde kullanılan sabit değerleri (renkler, metinler, ayarlar) tek bir merkezi yerde toplamanı sağlar — hiç nesne oluşturmadan, doğrudan AppRenkleri.anaRenk gibi erişilebilir. Flutter projelerinde bunu neredeyse her zaman göreceksin.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Instance üyeler her nesnenin kendi kopyasına sahiptir; static üyeler tüm nesneler arasında paylaşılır, class'a aittir.
  • Static üyelere ClassAdı.uyeAdı ile erişilir, nesne üzerinden değil.
  • Static metodlar nesne oluşturmadan çağrılabilir (int.parse() gibi Dart'ın kendi kütüphanesinde sıkça görürsün).
  • Static metod içinde this kullanılamaz ve instance alanlarına doğrudan erişilemez.
  • static const, uygulama genelinde sabit kalması gereken değerler için yaygın bir kalıptır.

📝 Ödevler

  • [ ] Bir class'a static bir sayaç ekle, her yeni nesne oluşturulduğunda bu sayacın arttığını 3 nesne oluşturarak kanıtla.
  • [ ] Nesne oluşturmadan çağrılabilen, iki sayıyı toplayan static bir metod yaz.
  • [ ] static const ile bir "sabitler" sınıfı yaz (örn. uygulama adı, versiyon numarası, maksimum kullanıcı sayısı gibi 3 sabit).
  • [ ] Bir class içinde hem static hem instance alan tanımla, static metod içinden instance alana erişmeyi dene, hatayı gözlemle ve yorumla.
  • [ ] int.parse(), double.parse() gibi Dart'ın kendi static metodlarından en az 2 tanesini daha bul (dokümantasyona bakabilir veya bildiklerini kullanabilirsin) ve neden static olmalarının mantıklı olduğunu açıkla.

🏁 Bölüm 6 Tamamlandı!

Nesne yönelimli programlamanın temellerini attık: class tanımlama, constructor türleri, initializer list, getter/setter ve static üyeler. Bu, Flutter'ın widget mimarisini anlamak için sağlam bir zemin oluşturuyor.

Sıradaki durak Bölüm 7 — Nesne Yönelimli Programlama (İleri): kalıtım (extends), soyut sınıflar, interface'ler, mixin'ler ve enum'larla OOP yolculuğumuza devam edeceğiz — bu bölüm, Flutter'da widget'ların birbirinden nasıl türediğini anlamak için doğrudan kritik olacak.

31. bölüm

Bölüm 7 — Konu 32: Kalıtım (`extends`), `super` Kullanımı

Bölüm 7'ye hoş geldin — nesne yönelimli programlamanın en güçlü araçlarından biri olan kalıtımı işliyoruz. Bu kavram, Flutter'da her widget'ın nasıl StatelessWidget veya StatefulWidget'tan türediğini anlamak için doğrudan temel oluşturacak.

Kalıtım Nedir?

Kalıtım (inheritance), bir class'ın başka bir class'ın özelliklerini ve davranışlarını devralmasıdır. "Devralan" class'a alt sınıf (subclass/child class), "devredilen" class'a üst sınıf (superclass/parent class) denir.

dart
class Hayvan {
  String isim;
  Hayvan(this.isim);

  void yeMek() {
    print("$isim yemek yiyor");
  }
}

class Kopek extends Hayvan {
  Kopek(String isim) : super(isim); // üst sınıfın constructor'ını çağırıyor
}

void main() {
  Kopek kopek = Kopek("Karabaş");
  kopek.yeMek(); // Karabaş yemek yiyor — Hayvan'dan devralınan metod!
}

extends anahtar kelimesi, Kopek sınıfının Hayvan sınıfından türediğini belirtir. Bunun sonucunda Kopek, Hayvan'ın tüm public alan ve metodlarını otomatik olarak kazanır — yeMek() metodunu Kopek içinde hiç yazmadık ama kopek.yeMek() çalıştı.

super — Üst Sınıfa Erişim

super, alt sınıftan üst sınıfın üyelerine (constructor, alan, metod) erişmek için kullanılır.

1. super ile Üst Sınıfın Constructor'ını Çağırma

dart
class Hayvan {
  String isim;
  int yas;
  Hayvan(this.isim, this.yas);
}

class Kedi extends Hayvan {
  String tuyRengi;

  Kedi(String isim, int yas, this.tuyRengi) : super(isim, yas);
  // super(isim, yas) → Hayvan constructor'ını çağırıyor
}

void main() {
  Kedi kedi = Kedi("Tekir", 3, "Turuncu");
  print("${kedi.isim}, ${kedi.yas} yaşında, ${kedi.tuyRengi} renkli");
  // Tekir, 3 yaşında, Turuncu renkli
}

Önemli kural: Eğer üst sınıfın constructor'ı parametre alıyorsa, alt sınıfın constructor'ı mutlaka super(...) ile bu parametreleri geçirmelidir (aksi halde derleme hatası alırsın). super(...) çağrısı, initializer list'in bir parçasıdır (Bölüm 6'da initializer list'i hatırla) ve her zaman initializer list'in en sonunda yer alır.

2. super ile Üst Sınıfın Metoduna Erişim

dart
class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kopek extends Hayvan {
  @override
  void sesCikar() {
    super.sesCikar(); // önce üst sınıfın davranışını çalıştır
    print("Hav hav!"); // sonra kendi ek davranışını ekle
  }
}

void main() {
  Kopek kopek = Kopek();
  kopek.sesCikar();
  // Bir hayvan sesi çıkarıyor
  // Hav hav!
}

Burada Kopek, sesCikar() metodunu override ediyor (bir sonraki derste tam olarak işleyeceğiz), ama super.sesCikar() ile üst sınıfın orijinal davranışını da çalıştırıyor, üzerine kendi davranışını ekliyor. Bu, üst sınıfın davranışını tamamen değiştirmek yerine, üzerine inşa etmek istediğinde kullanışlıdır.

Tek Seviyeli Kalıtım vs Çok Seviyeli Kalıtım

Dart, tek üst sınıftan kalıtımı destekler (Java/C# gibi "single inheritance" modeli — C++'taki gibi birden fazla sınıftan aynı anda extends yapamazsın). Ama kalıtım zincirlenebilir:

dart
class CanliVarlık {
  void nefes al() {}
}

Hmm, bu ismi düzeltelim — geçerli bir Dart tanımlayıcısı olmalı:

dart
class CanliVarlik {
  void nefesAl() {
    print("Nefes alıyor");
  }
}

class Hayvan extends CanliVarlik {
  void hareketEt() {
    print("Hareket ediyor");
  }
}

class Kopek extends Hayvan {
  void havla() {
    print("Hav!");
  }
}

void main() {
  Kopek kopek = Kopek();
  kopek.nefesAl();   // CanliVarlik'tan (2 seviye yukarıdan)
  kopek.hareketEt(); // Hayvan'dan (1 seviye yukarıdan)
  kopek.havla();     // kendi metodu
}

Kopek, Hayvan'dan, Hayvan da CanliVarlik'tan türüyor — bu bir kalıtım zinciri (hierarchy) oluşturuyor. Kopek, zincirdeki her seviyenin tüm public üyelerini devralır.

Object — Her Şeyin Üst Sınıfı (Hatırlatma)

Bölüm 2'de gördüğümüz gibi, Dart'ta her class, açıkça belirtmesen bile, örtük olarak Object'ten türer:

dart
class Kisi {
  // extends Object yazmasak da, Dart bunu otomatik varsayar
}

Bu yüzden her class, toString(), ==, hashCode gibi Object'in temel metodlarına otomatik olarak sahiptir (Bölüm 6'da toString() override etmiştik, hatırlarsan).

Kalıtımda Constructor Zorunluluğu

dart
class Hayvan {
  String isim;
  Hayvan(this.isim); // parametreli constructor, varsayılan (parametresiz) YOK
}

class Kopek extends Hayvan {
  Kopek() { // ❌ HATA! super(isim) çağrılmadı, ama Hayvan'ın parametresiz constructor'ı da yok
    print("Köpek oluşturuldu");
  }
}

Eğer üst sınıfın parametresiz (varsayılan) bir constructor'ı yoksa, alt sınıf mutlaka super(...) ile üst sınıfın parametreli constructor'ını açıkça çağırmalıdır:

dart
class Kopek extends Hayvan {
  Kopek(String isim) : super(isim) { // ✅ doğrusu
    print("Köpek oluşturuldu");
  }
}

Neden Kalıtım Kullanılır? — Kod Tekrarını Önleme

dart
// Kalıtım OLMADAN — kod tekrarı
class Daire {
  double yaricap;
  Daire(this.yaricap);
  void bilgiYazdir() => print("Bu bir şekil");
}

class Kare {
  double kenar;
  Kare(this.kenar);
  void bilgiYazdir() => print("Bu bir şekil"); // AYNI KOD tekrar yazıldı!
}
dart
// Kalıtım İLE — ortak davranış bir kere yazılır
class Sekil {
  void bilgiYazdir() => print("Bu bir şekil");
}

class Daire extends Sekil {
  double yaricap;
  Daire(this.yaricap);
}

class Kare extends Sekil {
  double kenar;
  Kare(this.kenar);
}

void main() {
  Daire d = Daire(5);
  Kare k = Kare(4);
  d.bilgiYazdir(); // Bu bir şekil
  k.bilgiYazdir(); // Bu bir şekil — kod tekrar yazılmadı!
}

Bu, kalıtımın temel değeridir: ortak davranışı bir kere, üst sınıfta tanımla; alt sınıflar bunu otomatik olarak kazansın. Bu prensip, Flutter'da her widget'ın StatelessWidget veya StatefulWidget'tan miras aldığı ortak davranışları (yaşam döngüsü metodları, build() gibi) anlamak için doğrudan kullanacağın bir temel.


🎯 Bu Dersten Çıkarılması Gerekenler

  • extends, bir class'ın başka bir class'ın özelliklerini devralmasını sağlar; devralan alt sınıf, devreden üst sınıftır.
  • super(...), alt sınıfın constructor'ından üst sınıfın constructor'ını çağırmak için kullanılır — initializer list'in bir parçasıdır.
  • super.metodAdi(), üst sınıfın bir metodunu, alt sınıftan çağırmak için kullanılır (genelde override edilen bir metodun üzerine davranış eklemek için).
  • Kalıtım zincirlenebilir (çok seviyeli olabilir); Dart tek üst sınıftan kalıtımı destekler.
  • Her class, örtük olarak Object'ten türer.
  • Kalıtım, ortak davranışı tek bir yerde tanımlayıp kod tekrarını önlemenin temel yoludur.

📝 Ödevler

  • [ ] Arac adında bir üst sınıf yaz (marka, model alanları ve bilgiVer() metodu), Otomobil adında bir alt sınıf ile extends kullanarak türet.
  • [ ] Üst sınıfın parametreli constructor'ını super(...) ile çağıran bir alt sınıf yaz.
  • [ ] Bir metodu alt sınıfta override edip içinde super.metodAdi() çağırarak hem üst sınıfın hem kendi davranışını birleştiren bir örnek yaz.
  • [ ] 3 seviyeli bir kalıtım zinciri kur (örn. CanliVarlik → Hayvan → Kus), her seviyenin bir metodu olsun, en alttaki class'tan hepsine eriş.
  • [ ] Kalıtım olmadan yazılmış, kod tekrarı içeren iki class'ı, ortak bir üst sınıf çıkararak kalıtımla yeniden düzenle.

Sıradaki konu: Bölüm 7 — Konu 33: Metod Override Etme, @override

32. bölüm

Bölüm 7 — Konu 33: Metod Override Etme, `@override`

Bir önceki derste sesCikar() örneğinde override'ı kısaca görmüştük. Şimdi bunu tam olarak işleyelim — bu, kalıtımın gerçek gücünü ortaya çıkaran kavramdır.

Override Nedir?

Override etmek, bir alt sınıfın, üst sınıftan devraldığı bir metodun davranışını kendi ihtiyacına göre değiştirmesidir.

dart
class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() {
    print("Miyav!");
  }
}

class Kopek extends Hayvan {
  @override
  void sesCikar() {
    print("Hav hav!");
  }
}

void main() {
  Hayvan h = Hayvan();
  Kedi k = Kedi();
  Kopek köpek = Kopek();

  h.sesCikar();      // Bir hayvan sesi çıkarıyor
  k.sesCikar();      // Miyav!
  köpek.sesCikar();  // Hav hav!
}

Kedi ve Kopek, Hayvan'dan sesCikar() metodunu devralıyor ama her biri kendi versiyonuyla değiştiriyor (override ediyor). Metod adı ve imzası (parametre tipleri, dönüş tipi) aynı kalmalı — sadece gövde (davranış) değişiyor.

@override Anotasyonu — Neden Önemli?

dart
class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() { // ✅ doğru — üst sınıfta gerçekten var olan bir metodu override ediyor
    print("Miyav!");
  }
}

@override, teknik olarak zorunlu değildir — onsuz da kod çalışır. Ama şiddetle önerilir, çünkü Dart derleyicisine "ben bilerek bir üst sınıf metodunu değiştiriyorum" der ve bu bir güvenlik ağı sağlar:

dart
class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikarr() { // yazım hatası! "sesCikar" değil "sesCikarr"
    print("Miyav!");
  }
}

Bu kod, @override sayesinde derleme zamanında hata verir — çünkü Dart, Hayvan sınıfında sesCikarr diye bir metod olmadığını görür ve "bunu override ettiğini iddia ediyorsun ama böyle bir metod yok" diye uyarır. Eğer @override yazmasaydık, bu kod sessizce derlenirdi — ama sesCikarr, aslında sesCikar'ı override etmiyor, tamamen yeni ve ayrı bir metod olarak eklenmiş olurdu. Bu, gerçek kodda fark edilmesi çok zor bir hataya yol açabilir. @override kullanmak, bu tür yazım hatalarını anında yakalamanı sağlar.

Polymorphism (Çok Biçimlilik) — Override'ın Asıl Gücü

dart
class Hayvan {
  void sesCikar() {
    print("Bir hayvan sesi çıkarıyor");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() => print("Miyav!");
}

class Kopek extends Hayvan {
  @override
  void sesCikar() => print("Hav hav!");
}

void tumHayvanlariSesletir(List<Hayvan> hayvanlar) {
  for (var hayvan in hayvanlar) {
    hayvan.sesCikar(); // her biri KENDİ override edilmiş versiyonunu çalıştırır!
  }
}

void main() {
  List<Hayvan> hayvanlar = [Kedi(), Kopek(), Hayvan()];
  tumHayvanlariSesletir(hayvanlar);
  // Miyav!
  // Hav hav!
  // Bir hayvan sesi çıkarıyor
}

Bu, polymorphism (çok biçimlilik) dediğimiz kavramın somut bir örneğidir: tumHayvanlariSesletir fonksiyonu, listedeki her elemanın gerçek tipinin ne olduğunu bilmek zorunda değildir — hepsine Hayvan gibi davranır (List<Hayvan>), ama her biri kendi override ettiği sesCikar() versiyonunu çalıştırır. Bu, Dart'ın çalışma zamanında, her nesnenin gerçek tipine göre doğru metodu seçmesi sayesinde olur (buna "dynamic dispatch" denir, ileri bir kavram — şimdilik sadece bu davranışın var olduğunu bilmen yeterli).

Bu neden bu kadar güçlü? Çünkü kod, genel (generic) bir şekilde yazılabilir — tumHayvanlariSesletir, gelecekte yeni bir hayvan türü (örneğin Kus) eklendiğinde hiç değişmeden çalışmaya devam eder, yeter ki Kus da Hayvan'dan türeyip sesCikar()'ı override etsin.

Üst Sınıfın Davranışını Tamamen Değiştirme vs Üzerine Ekleme

dart
class Calisan {
  double maasHesapla() {
    return 5000;
  }
}

class Yonetici extends Calisan {
  @override
  double maasHesapla() {
    return super.maasHesapla() + 2000; // üst sınıfın sonucunu al, üzerine ekle
  }
}

class Stajyer extends Calisan {
  @override
  double maasHesapla() {
    return 1500; // üst sınıfı hiç kullanmadan tamamen kendi mantığını yaz
  }
}

void main() {
  print(Calisan().maasHesapla());   // 5000.0
  print(Yonetici().maasHesapla());  // 7000.0 — 5000 + 2000
  print(Stajyer().maasHesapla());   // 1500.0 — tamamen farklı
}

Bu örnek, bir önceki derste gördüğümüz super.metodAdi() kullanımını override bağlamında pekiştiriyor: Yonetici, üst sınıfın davranışını temel alıp üzerine ekliyor; Stajyer ise üst sınıfı hiç kullanmadan tamamen kendi davranışını tanımlıyor. İkisi de geçerli override yaklaşımlarıdır, ihtiyaca göre seçilir.

Override Ederken Dikkat Edilmesi Gereken Kural — İmza Uyumu

dart
class Hayvan {
  void sesCikar(String ekstra) {
    print("Hayvan sesi: $ekstra");
  }
}

class Kedi extends Hayvan {
  @override
  void sesCikar() { // ❌ HATA! parametre eksik, üst sınıfla uyuşmuyor
    print("Miyav!");
  }
}

Override ederken, metodun parametre sayısı, tipleri ve dönüş tipi üst sınıftakiyle uyumlu olmalıdır (tam olarak aynı olması gerekmez ama tip sisteminin izin verdiği ölçüde uyumlu olmalı — buna "Liskov substitution principle" denir, ileri bir OOP prensibi). Basitçe: üst sınıfın imzasını değiştiremezsin, sadece gövdesini (davranışını) değiştirebilirsin.

toString() Override — Tekrar Hatırlatma

Bölüm 6'da gördüğümüz toString() override örneği, aslında tam olarak bu derste öğrendiğimiz mekanizmanın bir uygulamasıydı:

dart
class Kisi {
  String isim;
  Kisi(this.isim);

  @override
  String toString() => "Kisi: $isim"; // Object'ten gelen toString()'i override ediyoruz
}

void main() {
  print(Kisi("Ahmet")); // Kisi: Ahmet
}

Her class, örtük olarak Object'ten türediği için (Bölüm 7 Konu 32'de gördük), toString() de aslında Object sınıfından override edilen bir metoddur — şimdi bunun neden çalıştığını tam olarak anlıyorsun.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Override, bir alt sınıfın üst sınıftan devraldığı bir metodun davranışını değiştirmesidir; metod imzası aynı kalmalı.
  • @override zorunlu değildir ama şiddetle önerilir — yazım hatalarını derleme zamanında yakalamanı sağlar.
  • Polymorphism, farklı alt sınıfların aynı metodu farklı şekillerde override etmesi ve kodun bunları genel bir şekilde (üst sınıf tipi üzerinden) işleyebilmesidir.
  • super.metodAdi() ile üst sınıfın davranışının üzerine eklenebilir, ya da hiç çağrılmadan tamamen değiştirilebilir.
  • Override edilen metodun parametre ve dönüş tipleri üst sınıfla uyumlu olmalıdır.

📝 Ödevler

  • [ ] Sekil adında bir üst sınıf yaz (alanHesapla() metoduyla), Daire ve Kare alt sınıflarıyla bu metodu override et.
  • [ ] @override yazmadan bilerek bir yazım hatası (yanlış metod adı) yap, kodun sessizce derlendiğini gözlemle; sonra @override ekleyip hatanın nasıl yakalandığını gör.
  • [ ] List<Sekil> alıp içindeki her şeklin alanHesapla() sonucunu yazdıran bir fonksiyon yaz (polymorphism'i kullanarak) — en az 2 farklı şekil tipiyle test et.
  • [ ] Bir override'da super.metodAdi() çağırarak üst sınıfın davranışının üzerine ekleme yapan, başka bir override'da ise üst sınıfı hiç çağırmadan tamamen farklı davranan iki örnek yaz.
  • [ ] Kendi yazdığın bir class'ta toString() metodunu override ederek anlamlı bir çıktı üret, print() ile test et.

Sıradaki konu: Bölüm 7 — Konu 34: Soyut Sınıflar (abstract class)

33. bölüm

Bölüm 7 — Konu 34: Soyut Sınıflar (`abstract class`)

Soyut Sınıf Nedir?

Bazen bir üst sınıf yazarsın ama bu sınıftan hiçbir zaman doğrudan bir nesne oluşturulmasını istemezsin — sadece diğer sınıfların ondan türemesi (extend etmesi) için var olmasını istersin. Bu tür sınıflara soyut sınıf (abstract class) denir.

dart
abstract class Sekil {
  double alanHesapla(); // gövde YOK, sadece imza — "soyut metod"
}

void main() {
  Sekil s = Sekil(); // ❌ HATA! soyut sınıftan nesne oluşturulamaz
}

abstract anahtar kelimesi, bu sınıfın doğrudan Sekil() ile bir nesne oluşturmak için kullanılamayacağını belirtir. Neden? Çünkü alanHesapla() metodunun gövdesi (implementasyonu) yok — sadece "her Sekil'in bir alanHesapla metodu olmalı" diyoruz, ama bunun nasıl hesaplanacağını belirtmiyoruz (çünkü bir dairenin alanı ile bir karenin alanı tamamen farklı formüllerle hesaplanır — genel bir "şekil" için tek bir formül yazmak anlamsız).

Soyut Metod (Abstract Method)

dart
abstract class Sekil {
  double alanHesapla(); // soyut metod — sadece imza, noktalı virgülle biter

  void bilgiVer() { // normal (somut/concrete) metod — gövdesi var
    print("Bu şeklin alanı: ${alanHesapla()}");
  }
}

Bir soyut sınıf, hem soyut metodlar (gövdesiz) hem de somut metodlar (gövdeli) içerebilir. bilgiVer(), alanHesapla()'yı çağırıyor — ama alanHesapla()'nın gerçek implementasyonunu henüz bilmiyor. Bu, alt sınıfların sorumluluğudur.

Soyut Sınıftan Türeme — Zorunlu Implementasyon

dart
abstract class Sekil {
  double alanHesapla();
  void bilgiVer() {
    print("Bu şeklin alanı: ${alanHesapla()}");
  }
}

class Daire extends Sekil {
  double yaricap;
  Daire(this.yaricap);

  @override
  double alanHesapla() => 3.14159 * yaricap * yaricap;
}

class Kare extends Sekil {
  double kenar;
  Kare(this.kenar);

  @override
  double alanHesapla() => kenar * kenar;
}

void main() {
  Daire d = Daire(5);
  Kare k = Kare(4);

  d.bilgiVer(); // Bu şeklin alanı: 78.53975
  k.bilgiVer(); // Bu şeklin alanı: 16.0
}

Kritik kural: Sekil'den türeyen her sınıf (Daire, Kare), alanHesapla() metodunu mutlaka implemente etmek (override etmek) zorundadır. Eğer implemente etmezsen:

dart
class UcgenEksik extends Sekil {
  // alanHesapla() implemente edilmedi!
}

void main() {
  UcgenEksik u = UcgenEksik(); // ❌ HATA! soyut metod implemente edilmedi
}

Bu, derleme zamanında yakalanan bir hatadır — Dart, soyut bir metodun her alt sınıfta gerçekten implemente edildiğinden emin olmanı zorunlu kılar. Bu, "her Sekil'in kesinlikle bir alanHesapla() davranışı olacak" garantisini sağlar.

Soyut Sınıf ile Normal Kalıtım Arasındaki Fark

Özellik Normal Class Abstract Class
Doğrudan nesne oluşturulabilir mi? ✅ Evet ❌ Hayır
Soyut (gövdesiz) metod içerebilir mi? ❌ Hayır ✅ Evet
Somut (gövdeli) metod içerebilir mi? ✅ Evet ✅ Evet
Alt sınıflar soyut metodları implemente etmek zorunda mı? — ✅ Evet

Neden Soyut Sınıf Kullanılır?

Ana amaç: bir "sözleşme" (contract) tanımlamak. "Her Sekil'in bir alanHesapla() metodu olacak" demek, alt sınıflara bir zorunluluk yüklüyor — bu sayede, Sekil tipindeki herhangi bir nesneyle çalışan kod (Bölüm 7 Konu 33'teki polymorphism örneğini hatırla), her zaman güvenle alanHesapla()'yı çağırabileceğini bilir; çünkü Dart, her alt sınıfın bunu implemente ettiğini derleme zamanında garanti eder.

dart
double toplamAlan(List<Sekil> sekiller) {
  double toplam = 0;
  for (var sekil in sekiller) {
    toplam += sekil.alanHesapla(); // güvenle çağrılabilir, her Sekil'de KESİNLİKLE var
  }
  return toplam;
}

void main() {
  List<Sekil> sekiller = [Daire(3), Kare(4), Daire(2)];
  print(toplamAlan(sekiller)); // hepsinin alanı toplanır
}

Soyut Sınıfta Constructor Olabilir mi?

dart
abstract class Calisan {
  String isim;
  Calisan(this.isim); // soyut sınıfın constructor'ı olabilir!

  double maasHesapla(); // soyut metod
}

class TamZamanli extends Calisan {
  TamZamanli(String isim) : super(isim);

  @override
  double maasHesapla() => 10000;
}

void main() {
  TamZamanli t = TamZamanli("Ahmet");
  print("${t.isim}: ${t.maasHesapla()}"); // Ahmet: 10000.0
}

Evet, soyut bir sınıfın constructor'ı olabilir — ama bu constructor doğrudan çağrılamaz (Calisan("Ahmet") yazamazsın), sadece alt sınıfların super(...) ile çağırması için vardır. Bu, Bölüm 7 Konu 32'de öğrendiğimiz super mekanizmasının soyut sınıflarla birlikte nasıl çalıştığını gösteriyor.

Soyut Sınıf İçinde Alan Tanımlama

dart
abstract class Arac {
  String marka; // soyut sınıfta normal alan tanımlanabilir
  Arac(this.marka);

  int maksimumHiz(); // soyut metod

  void bilgiYazdir() {
    print("$marka - Maksimum hız: ${maksimumHiz()} km/s");
  }
}

class SporAraba extends Arac {
  SporAraba(String marka) : super(marka);

  @override
  int maksimumHiz() => 300;
}

void main() {
  SporAraba araba = SporAraba("Ferrari");
  araba.bilgiYazdir(); // Ferrari - Maksimum hız: 300 km/s
}

🎯 Bu Dersten Çıkarılması Gerekenler

  • abstract class, doğrudan nesne oluşturulamayan, sadece diğer sınıfların türemesi için var olan bir sınıftır.
  • Soyut metod (gövdesiz, sadece imza), her alt sınıfta zorunlu olarak implemente edilmelidir — bu derleme zamanında kontrol edilir.
  • Soyut sınıflar hem soyut hem somut metod içerebilir; somut metodlar soyut metodları çağırabilir.
  • Soyut sınıfın amacı, alt sınıflar için bir "sözleşme" (contract) tanımlamaktır — bu, polymorphism ile güvenle çalışmayı sağlar.
  • Soyut sınıfın constructor'ı olabilir ama sadece alt sınıflar tarafından super(...) ile çağrılabilir, doğrudan çağrılamaz.

📝 Ödevler

  • [ ] abstract class Hayvan yaz, soyut bir sesCikar() metodu tanımla; Kedi ve Kopek alt sınıflarıyla implemente et.
  • [ ] Soyut sınıftan doğrudan nesne oluşturmayı dene (Hayvan()), hatayı gözlemle.
  • [ ] Bir alt sınıfta bilerek soyut metodu implemente etme, hatayı gözlemle; sonra implemente edip düzelt.
  • [ ] Soyut sınıfa hem soyut hem somut bir metod ekle (somut metod, soyut metodu çağırsın), en az iki alt sınıfla test et.
  • [ ] List<SoyutSinifTipi> alan ve her elemanın soyut metodunu çağıran bir fonksiyon yaz (polymorphism ile), en az 2 farklı alt sınıfla test et.

Sıradaki konu: Bölüm 7 — Konu 35: Interface Mantığı (implements)

34. bölüm

Bölüm 7 — Konu 35: Interface Mantığı (`implements`)

Dart'ta "Interface" Kavramı — Java/C#'tan Farklı Bir Yaklaşım

Java veya C# bilen biri için önemli bir sürpriz: Dart'ta ayrı bir interface anahtar kelimesi yoktur. Bunun yerine, Dart'ta her class, örtük olarak bir interface'dir. implements anahtar kelimesiyle, herhangi bir class'ın "sözleşmesini" (yani tüm public metod ve alan imzalarını) başka bir class'a uygulatabilirsin.

dart
class Ucabilir {
  void uc() {
    print("Uçuyorum");
  }
}

class Kus implements Ucabilir {
  @override
  void uc() {
    print("Kuş kanat çırpıyor");
  }
}

void main() {
  Kus kus = Kus();
  kus.uc(); // Kuş kanat çırpıyor
}

implements ile extends Arasındaki Kritik Fark

Bu, Dart öğrenirken en çok karıştırılan noktalardan biridir — dikkatle inceleyelim:

extends ile: Alt sınıf, üst sınıfın davranışlarını (implementasyonlarını) da devralır. Override etmezsen, üst sınıfın kodu olduğu gibi çalışır.

implements ile: Alt sınıf, sadece imzaları (sözleşmeyi) devralır — davranışların hiçbirini otomatik almaz. Her metodu kendisi baştan implemente etmek zorundadır, üst sınıfta gövde olsa bile.

dart
class Ucabilir {
  void uc() {
    print("Genel uçma davranışı");
  }
}

class KusExtends extends Ucabilir {
  // uc()'yi override etmedik
}

class KusImplements implements Ucabilir {
  // uc()'yi implemente ETMEK ZORUNDAYIZ, yoksa hata!
  @override
  void uc() {
    print("Kuş uçma implementasyonu");
  }
}

void main() {
  KusExtends k1 = KusExtends();
  k1.uc(); // Genel uçma davranışı — extends ile devralınan kod ÇALIŞIYOR

  KusImplements k2 = KusImplements();
  k2.uc(); // Kuş uçma implementasyonu — implements ile KENDİ yazdığımız kod
}

Eğer KusImplements içinde uc()'yi implemente etmeseydik:

dart
class KusImplementsEksik implements Ucabilir {
  // uc() implemente edilmedi
}

void main() {
  KusImplementsEksik k = KusImplementsEksik(); // ❌ HATA!
}

Bu, tam olarak bir önceki derste gördüğümüz soyut metod davranışına benzer — implements kullandığında, sanki o class'ın tüm metodları soyutmuş gibi davranılır, hepsini yeniden yazman gerekir.

Neden implements Kullanılır?

Temel kullanım amacı: Bir class'ın davranışını değil, sadece şeklini (tipini) taklit etmek istediğinde. Bu, farklı, birbiriyle ilgisiz class'ların ortak bir "yetenek sözleşmesine" uymasını sağlar.

dart
class Yuzebilir {
  void yuz() => print("Yüzüyorum");
}

class Ucabilir {
  void uc() => print("Uçuyorum");
}

// Ördek, HEM yüzebilir HEM uçabilir — birden fazla interface implemente edilebilir!
class Ordek implements Yuzebilir, Ucabilir {
  @override
  void yuz() => print("Ördek su üzerinde yüzüyor");

  @override
  void uc() => print("Ördek alçaktan uçuyor");
}

void main() {
  Ordek ordek = Ordek();
  ordek.yuz(); // Ördek su üzerinde yüzüyor
  ordek.uc();  // Ördek alçaktan uçuyor
}

Bu, extends ile yapamayacağın bir şey! Bölüm 7 Konu 32'de öğrendiğimiz gibi, Dart tek üst sınıftan kalıtımı destekler — bir class aynı anda iki class'tan extends yapamaz. Ama implements ile, virgülle ayırarak birden fazla "sözleşmeye" aynı anda uyabilirsin. Bu, Dart'ın "çoklu kalıtım" (multiple inheritance) problemine getirdiği zarif bir çözümdür.

Soyut Sınıfları Interface Olarak Kullanma

Pratikte, implements genelde soyut sınıflarla birlikte kullanılır çünkü soyut sınıfların zaten çoğu (ya da tüm) metodu gövdesizdir — bu, tam olarak "sadece sözleşme" mantığına uyar:

dart
abstract class Depolanabilir {
  void kaydet();
  void yukle();
}

class DosyaDeposu implements Depolanabilir {
  @override
  void kaydet() => print("Dosyaya kaydedildi");

  @override
  void yukle() => print("Dosyadan yüklendi");
}

class BulutDeposu implements Depolanabilir {
  @override
  void kaydet() => print("Buluta kaydedildi");

  @override
  void yukle() => print("Buluttan yüklendi");
}

void main() {
  List<Depolanabilir> depolar = [DosyaDeposu(), BulutDeposu()];
  for (var depo in depolar) {
    depo.kaydet();
  }
  // Dosyaya kaydedildi
  // Buluta kaydedildi
}

Bu kalıp, çok yaygın bir tasarım desenidir (design pattern) — "farklı implementasyonları, ortak bir arayüz üzerinden değiştirilebilir kılmak." Örneğin, uygulamanın verisini bazen dosyaya, bazen buluta kaydetmek istiyorsan, kodun geri kalanı sadece Depolanabilir tipiyle çalışır, hangi somut implementasyonun kullanıldığından habersizdir.

extends mi, implements mı? — Karar Verme

Senaryo Kullan
Ortak davranışı paylaşmak istiyorsun (kod tekrarını önlemek) extends
Sadece bir "tip sözleşmesi" (bu class şu metodlara sahip olmalı) istiyorsun, davranışı değil implements
Birden fazla "yeteneği" aynı anda kazandırmak istiyorsun implements (birden fazla, virgülle)
Var olan bir davranışın üzerine ekleme/değiştirme yapmak istiyorsun extends + @override + super

implements ile Normal (Soyut Olmayan) Bir Class'ı Kullanmak

dart
class Hesaplayici {
  int topla(int a, int b) => a + b;
}

class OzelHesaplayici implements Hesaplayici {
  @override
  int topla(int a, int b) {
    print("Özel toplama işlemi çalıştı");
    return a + b;
  }
}

void main() {
  OzelHesaplayici h = OzelHesaplayici();
  print(h.topla(3, 4)); // Özel toplama işlemi çalıştı \n 7
}

Bu geçerlidir — implements, soyut olmayan (gövdeli metodlu) bir class'la da kullanılabilir, ama yine her metodu implemente etmen gerekir, üst class'ın orijinal implementasyonu (gövdesi) kullanılmaz.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ta ayrı bir interface anahtar kelimesi yoktur — her class örtük olarak bir interface'dir.
  • implements, sadece sözleşmeyi (tip imzalarını) devralır, davranışı (gövdeyi) devralmaz — her metod yeniden implemente edilmelidir.
  • extends, davranışı da devralır; override etmezsen üst sınıfın kodu çalışır.
  • Bir class, implements ile birden fazla "sözleşmeye" (virgülle ayırarak) aynı anda uyabilir — bu, extends'in tek üst sınıf kısıtlamasını aşan bir çözümdür.
  • implements, genelde soyut sınıflarla birlikte, farklı implementasyonları ortak bir tip üzerinden değiştirilebilir kılmak için kullanılır.

📝 Ödevler

  • [ ] Bir Ucabilir class'ı yaz, implements ile bir Kus class'ına uygulat; metodu implemente etmeden bırakıp hatayı gözlemle, sonra implemente et.
  • [ ] Aynı senaryoyu extends ile de yap, iki yaklaşım arasındaki davranış farkını (kod devralma vs sadece sözleşme) yorumla.
  • [ ] Bir class'a implements ile iki farklı "sözleşme" uygulat (örn. Yuzebilir ve Kosabilir), her ikisinin metodlarını da implemente et.
  • [ ] Soyut bir sınıf (abstract class Depolanabilir) tanımla, en az iki farklı class ile implements kullanarak farklı implementasyonlar yaz, List<Depolanabilir> üzerinde polymorphism ile test et.
  • [ ] extends ile mi yoksa implements ile mi çözülmesi gerektiğine karar vermen gereken bir senaryo düşün (örn. "bir Kedi hem Hayvan'dan davranış almalı hem de Evcil olma sözleşmesine uymalı"), buna göre kodu yaz.

Sıradaki konu: Bölüm 7 — Konu 36: Mixin (with)

35. bölüm

Bölüm 7 — Konu 36: Mixin (`with`)

Mixin Nedir? — extends ile implements Arasında Bir Orta Yol

Önceki iki derste iki kavram gördük:

  • extends: davranışı devralır ama sadece tek bir üst sınıftan
  • implements: birden fazla "sözleşmeye" uyabilir ama davranış devralmaz, her şeyi yeniden implemente etmen gerekir

Peki ya "birden fazla kaynaktan davranış devralmak" istersen? İşte tam burada mixin devreye giriyor — mixin, birden fazla class'tan davranışı (implementasyonu) bir class'a "karıştırmanı" (mix etmeni) sağlar.

dart
mixin Yuzebilir {
  void yuz() {
    print("Yüzüyorum");
  }
}

mixin Kosabilir {
  void kos() {
    print("Koşuyorum");
  }
}

class Insan with Yuzebilir, Kosabilir {
  // hiçbir metodu implemente etmedik ama HER İKİSİNİ de kullanabiliyoruz!
}

void main() {
  Insan insan = Insan();
  insan.yuz(); // Yüzüyorum — Yuzebilir'den geldi
  insan.kos(); // Koşuyorum — Kosabilir'den geldi
}

Dikkat et: Insan class'ı, yuz() veya kos() metodlarını hiç yazmadı, ama ikisini de kullanabiliyor — çünkü with anahtar kelimesi, mixin'lerin gerçek implementasyonunu (davranışını) class'a "karıştırıyor" (mix ediyor). Bu, implements'ten temel farkı: implements sadece imzayı devralır ve seni implemente etmeye zorlar, with ise gerçek çalışan kodu doğrudan devralır — tıpkı extends gibi.

mixin Anahtar Kelimesi

dart
mixin Loglanabilir {
  void logYaz(String mesaj) {
    print("[LOG] $mesaj");
  }
}

mixin, class tanımlamaya benzer ama özel bir amaç için tasarlanmıştır — doğrudan nesne oluşturmak için değil, başka class'lara davranış "karıştırmak" için kullanılır:

dart
void main() {
  Loglanabilir l = Loglanabilir(); // ❌ HATA! mixin'den doğrudan nesne oluşturulamaz
}

Neden Mixin Var? — Çoklu "Davranış Kaynağı" İhtiyacı

dart
class Ordek with Yuzebilir, Kosabilir {
  void ses() => print("Vak vak!");
}

class Balik with Yuzebilir {
  void ses() => print("...(balıklar sessizdir)");
}

class Atlet with Kosabilir {
  void ses() => print("Nefes nefese");
}

void main() {
  Ordek().yuz();  // Yüzüyorum
  Ordek().kos();  // Koşuyorum
  Balik().yuz();  // Yüzüyorum
  Atlet().kos();  // Koşuyorum
}

Bu örnek, mixin'in asıl gücünü gösteriyor: Ordek, Balik, Atlet — bunların hiçbiri birbirinin alt sınıfı değil (ortak bir üst sınıfları yok, olmasına da gerek yok) ama hepsi ihtiyaç duydukları davranışları (yüzme, koşma) mixin'lerden "karıştırarak" kazanabiliyorlar. Eğer bunu extends ile yapmaya çalışsaydık, tuhaf ve mantıksız bir kalıtım hiyerarşisi kurman gerekirdi (örneğin "YuzebilirVeKosabilirHayvan" gibi devasa, gereksiz bir üst sınıf).

Mixin vs Kalıtım — Ne Zaman Hangisi?

Senaryo Kullan
"X, bir Y'dir" ilişkisi var (Kedi bir Hayvan'dır) extends
"X, Y yapabilir" yeteneği var (Ördek yüzebilir) mixin (with)
Birden fazla bağımsız yetenek kazandırmak istiyorsun mixin (birden fazla, virgülle)
Sadece bir tip sözleşmesi istiyorsun, davranış değil implements

Bu ayrım önemlidir: kalıtım (extends), "is-a" (bir X'tir) ilişkisini modellemeli; mixin ise "can-do" (X yapabilir) yeteneğini modellemelidir. Bir Kus sınıfının Hayvan'dan extends etmesi mantıklıdır (bir kuş, bir hayvandır) — ama "uçabilme" yeteneğini bir mixin (with Ucabilir) olarak modellemek daha doğrudur, çünkü uçma, sadece kuşlara özgü değildir (yarasalar da uçar, ama yarasa bir kuş değildir).

on ile Mixin'i Belirli Tiplerle Sınırlama

dart
class Hayvan {
  String isim;
  Hayvan(this.isim);
}

mixin Ucabilir on Hayvan { // sadece Hayvan (veya alt sınıfı) olan class'lara uygulanabilir
  void uc() {
    print("$isim uçuyor"); // Hayvan'ın 'isim' alanına erişebiliyor!
  }
}

class Kus extends Hayvan with Ucabilir {
  Kus(String isim) : super(isim);
}

void main() {
  Kus kus = Kus("Kartal");
  kus.uc(); // Kartal uçuyor
}

on Hayvan ifadesi, bu mixin'in sadece Hayvan'dan türeyen class'lara uygulanabileceğini belirtir. Bu sayede, mixin içinde Hayvan'ın alanlarına (isim gibi) güvenle erişebiliyoruz — çünkü Dart, bu mixin'i kullanan her class'ın kesinlikle bir Hayvan olacağını garanti ediyor.

dart
class Araba with Ucabilir { // ❌ HATA! Araba, Hayvan'dan türemiyor
}

Birden Fazla Mixin'de Aynı Metod — Sıralama Önemli

dart
mixin A {
  void selamVer() => print("A'dan selam");
}

mixin B {
  void selamVer() => print("B'den selam");
}

class Ornek with A, B {} // B, A'dan SONRA geliyor

void main() {
  Ornek().selamVer(); // B'den selam — SONRAKİ mixin öncelikli
}

Eğer birden fazla mixin aynı isimde bir metod tanımlarsa, sonuncusu (en sağda/altta yazılan) kazanır. Bu, mixin'leri virgülle sıralarken dikkat etmen gereken bir detaydır — sıralama, hangi davranışın "üstün geleceğini" belirler.

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

Mixin'ler, Flutter'da da yaygın olarak kullanılır — örneğin bir widget'a animasyon yeteneği kazandırmak için SingleTickerProviderStateMixin gibi mixin'ler with ile eklenir (bunu Flutter tutorial'ında animasyon bölümünde detaylı göreceksin). Şimdiden bu deseni tanıman, ileride "neden bu class'a with ile bir şey ekleniyor" sorusuna hazırlıklı olmanı sağlayacak.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Mixin, with anahtar kelimesiyle, birden fazla kaynaktan gerçek davranışı (implementasyonu) bir class'a "karıştırmayı" sağlar.
  • mixin anahtar kelimesiyle tanımlanır, doğrudan nesne oluşturulamaz.
  • extends, "is-a" (bir şeydir) ilişkisini; mixin ise "can-do" (yapabilir) yeteneğini modellemelidir.
  • on TipAdı ile bir mixin'in sadece belirli bir tipten türeyen class'lara uygulanabilmesi sağlanabilir.
  • Birden fazla mixin aynı metodu tanımlarsa, sıralamada sonraki mixin öncelikli olur.

📝 Ödevler

  • [ ] Yuzebilir ve Ucabilir adında iki mixin yaz, bunları bir Ordek class'ına with ile ekle, her iki davranışı da test et.
  • [ ] Aynı yetenekleri (yüzme, koşma) birbiriyle ilgisiz iki farklı class'a (örn. Insan ve Robot) mixin ile kazandır — kalıtım hiyerarşisi kurmadan.
  • [ ] on anahtar kelimesiyle bir mixin'i belirli bir üst sınıfa bağla, o mixin'i uygunsuz bir class'a uygulamayı deneyip hatayı gözlemle.
  • [ ] İki mixin'de aynı isimli bir metod tanımla, bunları farklı sıralarda bir class'a ekleyip hangisinin "kazandığını" gözlemle.
  • [ ] Kendi senaryonu düşün — "is-a" ilişkisi mi yoksa "can-do" yeteneği mi olduğuna karar ver, buna göre extends veya mixin kullanarak modelle.

Sıradaki konu: Bölüm 7 — Konu 37: enum — Basit ve Gelişmiş (Metotlu Enum'lar)

36. bölüm

Bölüm 7 — Konu 37: `enum` — Basit ve Gelişmiş (Metotlu Enum'lar)

Bölüm 7'nin son konusundayız. enum (enumeration/sabit listesi), sınırlı sayıda, önceden bilinen değerlerden birini temsil eden özel bir tiptir.

Basit Enum

dart
enum TrafikIsigi { kirmizi, sari, yesil }

void main() {
  TrafikIsigi isik = TrafikIsigi.kirmizi;
  print(isik); // TrafikIsigi.kirmizi
  print(isik.name); // kirmizi — sadece ismi
}

Neden String yerine enum kullanılır?

dart
// ❌ Kötü pratik — String ile "durum" temsil etmek
String isikDurumu = "kirmizi";
isikDurumu = "morrr"; // yazım hatası! Ama derleyici bunu YAKALAYAMAZ

// ✅ İyi pratik — enum ile
TrafikIsigi isik = TrafikIsigi.kirmizi;
// isik = TrafikIsigi.morrr; // ❌ DERLEME HATASI! Böyle bir değer yok

enum, olası tüm değerleri derleme zamanında sabitler — geçersiz bir değer atamaya çalıştığında (yazım hatası gibi), Dart bunu anında yakalar. String ile aynı şeyi yapmaya çalışsaydın, hata ancak çalışma zamanında (belki hiç) fark edilirdi.

Enum ile switch — Exhaustiveness (Hatırlatma)

Bölüm 3'te kısaca önizlemesini gördüğümüz konuyu şimdi tam bağlamıyla pekiştirelim:

dart
enum TrafikIsigi { kirmizi, sari, yesil }

String eylemBelirle(TrafikIsigi isik) {
  return switch (isik) {
    TrafikIsigi.kirmizi => "Dur",
    TrafikIsigi.sari => "Hazırlan",
    TrafikIsigi.yesil => "Geç",
  };
}

void main() {
  print(eylemBelirle(TrafikIsigi.kirmizi)); // Dur
}

default (_) yazmadık çünkü tüm enum değerlerini kapsadık — Dart bunu doğrular. Eğer enum'a yeni bir değer eklenirse (örneğin turuncu), bu switch derleme zamanında eksik (non-exhaustive) olarak işaretlenir — böylece unutkanlıktan kaynaklı hatalar baştan engellenir.

Enum Üzerinde Gezinme — values

dart
enum Mevsim { ilkbahar, yaz, sonbahar, kis }

void main() {
  for (var mevsim in Mevsim.values) {
    print(mevsim.name);
  }
  // ilkbahar
  // yaz
  // sonbahar
  // kis
}

EnumAdi.values, o enum'un tüm değerlerini bir liste olarak verir — tüm olası durumlar üzerinde döngü kurmak istediğinde kullanışlıdır.

index — Enum Değerinin Sırası

dart
enum Mevsim { ilkbahar, yaz, sonbahar, kis }

void main() {
  print(Mevsim.ilkbahar.index); // 0
  print(Mevsim.yaz.index);      // 1
  print(Mevsim.kis.index);      // 3
}

Her enum değeri, tanımlandığı sıraya göre otomatik bir index (0'dan başlayan) alır.

Gelişmiş Enum — Alanlar ve Constructor ile (Dart 2.17+)

Modern Dart, enum'lara alan, constructor ve metod eklemene izin verir — bu, enum'ları çok daha güçlü hale getirir:

dart
enum Gezegen {
  merkur(kutle: 3.3, yaricap: 2439),
  venus(kutle: 4.8, yaricap: 6051),
  dunya(kutle: 5.9, yaricap: 6371);

  final double kutle;   // milyar kg cinsinden (basitleştirilmiş)
  final double yaricap; // km cinsinden

  const Gezegen({required this.kutle, required this.yaricap}); // enum constructor'ı HER ZAMAN const olmalı
}

void main() {
  print(Gezegen.dunya.kutle);   // 5.9
  print(Gezegen.dunya.yaricap); // 6371.0
}

Kritik kural: Enum constructor'ları her zaman const olmalıdır — çünkü enum değerleri, Bölüm 2'de öğrendiğimiz const mantığına uygun şekilde, derleme zamanında sabitlenen, tekil (singleton) nesnelerdir. Her Gezegen.dunya referansı, aynı, tek bir nesneye işaret eder.

Enum'a Metod Ekleme

dart
enum Gezegen {
  merkur(kutle: 3.3, yaricap: 2439),
  venus(kutle: 4.8, yaricap: 6051),
  dunya(kutle: 5.9, yaricap: 6371);

  final double kutle;
  final double yaricap;

  const Gezegen({required this.kutle, required this.yaricap});

  double get yogunlukOrani => kutle / yaricap; // getter — Bölüm 6'yı hatırla!

  String bilgiVer() => "Kütle: $kutle, Yarıçap: $yaricap"; // normal metod
}

void main() {
  print(Gezegen.dunya.bilgiVer());       // Kütle: 5.9, Yarıçap: 6371.0
  print(Gezegen.dunya.yogunlukOrani);    // hesaplanmış değer
}

Bu, Bölüm 6'da öğrendiğimiz her şeyin (constructor, alan, getter, metod) enum'lar için de geçerli olduğunu gösteriyor — modern Dart'ta enum, aslında sınırlı sayıda sabit nesnesi olan özel bir class gibi düşünülebilir.

Pratik Bir Örnek — Gün İsimleri ve Haftasonu Kontrolü

dart
enum Gun {
  pazartesi, sali, carsamba, persembe, cuma, cumartesi, pazar;

  bool get haftaSonuMu => this == Gun.cumartesi || this == Gun.pazar;
}

void main() {
  print(Gun.cuma.haftaSonuMu);        // false
  print(Gun.cumartesi.haftaSonuMu);   // true

  for (var gun in Gun.values) {
    print("${gun.name}: ${gun.haftaSonuMu ? "Haftasonu" : "Haftaiçi"}");
  }
}

Bu örnek, Bölüm 1'in ödevlerinde vaat ettiğimiz "gün isimlerini tutan ve haftasonu olup olmadığını döndüren metoda sahip enum" örneğinin tam çözümü — artık bunu gerçek anlamıyla yazabiliyorsun.

Enum ile Interface Implemente Etme (İleri Bir Not)

Modern Dart'ta enum'lar implements de kullanabilir (bir üst sınıfın sözleşmesine uyabilir) — bu, Bölüm 13'te sealed class ve pattern matching konusuna geldiğimizde daha da anlamlı hale gelecek bir özellik. Şimdilik sadece bu kapının açık olduğunu bilmen yeterli.


🎯 Bu Dersten Çıkarılması Gerekenler

  • enum, sınırlı ve önceden bilinen değerleri temsil eder; String ile aynı işi yapmaya çalışmaktan çok daha güvenlidir (derleme zamanı kontrolü sağlar).
  • EnumAdi.values, tüm enum değerlerini bir liste olarak verir; .index, değerin sırasını verir; .name, ismini string olarak verir.
  • switch ile kullanıldığında, tüm değerler kapsandığında default gerekmez — derleyici eksik durumları yakalar.
  • Modern Dart'ta enum'lara alan, constructor (her zaman const), getter ve metod eklenebilir — enum, aslında sınırlı sayıda sabit nesnesi olan özel bir class gibidir.

📝 Ödevler

  • [ ] HaftaGunu adında basit bir enum tanımla, values ile tüm günleri yazdır, .index ve .name özelliklerini kullan.
  • [ ] Bir enum ve bunu kullanan exhaustive bir switch expression yaz (default kullanmadan), sonra enum'a yeni bir değer ekleyip derleyicinin seni nasıl uyardığını gözlemle.
  • [ ] Alanlı ve constructor'lı bir enum yaz (örn. Meyve — isim ve kalori alanlarıyla), en az 3 değer tanımla.
  • [ ] Bu enum'a bir getter ekle (örn. dusukKalorili — kalorisi belirli bir eşiğin altındaysa true dönsün).
  • [ ] Gun enum örneğindeki gibi, kendi enum'una bir metod veya getter ekleyerek pratik bir kontrol mekanizması (örn. tatil günü mü, mesai saati mi) yaz.

🏁 Bölüm 7 Tamamlandı!

Nesne yönelimli programlamanın ileri konularını tamamladık: kalıtım, override, soyut sınıflar, interface'ler, mixin'ler ve gelişmiş enum'lar. Bu, Dart'ın OOP tarafında artık gerçekten sağlam bir temele sahip olduğun anlamına geliyor — ve bu bilgi, Flutter'da widget hiyerarşisini, StatelessWidget/StatefulWidget ayrımını ve birçok tasarım desenini anlamak için doğrudan kullanılacak.

Sıradaki durak Bölüm 8 — Hata Yönetimi & Null Safety Derinleşme: try/catch/finally, özel exception sınıfları yazma ve null safety'nin daha ileri detaylarıyla devam edeceğiz.

37. bölüm

Bölüm 8 — Konu 38: `try / catch / finally`, `throw`

Bölüm 8'e hoş geldin. Bu bölümde, programın beklenmedik durumlarla (hatalarla) nasıl güvenli bir şekilde başa çıkacağını öğreneceğiz.

Exception (İstisna) Nedir?

Bir program çalışırken, beklenmedik bir durumla karşılaşabilir — örneğin sıfıra bölme, geçersiz bir veri formatı, var olmayan bir dosyaya erişim gibi. Dart, bu tür durumları exception (istisna) olarak "fırlatır" (throw eder). Eğer bu istisna yakalanmazsa, program çöker.

dart
void main() {
  int a = 10;
  int b = 0;
  print(a ~/ b); // ❌ RUNTIME HATASI! IntegerDivisionByZeroException
  print("Bu satır hiç çalışmaz");
}

Bu programı çalıştırdığında, ~/ 0 satırında program çöker ve bir sonraki satır hiç çalışmaz.

try / catch — İstisnayı Yakalama

dart
void main() {
  int a = 10;
  int b = 0;

  try {
    print(a ~/ b);
  } catch (e) {
    print("Bir hata oluştu: $e");
  }

  print("Program devam ediyor!");
}

Çıktı:

metin
Bir hata oluştu: IntegerDivisionByZeroException
Program devam ediyor!

Yapıyı parçalayalım:

  • try { ... } — hata verebilecek kodu buraya yazarsın.
  • catch (e) { ... } — eğer try bloğunda bir hata oluşursa, buradaki kod çalışır; e, oluşan hatayı temsil eden bir değişkendir.

Bu sayede, hata oluşsa bile program çökmez, akış catch bloğuna geçer ve devam eder.

catch ile Hata Tipini Belirtme — on

dart
void main() {
  try {
    int a = 10;
    int b = 0;
    print(a ~/ b);
  } on IntegerDivisionByZeroException {
    print("Sıfıra bölme hatası!");
  } catch (e) {
    print("Başka bir hata: $e");
  }
}

on TipAdı, sadece belirli bir tip hatayı yakalamak istediğinde kullanılır. Bu, farklı hata türlerine farklı şekilde tepki vermeni sağlar:

dart
void main() {
  try {
    int sayi = int.parse("merhaba"); // FormatException fırlatır
  } on FormatException {
    print("Geçersiz sayı formatı!");
  } on IntegerDivisionByZeroException {
    print("Sıfıra bölme hatası!");
  } catch (e) {
    print("Bilinmeyen bir hata: $e");
  }
}

Dart, try bloğunda hata oluştuğunda, on bloklarını yukarıdan aşağıya sırayla kontrol eder ve hatanın tipine uyan ilk bloğu çalıştırır. Hiçbiri uymazsa, genel catch bloğu (varsa) devreye girer — bu, Bölüm 3'te öğrendiğimiz switch/else if mantığına benzer bir sıralı kontrol.

on ve catch'i Birlikte Kullanma — Hem Tip Hem Detay

dart
void main() {
  try {
    int sayi = int.parse("abc");
  } on FormatException catch (e) {
    print("Format hatası: ${e.message}");
  }
}

on FormatException catch (e), hem belirli bir tipi yakalıyor hem de o hatanın detaylarına (e.message gibi) erişim sağlıyor. FormatException'ın kendi özel alanları vardır (message gibi), bunlara e üzerinden ulaşabilirsin.

finally — Her Durumda Çalışan Blok

dart
void main() {
  try {
    print("Deneme yapılıyor");
    int sonuc = 10 ~/ 0;
  } catch (e) {
    print("Hata yakalandı: $e");
  } finally {
    print("Bu her durumda çalışır — hata olsa da olmasa da!");
  }
}

Çıktı:

metin
Deneme yapılıyor
Hata yakalandı: IntegerDivisionByZeroException
Bu her durumda çalışır — hata olsa da olmasa da!

finally bloğu, hata olsun ya da olmasın, her zaman çalışır. Bu, genelde temizlik işlemleri için kullanılır — örneğin bir dosyayı kapatmak, bir bağlantıyı sonlandırmak gibi işlemler, hata oluşsa bile mutlaka yapılması gereken işlerdir.

dart
void main() {
  try {
    print("İşlem başarılı");
  } finally {
    print("Temizlik yapılıyor");
  }
  // catch bloğu olmadan da finally kullanılabilir
}

throw — Kendi Hatanı Fırlatmak

Şimdiye kadar Dart'ın kendiliğinden fırlattığı hataları (IntegerDivisionByZeroException, FormatException) gördük. Kendi kodunda da, bir durumun "hata" olduğuna karar verip bunu bilerek fırlatabilirsin:

dart
void yasKontrolEt(int yas) {
  if (yas < 0) {
    throw Exception("Yaş negatif olamaz");
  }
  print("Yaş: $yas");
}

void main() {
  try {
    yasKontrolEt(-5);
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Çıktı:

metin
Hata yakalandı: Exception: Yaş negatif olamaz

throw, o anki fonksiyonun çalışmasını anında durdurur ve belirtilen hatayı "fırlatır" — bu hata, en yakın uygun try/catch bloğu tarafından yakalanana kadar, çağıran fonksiyonlar zinciri boyunca yukarı doğru "yayılır" (propagate olur).

throw ile Herhangi Bir Değer Fırlatılabilir mi?

dart
void main() {
  try {
    throw "Basit bir string hata"; // teknik olarak çalışır
  } catch (e) {
    print(e); // Basit bir string hata
  }
}

Teknik olarak throw, herhangi bir nesneyi fırlatabilir (sadece Exception sınıfından türeyen bir şey olması zorunlu değildir). Ama bu önerilmez — Dart'ın standart pratiği, Exception veya Error sınıflarından türeyen (ya da bunları doğrudan kullanan) nesneleri fırlatmaktır, çünkü bunlar daha fazla bilgi taşır ve on ExceptionTipi ile daha kolay yakalanabilir. Bunu bir sonraki derste (özel exception sınıfları) detaylı işleyeceğiz.

Hatayı Yakalayıp Tekrar Fırlatmak — rethrow

dart
void islemYap() {
  try {
    throw Exception("Bir sorun oluştu");
  } catch (e) {
    print("İşlem sırasında loglama yapılıyor: $e");
    rethrow; // hatayı tekrar fırlat, çağıran taraf da yakalasın
  }
}

void main() {
  try {
    islemYap();
  } catch (e) {
    print("main() içinde de yakalandı: $e");
  }
}

Çıktı:

metin
İşlem sırasında loglama yapılıyor: Exception: Bir sorun oluştu
main() içinde de yakalandı: Exception: Bir sorun oluştu

rethrow, bir hatayı yakalayıp bir şey yaptıktan sonra (örneğin loglama), aynı hatayı tekrar fırlatmanı sağlar — böylece hatayı çağıran üst kod da haberdar olur. Bu, "hatayı burada gözlemle ama tamamen yutma, üst katmanlara da bildir" senaryolarında kullanılır.

Stack Trace — Hatanın Nerede Oluştuğunu Görme

dart
void main() {
  try {
    int sonuc = 10 ~/ 0;
  } catch (e, stackTrace) {
    print("Hata: $e");
    print("Nerede oluştu: $stackTrace");
  }
}

catch (e, stackTrace) şeklinde ikinci bir parametre alarak, hatanın kod içinde tam olarak nerede oluştuğuna dair bilgiyi (call stack — hangi fonksiyonun hangi fonksiyonu çağırdığı zinciri) alabilirsin. Bu, özellikle karmaşık uygulamalarda hata ayıklarken (debugging) çok değerlidir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • try/catch, hata verebilecek kodu güvenli şekilde çalıştırmanı ve hatayı yakalayıp programın çökmesini engellemeni sağlar.
  • on TipAdı, belirli bir hata tipini hedeflemeni sağlar; birden fazla on bloğu sırayla kontrol edilir.
  • finally, hata olsun olmasın her zaman çalışır — temizlik işlemleri için kullanılır.
  • throw, kendi hatanı bilerek fırlatmanı sağlar; fonksiyonun çalışmasını anında durdurur.
  • rethrow, bir hatayı yakalayıp işlem yaptıktan sonra tekrar fırlatmanı sağlar.
  • catch (e, stackTrace), hatanın kod içinde nerede oluştuğuna dair detaylı bilgi verir.

📝 Ödevler

  • [ ] Sıfıra bölme hatasını try/catch ile yakalayan ve kullanıcıya anlamlı bir mesaj gösteren bir örnek yaz.
  • [ ] on FormatException ile int.parse()'ın geçersiz bir string ile çağrılmasını özel olarak yakala, genel catch ile diğer hataları ayrı yakala.
  • [ ] finally bloğunun hem hata olduğunda hem olmadığında çalıştığını gösteren iki ayrı test senaryosu yaz.
  • [ ] Kendi throw Exception(...) ifadeni kullanarak, negatif bir sayı girildiğinde hata fırlatan bir fonksiyon yaz, main() içinde yakala.
  • [ ] rethrow kullanarak, bir hatayı iç fonksiyonda loglayıp dış fonksiyonda tekrar yakalayan iki seviyeli bir örnek yaz.

Sıradaki konu: Bölüm 8 — Konu 39: Özel Exception Sınıfları Yazma

38. bölüm

Bölüm 8 — Konu 39: Özel Exception Sınıfları Yazma

Neden Kendi Exception Sınıfını Yazmalısın?

Bir önceki derste throw Exception("Yaş negatif olamaz") gibi genel Exception sınıfını kullandık. Bu çalışır ama bir sorunu var: tüm hataların aynı tipte (Exception) olması, on ile onları birbirinden ayırt etmeni zorlaştırır.

dart
void main() {
  try {
    // bir işlem
    throw Exception("Yaş negatif olamaz");
  } on Exception catch (e) {
    // Bu blok, HER türlü Exception'ı yakalar — hangi hata olduğunu ayırt edemeyiz
    print("Bir Exception oluştu: $e");
  }
}

Kendi özel exception sınıflarını yazarak, her hata türünü ayrı ayrı tanımlayıp on ile spesifik olarak yakalayabilirsin.

Basit Bir Özel Exception Sınıfı

dart
class GecersizYasException implements Exception {
  final String mesaj;
  GecersizYasException(this.mesaj);

  @override
  String toString() => "GecersizYasException: $mesaj";
}

void yasKontrolEt(int yas) {
  if (yas < 0) {
    throw GecersizYasException("Yaş negatif olamaz: $yas");
  }
  print("Yaş geçerli: $yas");
}

void main() {
  try {
    yasKontrolEt(-5);
  } on GecersizYasException catch (e) {
    print("Özel hata yakalandı: $e");
  }
}

Çıktı:

metin
Özel hata yakalandı: GecersizYasException: Yaş negatif olamaz: -5

Yapıyı parçalayalım:

  • class GecersizYasException implements Exception — Bölüm 7'de öğrendiğimiz implements ile, Exception'ın "sözleşmesine" uyuyoruz (Dart, Exception'ı aslında boş bir "marker interface" olarak tanımlar — herhangi bir zorunlu metodu yoktur, sadece "bu bir exception'dır" anlamını taşır).
  • final String mesaj — kendi özel alanımızı ekliyoruz, hatanın neden oluştuğuna dair bilgi taşıyor.
  • toString() override — Bölüm 6'da öğrendiğimiz gibi, print(e) çağrıldığında anlamlı bir çıktı vermesi için.

Birden Fazla Özel Exception ile Hata Hiyerarşisi Kurma

dart
class ValidasyonException implements Exception {
  final String mesaj;
  ValidasyonException(this.mesaj);
  @override
  String toString() => "ValidasyonException: $mesaj";
}

class GecersizYasException extends ValidasyonException {
  GecersizYasException(String mesaj) : super(mesaj);
}

class GecersizEmailException extends ValidasyonException {
  GecersizEmailException(String mesaj) : super(mesaj);
}

void kayitOlustur({required int yas, required String email}) {
  if (yas < 0) {
    throw GecersizYasException("Yaş negatif olamaz");
  }
  if (!email.contains("@")) {
    throw GecersizEmailException("Geçersiz email formatı");
  }
  print("Kayıt oluşturuldu");
}

void main() {
  try {
    kayitOlustur(yas: -5, email: "test@test.com");
  } on GecersizYasException catch (e) {
    print("Yaş hatası: $e");
  } on GecersizEmailException catch (e) {
    print("Email hatası: $e");
  } on ValidasyonException catch (e) {
    print("Genel validasyon hatası: $e");
  }
}

Burada Bölüm 7'de öğrendiğimiz kalıtım kavramını exception sınıflarına uyguladık: GecersizYasException ve GecersizEmailException, ortak bir üst sınıf olan ValidasyonException'dan türüyor. Bu sayede:

  • Spesifik hatayı yakalamak istersen on GecersizYasException kullanırsın.
  • Tüm validasyon hatalarını genel olarak yakalamak istersen on ValidasyonException kullanırsın (çünkü alt sınıflar da üst sınıf tipine "uyar" — polymorphism, Bölüm 7 Konu 33'ü hatırla).

Exception mı Error mı? — İkisi Arasındaki Fark

Dart'ta iki temel "hata" kategorisi vardır:

dart
void main() {
  // Exception — genelde İYİLEŞTİRİLEBİLİR (recoverable) durumlar için
  try {
    throw FormatException("Geçersiz format");
  } catch (e) {
    print("Yakalandı: $e");
  }

  // Error — genelde PROGRAMLAMA HATALARI için, yakalanması önerilmez
  try {
    List<int> liste = [];
    print(liste[5]); // RangeError fırlatır
  } catch (e) {
    print("Yakalandı: $e");
  }
}

Genel kural (Dart topluluğunun pratiği):

  • Exception: Programın çalışması sırasında beklenebilecek, iyileştirilebilir durumlar için (kullanıcının geçersiz veri girmesi, ağ bağlantısının kopması gibi). Bunları try/catch ile yakalamak normal ve önerilen bir pratiktir.
  • Error: Programlama hataları için (dizinin sınırları dışına erişmek, null bir değere erişmeye çalışmak gibi). Bunlar genelde kodundaki bir bug'ı işaret eder ve try/catch ile "yutulmamalı" — bunun yerine kodun kendisi düzeltilmelidir.

Kendi özel hata sınıflarını yazarken, genelde implements Exception kullanırsın (yukarıdaki örneklerde yaptığımız gibi) — çünkü kendi tanımladığın hatalar, genelde "beklenebilir, iyileştirilebilir" durumlardır (örneğin bir kullanıcı doğrulama hatası).

Gerçek Dünya Örneği — API Hata Yönetimi (Önizleme)

Bölüm 5'te HTTP istekleri ve API çağrılarını işleyeceğiz, ama şimdiden özel exception'ların orada nasıl kullanılacağına dair bir önizleme:

dart
class ApiException implements Exception {
  final int durumKodu;
  final String mesaj;
  ApiException(this.durumKodu, this.mesaj);

  @override
  String toString() => "ApiException($durumKodu): $mesaj";
}

class AgBaglantisiYokException implements Exception {
  @override
  String toString() => "AgBaglantisiYokException: İnternet bağlantısı yok";
}

// Bu fonksiyon, ileride gerçek bir API çağrısını temsil edecek (şimdilik simüle ediyoruz)
void veriGetir(bool baglantiVar, int durumKodu) {
  if (!baglantiVar) {
    throw AgBaglantisiYokException();
  }
  if (durumKodu != 200) {
    throw ApiException(durumKodu, "Sunucu hatası");
  }
  print("Veri başarıyla alındı");
}

void main() {
  try {
    veriGetir(true, 404);
  } on AgBaglantisiYokException catch (e) {
    print("Bağlantı sorunu: $e");
  } on ApiException catch (e) {
    print("API sorunu: $e (kod: ${e.durumKodu})");
  }
}

Bu kalıp — her farklı hata senaryosu için ayrı bir exception sınıfı — gerçek uygulamalarda (özellikle Flutter'da API çağrıları yaparken) çok yaygın bir pratiktir. Kullanıcıya "bir hata oluştu" gibi belirsiz bir mesaj yerine, hatanın tam olarak ne olduğuna göre (bağlantı yok mu, sunucu hatası mı, geçersiz veri mi) farklı ve anlamlı tepkiler verebilirsin.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Özel exception sınıfları, implements Exception ile tanımlanır ve kendi alanlarını (hata mesajı, kod vb.) taşıyabilir.
  • Kalıtım kullanarak (extends), hata sınıfları arasında bir hiyerarşi kurabilir, hem spesifik hem genel yakalama yapabilirsin.
  • Exception, iyileştirilebilir/beklenebilir durumlar için; Error, programlama hataları için kullanılır ve genelde yakalanmaz, kodun düzeltilmesi gerekir.
  • Farklı hata senaryoları için ayrı exception sınıfları tanımlamak, hataya özgü, anlamlı tepkiler vermeni sağlar.

📝 Ödevler

  • [ ] implements Exception kullanarak kendi GecersizSifreException sınıfını yaz, bir şifre doğrulama fonksiyonunda kullan.
  • [ ] Ortak bir üst sınıftan (ValidasyonException gibi) türeyen en az iki özel exception sınıfı yaz, hem spesifik hem genel on blokları ile yakala.
  • [ ] Kendi exception sınıfına, hata mesajının yanında ek bir bilgi (örn. bir hata kodu veya zaman damgası) ekle, toString() içinde göster.
  • [ ] Bir senaryoda Exception kullanmanın, bir başka senaryoda ise Error'un neden daha uygun olacağını (kendi örneklerinle) karşılaştırmalı olarak açıkla.
  • [ ] "API hata yönetimi" örneğindeki gibi, en az iki farklı özel exception sınıfıyla, farklı hata durumlarına farklı tepkiler veren bir simülasyon yaz.

Sıradaki konu: Bölüm 8 — Konu 40: Sound Null Safety Derinlemesine — late, required, Non-Nullable Varsayılan Davranış

39. bölüm

Bölüm 8 — Konu 40: Sound Null Safety Derinlemesine — `late`, `required`, Non-Nullable Varsayılan Davranış

Bölüm 2'de null safety'nin temellerini (?, ?., ??, !, late) görmüştük. Şimdi bunun "sound" (sağlam/kanıtlanabilir) olmasının ne anlama geldiğini ve daha ileri detaylarını işleyeceğiz.

"Sound" Null Safety Ne Demek?

Dart'ın null safety sistemi, sadece bir "öneri" veya "uyarı" sistemi değildir — matematiksel olarak kanıtlanabilir bir garanti sunar: eğer bir değişken non-nullable (String gibi, String? değil) olarak tanımlandıysa, Dart derleyicisi bunun hiçbir koşulda null olamayacağını %100 garanti eder.

dart
void main() {
  String isim = "Ahmet";
  // Bu satırdan sonra, kod içinde HİÇBİR yol yok ki 'isim' null olsun.
  // Bu, "sound" (sağlam) olmanın anlamı — derleyici bunu matematiksel olarak kanıtlayabilir.
  print(isim.length); // asla null reference hatası veremez, GARANTİ
}

Bu, örneğin TypeScript gibi bazı dillerin "null safety" yaklaşımından daha güçlüdür — TypeScript'te bazı durumlarda (özellikle JavaScript kütüphaneleriyle etkileşimde) tip sistemi "yanılabilir", ama Dart'ın sound null safety'si, dilin temelinde yer aldığı için bu tür kaçaklara izin vermez.

late — Derinlemesine Kullanım Senaryoları

Bölüm 2'de late'i tanımıştık. Şimdi gerçek kullanım senaryolarını görelim.

Senaryo 1: Sınıf Alanının Constructor Dışında Atanması

dart
class VeriYoneticisi {
  late String veri; // constructor'da atanmıyor ama non-nullable

  void veriYukle() {
    veri = "Sunucudan gelen veri"; // burada atanıyor
  }

  void veriGoster() {
    print(veri);
  }
}

void main() {
  VeriYoneticisi yonetici = VeriYoneticisi();
  yonetici.veriYukle();
  yonetici.veriGoster(); // Sunucudan gelen veri
}

Burada veri, constructor'da hemen atanmıyor (çünkü belki bir API çağrısından sonra dolacak) ama String? yapmak da istemiyoruz çünkü mantıksal olarak, veriYukle() çağrıldıktan sonra bu alan asla null olmamalı. late, bu ara durumu doğru şekilde modellememizi sağlıyor.

Eğer veriYukle() çağrılmadan veriGoster() çağrılırsa:

dart
void main() {
  VeriYoneticisi yonetici = VeriYoneticisi();
  yonetici.veriGoster(); // ❌ RUNTIME HATASI! LateInitializationError
}

Bu bir runtime hatası — late kullanmak, "bu değişkenin bir gün atanacağına söz veriyorum" demektir, ama Dart bunu derleme zamanında doğrulayamaz (çünkü hangi sırayla metod çağıracağını bilemez). Bu, late kullanırken bilinçli olman gereken bir risktir — Bölüm 2'de "riskli" olarak nitelediğimiz ! operatörüne benzer bir güven ilişkisi kurar.

Senaryo 2: Pahalı Hesaplamaları Geciktirme (Lazy Initialization)

dart
class Rapor {
  late final List<int> buyukVeriListesi = _agirHesaplamaYap();

  List<int> _agirHesaplamaYap() {
    print("Ağır hesaplama çalışıyor...");
    return List.generate(1000000, (i) => i);
  }
}

void main() {
  print("Rapor nesnesi oluşturuluyor");
  Rapor rapor = Rapor(); // "Ağır hesaplama çalışıyor..." henüz YAZDIRILMAZ!

  print("Şimdi veriye erişiyoruz");
  print(rapor.buyukVeriListesi.length); // İLK erişimde hesaplama çalışır
}

Çıktı:

metin
Rapor nesnesi oluşturuluyor
Şimdi veriye erişiyoruz
Ağır hesaplama çalışıyor...
1000000

Bu, lazy initialization (tembel başlatma) denen bir kalıptır: late final, alanın değerinin ilk erişildiği anda hesaplanmasını sağlar, nesne oluşturulduğu anda değil. Eğer bu alana hiç erişilmezse, pahalı hesaplama hiç çalışmaz — bu, performans açısından değerli bir optimizasyondur (gereksiz işlem yapılmaz).

late final — İkisi Birlikte: Dikkat et, late ile final birlikte kullanılabilir — "geç başlatılacak ama bir kere atandıktan sonra değişmeyecek" anlamına gelir. Bu, late'in en yaygın kullanım şekillerinden biridir.

required — Derinlemesine

Bölüm 5'te fonksiyon parametrelerinde required'ı görmüştük. Bunun null safety ile ilişkisini netleştirelim:

dart
void kayitOlustur({required String kullaniciAdi, String? bio}) {
  print("Kullanıcı: $kullaniciAdi");
}

required, aslında null safety'nin fonksiyon parametrelerine uygulanmış halidir. kullaniciAdi, non-nullable (String, String? değil) olduğu için, zaten "bu asla null olamaz" garantisi taşıyor — ama named parametreler varsayılan olarak optional olduğundan, Dart'ın "bu parametrenin verilmesi zorunlu" olduğunu ayrıca belirtmen gerekiyor. required, bu iki kuralı (non-nullable olmalı + verilmesi zorunlu) birleştiriyor.

required olmadan non-nullable named parametre mümkün mü?

dart
void ornek({String kullaniciAdi = "Misafir"}) {
  // required olmadan da non-nullable olabilir, EĞER varsayılan değer varsa
  print(kullaniciAdi);
}

Evet — eğer bir varsayılan değer verirsen, required yazmana gerek kalmaz, çünkü parametre hiç verilmese bile asla null olmayacağı garanti altındadır (varsayılan değer devreye girer).

Non-Nullable'ın Varsayılan Davranışı — Neden Bu Kadar Katı?

dart
class Kullanici {
  String isim; // varsayılan olarak non-nullable
  int yas;     // varsayılan olarak non-nullable

  Kullanici(this.isim, this.yas);
}

Dart'ın tasarım felsefesi şu: "Nullable olmak istisna olmalı, non-nullable olmak kural olmalı." Bu, birçok eski dilin (Java, C# başlangıçta, JavaScript) tam tersi bir yaklaşımdır — onlarda her şey varsayılan olarak nullable'dı ve sen özellikle "bu null olamaz" demen gerekiyordu (ya da hiç böyle bir mekanizma yoktu). Dart, bu durumu tersine çevirerek, geliştiricinin bilinçli olarak "bu değer null olabilir" demesini zorunlu kılıyor — bu, null ile ilgili hataların çoğunu daha kod yazılırken önlüyor.

Migration (Geçiş) Notu — Eski Kod ile Yeni Kod

Dart 2.12 öncesi yazılmış kodlar (null safety olmadan) hâlâ var olabilir. Eğer eski bir pakete bağımlıysan, Dart bunu "legacy" (miras) tip sistemiyle ele alır — bu, ileri bir konu ve muhtemelen Flutter'a geçtiğinde nadiren karşına çıkacak bir durum, ama var olduğunu bilmen faydalı: eski, null-safety'siz kodla yeni kod bir arada çalışabilir, Dart bu geçişi yönetir.

Null Safety'nin Koleksiyonlarla İlişkisi — Kısa Bir Hatırlatma

Bölüm 4'te Map üzerinde [] erişiminin neden nullable döndürdüğünü görmüştük (yaslar["Olmayan"] → null). Bu, sound null safety'nin koleksiyonlara tutarlı şekilde uygulanmasının bir örneğiydi — Dart, "bu anahtar var mı yok mu, derleme zamanında bilemem" dediği için, sonucu dürüstçe nullable olarak işaretliyor.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Sound null safety, "bir değişken non-nullable ise asla null olamaz" garantisini matematiksel olarak kanıtlanabilir şekilde sağlar.
  • late, hem "constructor dışında atanacak ama non-nullable" hem de "lazy initialization" (ilk erişimde hesaplama) senaryolarında kullanılır.
  • late final, geç başlatılan ama bir kere atandıktan sonra değişmeyen alanlar için yaygın bir kombinasyondur.
  • required, non-nullable + "verilmesi zorunlu" garantisini named parametrelere uygular; varsayılan değer varsa required gerekmez.
  • Dart'ın felsefesi: nullable olmak istisna, non-nullable olmak kuraldır — bu, null hatalarının çoğunu kod yazılırken önler.

📝 Ödevler

  • [ ] late bir alan tanımla, önce atamadan erişip LateInitializationError hatasını gözlemle, sonra doğru sırada atayıp düzelt.
  • [ ] late final ile lazy initialization örneği yaz — bir "pahalı hesaplama" fonksiyonunun sadece ilk erişimde çalıştığını print ile kanıtla.
  • [ ] Named bir parametreyi hem required ile hem varsayılan değerle (ikisi ayrı örnekte) non-nullable yap, farklarını yorumla.
  • [ ] Bir sınıfta, constructor'da hemen atanamayan ama "sonradan kesinlikle atanacak" bir alanı late ile modelle (örn. bir "kullanıcı profili yüklendiğinde dolacak" alan).
  • [ ] Kendi cümlelerinle, "neden Dart varsayılan olarak her şeyi non-nullable yapıyor" sorusunu, bu dersten öğrendiklerinle açıkla.

Sıradaki konu: Bölüm 8 — Konu 41: assert ile Geliştirme Zamanı Kontrolleri

40. bölüm

Bölüm 8 — Konu 41: `assert` ile Geliştirme Zamanı Kontrolleri

Bölüm 8'in son konusundayız. assert'i Bölüm 6'da initializer list içinde kısaca görmüştük — şimdi bunu tam olarak işleyip, hata yönetimiyle olan ilişkisini netleştireceğiz.

assert Nedir?

assert, bir koşulun doğru olduğunu varsaydığın yerlerde, bu varsayımı açıkça doğrulamak için kullanılan bir araçtır:

dart
void main() {
  int yas = 25;
  assert(yas >= 0, "Yaş negatif olamaz");
  print("Yaş: $yas");
}

Eğer assert içindeki koşul false ise, program bir AssertionError fırlatır:

dart
void main() {
  int yas = -5;
  assert(yas >= 0, "Yaş negatif olamaz"); // ❌ AssertionError fırlatır
  print("Bu satır hiç çalışmaz");
}

assert ile throw/Exception Arasındaki Kritik Fark

Bu, assert'in en önemli ve en sık yanlış anlaşılan özelliğidir: assert, sadece "debug" modda çalışır — üretim (release/production) modunda tamamen devre dışı kalır ve hiçbir performans maliyeti getirmez!

dart
void islemYap(int deger) {
  assert(deger > 0, "Değer pozitif olmalı"); // sadece debug modda kontrol edilir
  print("İşlem yapılıyor: $deger");
}

Bunu Exception ile karşılaştıralım:

dart
void islemYapGuvenli(int deger) {
  if (deger <= 0) {
    throw Exception("Değer pozitif olmalı"); // HER ZAMAN kontrol edilir, debug/release fark etmez
  }
  print("İşlem yapılıyor: $deger");
}

Bu fark neden önemli?

assert throw / Exception
Debug modda çalışır mı? ✅ Evet ✅ Evet
Release (üretim) modda çalışır mı? ❌ Hayır — tamamen kaldırılır ✅ Evet, her zaman çalışır
Performans maliyeti (release'te) Yok (kod derlemede kaldırılır) Var (her zaman çalışır)
Kullanım amacı Geliştirici hatalarını erken yakalamak Kullanıcı/dış dünya kaynaklı hataları yönetmek

Ne Zaman assert, Ne Zaman Exception Kullanılmalı?

assert kullan, eğer:

  • Kontrol ettiğin şey, senin kendi kod mantığının bir varsayımı ise ("bu fonksiyona asla negatif bir değer gelmemeli, çünkü çağıran kod zaten kontrol ediyor").
  • Bu, aslında bir bug'ı yakalamak için — yani "eğer bu koşul false ise, benim kodumda bir hata var demektir."

Exception/throw kullan, eğer:

  • Kontrol ettiğin şey, dış dünyadan gelen (kullanıcı girdisi, API cevabı, dosya içeriği gibi) ve gerçekten yanlış olabilecek bir veri ise.
  • Bu durumun üretimde de (kullanıcı karşısında) kontrol edilmesi ve düzgün bir şekilde ele alınması gerekiyor.
dart
// assert — geliştirici varsayımı, bug yakalamak için
void dahiliHesaplama(int index, List<int> liste) {
  assert(index >= 0 && index < liste.length, "Geçersiz index — bu bir kod hatasıdır");
  print(liste[index]);
}

// Exception — kullanıcı girdisi, üretimde de kontrol edilmeli
void kullaniciYasiKaydet(int yas) {
  if (yas < 0 || yas > 150) {
    throw ArgumentError("Geçersiz yaş değeri: $yas");
  }
  print("Yaş kaydedildi: $yas");
}

Basit bir zihinsel model: assert, kodunu yazarken kendine "bu asla olmamalı, ama olursa hemen haber ver" demenin bir yolu. Exception, "bu olabilir, ve olduğunda düzgün bir şekilde ele almam gerekiyor" demenin bir yolu.

assert Debug Modda Nasıl Çalışır?

Flutter'da (ve genel olarak Dart'ta) iki temel çalıştırma modu vardır:

  • Debug mode: Geliştirme sırasında kullanılır (flutter run ile varsayılan olarak), assert'ler aktiftir.
  • Release mode: Uygulamayı kullanıcıya yayınlarken kullanılır (flutter build ile), assert'ler tamamen kaldırılır (kod satırları derlenen çıktıya bile dahil edilmez).

Bu, assert'i sıfır maliyetli bir geliştirme aracı yapar — istediğin kadar assert ekleyebilirsin, üretim performansını hiç etkilemez, ama geliştirme sırasında hataları anında yakalamana yardımcı olur.

assert ile Karmaşık Koşullar

dart
class Dikdortgen {
  final double genislik;
  final double yukseklik;

  Dikdortgen(this.genislik, this.yukseklik)
      : assert(genislik > 0, "Genişlik pozitif olmalı"),
        assert(yukseklik > 0, "Yükseklik pozitif olmalı");
}

void main() {
  Dikdortgen d1 = Dikdortgen(5, 10); // ✅ sorunsuz
  Dikdortgen d2 = Dikdortgen(-5, 10); // ❌ AssertionError (sadece debug modda)
}

Bölüm 6'da initializer list'te gördüğümüz gibi, birden fazla assert art arda, virgülle ayrılarak yazılabilir — her biri farklı bir varsayımı doğrular.

assert Mesajsız da Kullanılabilir

dart
void main() {
  int deger = 10;
  assert(deger > 0); // mesaj opsiyonel
}

Mesaj yazmak zorunlu değildir ama şiddetle önerilir — mesajsız bir assert başarısız olduğunda, sadece "bir yerde bir assert başarısız oldu" bilgisini alırsın, neden başarısız olduğunu anlamak için kodu incelemen gerekir. Anlamlı bir mesaj, hatayı anında anlamanı sağlar.

Flutter Bağlantısı — Neden Bu Kadar Önemli?

Flutter'ın kendi iç kod tabanında binlerce assert vardır — örneğin bir widget'a geçersiz bir parametre (negatif bir genişlik gibi) verdiğinde, Flutter bunu genelde bir assert ile geliştirme sırasında hemen yakalar ve sana anlamlı bir hata mesajı gösterir. Bu, Flutter'ın "geliştirici deneyimi" felsefesinin önemli bir parçasıdır — hataları, kullanıcı karşısında değil, sen kodu yazarken yakalamaya çalışır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • assert, bir koşulun doğru olduğunu doğrulamak için kullanılır; koşul false ise AssertionError fırlatır.
  • assert, sadece debug modda çalışır — release modda tamamen kaldırılır, sıfır performans maliyeti getirir.
  • assert, geliştirici varsayımlarını (bug'ları) yakalamak için; Exception/throw, üretimde de kontrol edilmesi gereken dış dünya kaynaklı hatalar için kullanılır.
  • Anlamlı bir mesaj eklemek, assert başarısız olduğunda hatayı hızlıca anlamanı sağlar.
  • Flutter, kendi iç kodunda yoğun şekilde assert kullanır — bu, hataları geliştirme sırasında erken yakalama felsefesinin bir parçasıdır.

📝 Ödevler

  • [ ] Bir fonksiyona assert ekleyerek, parametrenin belirli bir aralıkta olduğunu doğrula (örn. 0-100 arası bir puan), hem geçerli hem geçersiz değerle test et.
  • [ ] Aynı kontrolü bir kere assert ile bir kere throw Exception ile yaz, ikisinin ne zaman/nasıl farklı davrandığını (debug/release bağlamında) yorumla.
  • [ ] Bir class'ın constructor'ında initializer list içinde birden fazla assert kullanarak birkaç alanı doğrula.
  • [ ] Mesajlı ve mesajsız iki assert örneği yaz, başarısız olduklarında verdikleri bilgi farkını karşılaştır.
  • [ ] Kendi cümlelerinle, "assert ile Exception'ı ne zaman kullanmalıyım" sorusuna, bu dersten öğrendiğin kriterlerle bir karar rehberi yaz.

🏁 Bölüm 8 Tamamlandı!

Hata yönetimini ve null safety'nin ileri detaylarını tamamladık: try/catch/finally, özel exception sınıfları, sound null safety'nin derinlemesine işleyişi ve assert. Artık kodunun hem beklenmedik hem de beklenen hata durumlarını güvenli ve profesyonel şekilde yönetebiliyorsun.

Daha önce konuştuğumuz gibi, şimdi Bölüm 1-8'i birleştiren bir mini proje ödevi ile bu bölümü pekiştirelim.

Sıradaki: Bölüm 1-8 Mini Proje — "Kütüphane Yönetim Sistemi" (Konsol Uygulaması)

41. bölüm

Bölüm 9 — Konu 42: Generic Sınıflar ve Fonksiyonlar

Bölüm 9'a hoş geldin. Bu bölüm, aslında Bölüm 4'te List<String>, Map<String, int> yazarken sürekli kullandığın <...> sözdiziminin arkasında ne olduğunu açıklayacak — generics.

Generics Neden Var? — Problemi Anlamak

Diyelim ki, herhangi bir tipte tek bir değer tutan basit bir "kutu" sınıfı yazmak istiyorsun:

dart
// Yaklaşım 1: dynamic kullanmak
class KutuDynamic {
  dynamic icerik;
  KutuDynamic(this.icerik);
}

void main() {
  KutuDynamic k = KutuDynamic("Merhaba");
  String metin = k.icerik; // ❌ HATA! dynamic, String'e otomatik dönüşmez, tip güvenliği yok
}

Bölüm 2'de dynamic'ten kaçınmayı öğrenmiştik — bu yaklaşım tip güvenliğini tamamen kaybettiriyor. Peki her tip için ayrı bir sınıf mı yazmalıyız?

dart
// Yaklaşım 2: Her tip için ayrı sınıf — kod tekrarı!
class StringKutu {
  String icerik;
  StringKutu(this.icerik);
}

class IntKutu {
  int icerik;
  IntKutu(this.icerik);
}

class BoolKutu {
  bool icerik;
  BoolKutu(this.icerik);
}

Bu çalışır ama korkunç bir kod tekrarı — her yeni tip için yeni bir sınıf yazman gerekiyor. Generics, tam olarak bu problemi çözmek için var: hem tip güvenliğini koru, hem de kod tekrarını önle.

Generic Sınıf Yazma

dart
class Kutu<T> {
  T icerik;
  Kutu(this.icerik);

  void goster() {
    print("İçerik: $icerik, Tip: ${icerik.runtimeType}");
  }
}

void main() {
  Kutu<String> stringKutu = Kutu<String>("Merhaba");
  Kutu<int> intKutu = Kutu<int>(42);
  Kutu<bool> boolKutu = Kutu<bool>(true);

  stringKutu.goster(); // İçerik: Merhaba, Tip: String
  intKutu.goster();    // İçerik: 42, Tip: int
}

<T> ne anlama geliyor? T, bir tip parametresidir (type parameter) — "bu sınıf, kullanıldığı anda belirlenecek herhangi bir tip ile çalışabilir" anlamına gelir. T harfi bir kural değil, sadece yaygın bir konvansiyondur ("Type" kelimesinin kısaltması) — istersen Kutu<X> da yazabilirdin, ama T kullanmak yaygın ve okunması kolay bir tercihtir.

Tip güvenliği nasıl korunuyor?

dart
void main() {
  Kutu<String> stringKutu = Kutu<String>("Merhaba");
  String metin = stringKutu.icerik; // ✅ çalışır! icerik zaten String olarak biliniyor

  stringKutu.icerik = 42; // ❌ HATA! Kutu<String>, sadece String kabul eder
}

Bu, generics'in gücünü gösteriyor: Kutu<String> dediğinde, Dart artık o kutunun kesinlikle String tutacağını bilir ve tip güvenliğini tam olarak korur — dynamic kullanmadığımız için hiçbir tip belirsizliği yok.

Tip Çıkarımı Generics'te de Çalışır

dart
void main() {
  var kutu = Kutu("Merhaba"); // <String> yazmadık, Dart otomatik anladı
  print(kutu.icerik.runtimeType); // String
}

Bölüm 2'de öğrendiğimiz tip çıkarımı, generics'te de geçerlidir — Kutu("Merhaba") yazdığında, Dart parametrenin String olduğunu görüp T'yi otomatik olarak String olarak belirler. Yine de, özellikle karmaşık durumlarda açıkça Kutu<String>(...) yazmak okunabilirlik açısından tercih edilir.

Generic Fonksiyonlar

Sadece sınıflar değil, fonksiyonlar da generic olabilir:

dart
T ilkEleman<T>(List<T> liste) {
  return liste[0];
}

void main() {
  List<String> isimler = ["Ahmet", "Ayşe"];
  List<int> sayilar = [10, 20, 30];

  print(ilkEleman(isimler)); // Ahmet — T, String olarak belirlendi
  print(ilkEleman(sayilar)); // 10 — T, int olarak belirlendi
}

ilkEleman<T>(List<T> liste), herhangi bir tipteki listenin ilk elemanını, o listenin tipini koruyarak döndürür. Eğer bunu generic olmadan, dynamic ile yazsaydık:

dart
dynamic ilkElemanDynamic(List liste) {
  return liste[0];
}

void main() {
  List<String> isimler = ["Ahmet", "Ayşe"];
  String isim = ilkElemanDynamic(isimler); // ❌ HATA! dynamic, String'e otomatik atanamaz
}

Generic versiyon, çağrıldığı listenin gerçek tipini koruyarak döndürüyor — bu, dynamic versiyonunun kaybettiği tip güvenliğini tam olarak sağlıyor.

Birden Fazla Tip Parametresi

dart
class Cift<A, B> {
  A birinci;
  B ikinci;
  Cift(this.birinci, this.ikinci);

  @override
  String toString() => "($birinci, $ikinci)";
}

void main() {
  Cift<String, int> yasBilgisi = Cift("Ahmet", 25);
  print(yasBilgisi); // (Ahmet, 25)

  Cift<String, bool> aktiflikBilgisi = Cift("Sistem", true);
  print(aktiflikBilgisi); // (Sistem, true)
}

Bu, aslında Bölüm 4'te sürekli kullandığımız Map<K, V>'nin tam olarak nasıl çalıştığının basitleştirilmiş bir versiyonu — Map, içeride iki tip parametresi alan (K: key tipi, V: value tipi) generic bir sınıftır.

Generic Metod (Sınıf Generic Olmasa Bile)

dart
class Yardimci {
  T ikisindenBuyuguGetir<T extends Comparable>(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
  }
}

Burada Yardimci sınıfının kendisi generic değil, ama içindeki bir metod generic — bu, sadece o metod çağrıldığında tip parametresi belirlenecek anlamına gelir. T extends Comparable kısmını (generic sınırlama) bir sonraki derste tam olarak işleyeceğiz.

Dart'ın Kendi Koleksiyonları — Artık Nasıl Çalıştıklarını Biliyorsun

dart
List<String> isimler = [];   // List<T>, T=String
Map<String, int> yaslar = {}; // Map<K, V>, K=String, V=int
Set<int> sayilar = {};        // Set<T>, T=int

Bölüm 4'te bunları "kullanmayı" öğrenmiştik, şimdi neden bu şekilde tasarlandıklarını anlıyorsun — List, Map, Set sınıflarının hepsi generic olarak yazılmış, bu sayede herhangi bir tipte veri tutabiliyorlar, ama her kullanımda tam tip güvenliği koruyorlar.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Generics, dynamic kullanmadan (tip güvenliğini kaybetmeden) hem esnek hem tip-güvenli kod yazmanı sağlar.
  • <T>, bir tip parametresidir — sınıf/fonksiyon kullanıldığı anda gerçek bir tiple değiştirilir.
  • Generic sınıflarda tip çıkarımı çalışır, ama açıkça belirtmek genelde daha okunabilirdir.
  • Fonksiyonlar da generic olabilir (T fonksiyon<T>(...)), farklı tiplerle aynı mantığı tekrar yazmadan çalıştırabilirsin.
  • Birden fazla tip parametresi (<A, B>) kullanılabilir — Map<K, V> buna bir örnektir.
  • Dart'ın kendi List, Map, Set koleksiyonları, generics kullanılarak tasarlanmıştır.

📝 Ödevler

  • [ ] Herhangi bir tipte eleman tutabilen generic bir Kutu<T> sınıfı yaz, en az 3 farklı tiple (String, int, bool) kullan.
  • [ ] Bir listenin son elemanını döndüren generic bir fonksiyon yaz (sonEleman<T>(List<T> liste)), farklı tipte listelerle test et.
  • [ ] Cift<A, B> benzeri, iki farklı tipte değer tutan generic bir sınıf yaz, en az iki farklı tip kombinasyonuyla kullan.
  • [ ] Generic olmayan (dynamic kullanan) bir fonksiyon ile aynı işi yapan generic bir fonksiyonu karşılaştırmalı olarak yaz, tip güvenliği farkını göster.
  • [ ] Kendi Cift<A, B> sınıfına, A ve B değerlerini yer değiştiren bir takasEt() metodu ekle (yeni bir Cift<B, A> döndürsün).

Sıradaki konu: Bölüm 9 — Konu 43: Generic Sınırlamalar (<T extends ...>)

42. bölüm

Bölüm 9 — Konu 43: Generic Sınırlamalar (`<T extends ...>`)

Sorun: Generic Tip Üzerinde Hiçbir Varsayımda Bulunamazsın

Bir önceki derste generic bir Kutu<T> yazmıştık. Ama T tamamen "sınırsız" olduğu için, içindeki değer üzerinde hiçbir özel işlem yapamayız:

dart
class Kutu<T> {
  T deger;
  Kutu(this.deger);

  bool digeriylebuyukmu(Kutu<T> diger) {
    return deger > diger.deger; // ❌ HATA! T'nin '>' operatörüne sahip olduğu garanti değil
  }
}

Bu kod derlenmez — çünkü T, herhangi bir tip olabilir (bir String, bir bool, hatta kendi yazdığın bir class). Dart, T'nin > operatörünü desteklediğinden emin olamaz (örneğin bool tipinde > operatörü anlamsızdır). Bu yüzden derleyici, güvenli olmayan bu kodu reddediyor.

Çözüm: extends ile Generic Sınırlama (Bound)

dart
class Kutu<T extends Comparable> {
  T deger;
  Kutu(this.deger);

  bool digeriylebuyukmu(Kutu<T> diger) {
    return deger.compareTo(diger.deger) > 0; // ✅ artık güvenli!
  }
}

void main() {
  Kutu<int> k1 = Kutu(10);
  Kutu<int> k2 = Kutu(20);
  print(k1.digeriylebuyukmu(k2)); // false

  Kutu<String> k3 = Kutu("elma");
  Kutu<String> k4 = Kutu("armut");
  print(k3.digeriylebuyukmu(k4)); // false (alfabetik karşılaştırma)
}

<T extends Comparable>, "T, sadece Comparable interface'ini implemente eden tiplerden biri olabilir" anlamına gelir. Comparable, Dart'ın standart kütüphanesinde tanımlı, compareTo() metoduna sahip olmayı garanti eden bir interface'dir — int, double, String gibi birçok yerleşik tip bunu zaten implemente eder.

Bu sınırlama sayesinde ne kazanıyoruz? Dart artık, T her ne olursa olsun, compareTo() metoduna sahip olacağını garanti eder — bu yüzden deger.compareTo(diger.deger) çağrısı güvenle derlenir.

Sınırlamayı İhlal Etmeye Çalışmak

dart
class Kutu<T extends Comparable> {
  T deger;
  Kutu(this.deger);
}

void main() {
  Kutu<bool> k = Kutu(true); // ❌ HATA! bool, Comparable'ı implemente etmiyor
}

bool, compareTo() metoduna sahip değildir (iki boolean değeri "büyük/küçük" karşılaştırmak mantıklı değildir), bu yüzden Dart, Kutu<bool> oluşturmana derleme zamanında izin vermez. Bu, generic sınırlamanın asıl gücü — yanlış kullanımı, kod çalışmadan önce yakalıyor.

Kendi Class'larınla Generic Sınırlama Kullanma

dart
abstract class Hayvan {
  String isim;
  Hayvan(this.isim);
  void sesCikar();
}

class Kedi extends Hayvan {
  Kedi(String isim) : super(isim);
  @override
  void sesCikar() => print("Miyav!");
}

class HayvanBarinagi<T extends Hayvan> {
  List<T> hayvanlar = [];

  void ekle(T hayvan) {
    hayvanlar.add(hayvan);
  }

  void hepsiniSesletir() {
    for (var hayvan in hayvanlar) {
      hayvan.sesCikar(); // ✅ güvenli, çünkü T kesinlikle bir Hayvan
    }
  }
}

void main() {
  HayvanBarinagi<Kedi> kediBarinagi = HayvanBarinagi();
  kediBarinagi.ekle(Kedi("Tekir"));
  kediBarinagi.hepsiniSesletir(); // Miyav!
}

<T extends Hayvan>, HayvanBarinagi'nin sadece Hayvan'dan türeyen tiplerle (Kedi, Kopek gibi) kullanılabileceğini garanti ediyor. Bu sayede, hepsiniSesletir() metodu içinde hayvan.sesCikar() çağırmak güvenlidir — Dart, T'nin kesinlikle sesCikar() metoduna sahip olduğunu bilir (çünkü Hayvan'ın alt sınıfı olmak zorunda).

dart
void main() {
  HayvanBarinagi<String> stringBarinagi = HayvanBarinagi(); // ❌ HATA! String, Hayvan'dan türemiyor
}

Sınırlama Olmadan vs Sınırlama İle — Karşılaştırma

dart
// Sınırsız generic — hiçbir varsayımda bulunamazsın
class KutuSinirsiz<T> {
  T deger;
  KutuSinirsiz(this.deger);
  // sadece Object'in metodlarını (toString, ==ile vb.) kullanabilirsin
}

// Sınırlı generic — belirli bir "yetenek" garanti edilir
class KutuSinirli<T extends Comparable> {
  T deger;
  KutuSinirli(this.deger);
  // Comparable'ın metodlarını (compareTo) güvenle kullanabilirsin
}

Ne zaman sınırlama kullanılır? Generic tipin, sınıfın içinde belirli bir davranışa (bir metoda, bir alana) sahip olması gerektiğinde. Eğer generic tipi sadece "saklamak" için kullanıyorsan (Bölüm 9 Konu 42'deki basit Kutu<T> gibi), sınırlamaya gerek yoktur. Ama generic tip üzerinde işlem yapman gerekiyorsa (karşılaştırma, belirli bir metod çağırma), sınırlama şarttır.

Object — Varsayılan (Örtük) Sınırlama

Aslında, sınırlama belirtmediğinde bile, Dart örtük olarak <T extends Object?> varsayar (ya da null safety bağlamına göre Object) — yani her generic tip, en azından Object'in (Bölüm 2'de gördüğümüz tip hiyerarşisinin köküdür) sahip olduğu temel metodlara (toString(), == gibi) her zaman sahiptir.

Birden Fazla Generic Parametrede Sınırlama

dart
class Eslesme<K extends Comparable, V> {
  K anahtar;
  V deger;
  Eslesme(this.anahtar, this.deger);
}

Sınırlama, birden fazla tip parametresinin her birine ayrı ayrı uygulanabilir — burada sadece K sınırlandırıldı, V sınırsız bırakıldı.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Sınırlanmamış (<T>) bir generic tip üzerinde, sadece Object'in temel metodlarını güvenle kullanabilirsin.
  • <T extends TipAdı>, generic tipin belirli bir sınıf/interface'den türemesini zorunlu kılar — bu, o tipin belirli metod/alanlara sahip olacağını garanti eder.
  • Sınırlama ihlal edildiğinde (örn. Kutu<bool> ile Comparable sınırlaması), hata derleme zamanında yakalanır.
  • Generic tip üzerinde özel bir davranış (karşılaştırma, belirli bir metod çağırma) gerekiyorsa sınırlama şarttır; sadece "saklamak" için sınırlamaya gerek yoktur.
  • Birden fazla tip parametresinin her biri ayrı ayrı sınırlandırılabilir.

📝 Ödevler

  • [ ] Comparable sınırlamalı bir Kutu<T> sınıfı yaz, iki farklı Kutu<int> nesnesini karşılaştıran bir metod ekle.
  • [ ] Kutu<bool> oluşturmayı deneyip (eğer Comparable sınırlaması varsa) derleme hatasını gözlemle.
  • [ ] Kendi soyut sınıfını (örn. Sekil, alanHesapla() metoduyla) yaz, bu sınıfla sınırlandırılmış generic bir SekilKoleksiyonu<T extends Sekil> sınıfı oluştur, içindeki tüm şekillerin toplam alanını hesaplayan bir metod ekle.
  • [ ] Sınırlanmamış bir generic sınıfta, sınırlı olmadığı için hangi işlemleri yapamayacağını (örn. karşılaştırma, belirli bir metod çağırma) örnekle göster.
  • [ ] İki tip parametreli bir generic sınıf yaz, sadece birini sınırlandır, ikisini de kullanan bir metod ekle.

Sıradaki konu: Bölüm 9 — Konu 44: Dart'ın Built-in Generic Koleksiyonları Nasıl Çalışır (List<T>, Map<K,V>)

43. bölüm

Bölüm 9 — Konu 44: Dart'ın Built-in Generic Koleksiyonları Nasıl Çalışır

Bölüm 9'un son konusundayız. Şimdiye kadar generics'i kendi sınıflarımızda kullanmayı gördük. Bu derste, Bölüm 4'te öğrendiğimiz List, Set, Map'in aslında birer generic sınıf olarak nasıl tasarlandığını anlayacağız.

List<T> — Basitleştirilmiş Bir Zihin Modeli

Dart'ın gerçek List implementasyonu çok daha karmaşıktır (performans optimizasyonları, farklı liste türleri vb. içerir), ama kavramsal olarak şöyle düşünebilirsin:

dart
// Bu, GERÇEK List implementasyonu DEĞİL — sadece kavramı anlamak için basitleştirilmiş bir örnek
class BenimListem<T> {
  final List<T> _icerik = [];

  void add(T eleman) {
    _icerik.add(eleman);
  }

  T operator [](int index) {
    return _icerik[index];
  }

  int get length => _icerik.length;
}

void main() {
  BenimListem<String> liste = BenimListem();
  liste.add("Merhaba");
  print(liste[0]); // Merhaba
  print(liste.length); // 1
}

Bu örnek, Bölüm 9'da öğrendiğin generic sınıf kavramının, Dart'ın kendi List<T> sınıfında da aynı prensiple çalıştığını gösteriyor. List<String> yazdığında, aslında List sınıfının T tip parametresine String "geçiriyorsun" — tıpkı kendi Kutu<T> sınıfını kullandığın gibi.

operator [] — Küçük Bir Not

Yukarıdaki örnekte T operator [](int index) gördün — bu, operatör overloading dediğimiz, ileri bir Dart özelliğidir ([] erişim operatörünü kendi sınıfın için özelleştirmeni sağlar). Bunu şimdi detaylı işlemiyoruz, sadece liste[0] gibi bir erişimin arka planda bir metod çağrısı olduğunu bilmen, generics'in koleksiyonlarda nasıl işlediğini anlaman için yeterli.

Map<K, V> — İki Tip Parametreli Generic

Bölüm 9 Konu 42'de gördüğümüz Cift<A, B> örneğini hatırlarsan, Map<K, V> de aynı mantıkla çalışır — sadece çok daha gelişmiş bir implementasyona sahiptir (hash tabanlı arama için optimize edilmiştir):

dart
// Kavramsal basitleştirme
class BenimMapim<K, V> {
  final Map<K, V> _icerik = {};

  void set(K anahtar, V deger) {
    _icerik[anahtar] = deger;
  }

  V? get(K anahtar) {
    return _icerik[anahtar];
  }
}

void main() {
  BenimMapim<String, int> yaslar = BenimMapim();
  yaslar.set("Ahmet", 25);
  print(yaslar.get("Ahmet")); // 25
}

K (Key) ve V (Value), Bölüm 9'da öğrendiğimiz "birden fazla tip parametresi" kavramının Dart'ın kendi kütüphanesindeki gerçek kullanımıdır.

Koleksiyon Tipleri Arasında Uyumluluk — Kovaryans (Kısa Bir Bakış)

dart
void main() {
  List<int> tamSayilar = [1, 2, 3];
  List<num> sayilar = tamSayilar; // ✅ çalışır! List<int>, List<num>'a atanabilir
  print(sayilar); // [1, 2, 3]
}

Bu ilginç bir davranış — List<int>, List<num> tipine atanabiliyor, çünkü Bölüm 2'de gördüğümüz gibi int, num'un bir alt tipidir. Bu davranışa kovaryans (covariance) denir — "eğer int, num'un alt tipiyse, List<int> da List<num>'ın alt tipi sayılır" mantığı. Bunu tam olarak Bölüm 13'te (variance detayları) işleyeceğiz — şimdilik sadece bu davranışın var olduğunu ve bazen beklenmedik sonuçlara yol açabileceğini bilmen yeterli:

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

  sayilar.add(3.14); // ❌ RUNTIME HATASI! Aslında altta yatan liste hâlâ List<int>
}

Bu, ileri bir tuzak — sayilar değişkeni List<num> tipinde görünse de, altında yatan gerçek nesne hâlâ List<int>'tir, bu yüzden ona bir double eklemeye çalışmak çalışma zamanında hataya yol açar. Bu konuyu şimdilik sadece farkında olman için gösteriyoruz; derinlemesine Bölüm 13'te işleyeceğiz.

is ile Generic Tip Kontrolü

dart
void main() {
  List<String> isimler = ["Ahmet", "Ayşe"];
  List<int> sayilar = [1, 2, 3];

  print(isimler is List<String>); // true
  print(isimler is List<int>);    // false
  print(isimler is List);         // true — tip parametresi belirtilmeden de kontrol edilebilir
}

Bölüm 3'te öğrendiğimiz is operatörü, generic koleksiyonlarla da çalışır — hem tam tip eşleşmesi (List<String>) hem de genel tip kontrolü (List) yapabilirsin.

List<Object> vs List<dynamic> — İnce Bir Fark

dart
void main() {
  List<Object> objeListesi = [1, "iki", true]; // karışık tipler, ama hepsi Object
  List<dynamic> dinamikListe = [1, "iki", true]; // aynı görünüyor ama...

  for (var eleman in objeListesi) {
    // eleman, Object tipinde — sadece Object'in metodları doğrudan çağrılabilir
    print(eleman.toString());
  }

  for (var eleman in dinamikListe) {
    // eleman, dynamic tipinde — HERHANGİ bir metod çağrılabilir (riskli!)
    print(eleman.toString());
  }
}

Bölüm 2'de öğrendiğimiz Object ile dynamic arasındaki fark, koleksiyonlarda da aynen geçerlidir: List<Object>, her elemanın en azından Object olduğunu garanti eder (tip güvenli), List<dynamic> ise tip kontrolünü tamamen kapatır. JSON gibi karışık tipli veri yapılarıyla çalışırken, List<dynamic> yerine mümkünse List<Object?> kullanmak daha güvenlidir — ama bu, projenin ihtiyacına göre değişebilir.

Neden Bu Konuyu Bilmek Önemli?

Flutter'da, özellikle API'lerden gelen JSON verisiyle çalışırken (List<dynamic>, Map<String, dynamic> gibi tiplerle sıkça karşılaşacaksın — Bölüm 5'in ilerleyen konularında bunu tam olarak işleyeceğiz), bu generics bilgisi, neden bu tiplerin bu şekilde tasarlandığını ve hangi durumda hangi tipin daha güvenli olduğunu anlamana yardımcı olacak.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ın List<T>, Map<K, V>, Set<T> koleksiyonları, kendi yazdığın generic sınıflarla aynı temel prensiple tasarlanmıştır.
  • Kovaryans, List<int>'in List<num>'a atanabilmesini sağlar, ama bu bazı runtime hatalarına yol açabilir (Bölüm 13'te derinlemesine işlenecek).
  • is, generic koleksiyonlarla tam tip (List<String>) veya genel tip (List) kontrolü için kullanılabilir.
  • List<Object>, tip güvenliğini korur; List<dynamic>, tip kontrolünü kapatır — JSON gibi karışık verilerle çalışırken bu farkı bilmek önemlidir.

📝 Ödevler

  • [ ] Kendi basit bir generic "liste benzeri" sınıfını yaz (add, length, [] erişimi ile), Bölüm 9 boyunca öğrendiklerini pekiştir.
  • [ ] List<int>'i List<num>'a atayıp, sonra bu değişkene bir double eklemeyi dene, runtime hatasını gözlemle ve yorumla.
  • [ ] is operatörü ile en az 3 farklı generic koleksiyon tipini (List<String>, Map<String, int>, genel List) kontrol eden bir örnek yaz.
  • [ ] Aynı verilerle bir List<Object> ve bir List<dynamic> oluştur, aralarındaki tip güvenliği farkını, bilerek yanlış bir metod çağırarak göster.
  • [ ] Kendi cümlelerinle, "Dart'ın List ve Map sınıfları neden generic olarak tasarlandı" sorusunu, Bölüm 9'da öğrendiklerinle açıkla.

🏁 Bölüm 9 Tamamlandı!

Generics'in temellerini, sınırlamalarını ve Dart'ın kendi koleksiyonlarının bunları nasıl kullandığını öğrendik. Bu, hem kendi esnek ve tip-güvenli sınıflarını yazabilmeni hem de Dart'ın standart kütüphanesini çok daha derinlemesine anlamanı sağladı.

Sıradaki durak Bölüm 10 — Asenkron Programlama: Future, async/await, Stream ile Dart'ın zamanla ilgili (zaman alan, beklemeli) işlemleri nasıl yönettiğini işleyeceğiz — bu, Flutter'da API çağrıları yaparken mutlaka bilmen gereken bir konu.

44. bölüm

Bölüm 10 — Konu 45: `Future` Kavramı, `async`/`await`

Bölüm 10'a hoş geldin. Bu bölüm, Dart'ta zaman alan işlemleri (bir API'den veri çekme, bir dosya okuma, birkaç saniye beklemek gibi) nasıl yöneteceğimizi işliyor — bu, Flutter'da neredeyse her uygulamada karşına çıkacak temel bir konu.

Senkron (Eşzamanlı) Kod — Alışık Olduğumuz Model

Şimdiye kadar yazdığımız tüm kod senkrondu — her satır, bir öncekinin bitmesini bekleyerek, sırayla çalıştı:

dart
void main() {
  print("1. adım");
  print("2. adım");
  print("3. adım");
}

Çıktı her zaman sırayla gelir: 1. adım, 2. adım, 3. adım. Ama gerçek dünyada bazı işlemler zaman alır — bir sunucudan veri çekmek birkaç saniye sürebilir. Eğer program bu süre boyunca tamamen donarsa (bekleyene kadar hiçbir şey yapamazsa), bu kötü bir kullanıcı deneyimi yaratır — Flutter'da bu, uygulamanın "kilitlenmiş" gibi görünmesi anlamına gelir.

Future Nedir?

Future, şu anda elinde olmayan ama gelecekte (future) bir noktada elde edeceğin bir değeri temsil eder. Bunu "ileride dolacak bir kutu" gibi düşünebilirsin.

dart
Future<String> veriGetir() {
  return Future.delayed(Duration(seconds: 2), () {
    return "Sunucudan gelen veri";
  });
}

void main() {
  print("İstek gönderiliyor...");
  veriGetir().then((veri) {
    print("Gelen veri: $veri");
  });
  print("Bu satır, veri gelmeden ÖNCE çalışır!");
}

Çıktı:

metin
İstek gönderiliyor...
Bu satır, veri gelmeden ÖNCE çalışır!
Gelen veri: Sunucudan gelen veri  (2 saniye sonra)

Kritik gözlem: "Bu satır..." yazısı, veri gelmeden önce yazdırıldı! Bu, Future'ın asenkron (non-blocking) çalıştığını gösteriyor — program, veriyi beklerken donmuyor, diğer işlere devam edebiliyor. Veri geldiğinde, .then() içindeki kod otomatik olarak çalıştırılıyor.

Future.delayed — Test/Öğrenme İçin Kullanışlı Bir Araç

Future.delayed(Duration(seconds: 2), () { ... }), belirtilen süre kadar bekleyip, sonra verilen fonksiyonun sonucunu döndüren bir Future oluşturur. Bu, gerçek bir API çağrısını simüle etmek için harika bir araçtır — gerçek bir sunucun olmadan, "zaman alan bir işlem" davranışını test edebilirsin.

async / await — Daha Okunabilir Bir Yazım

.then() kullanmak çalışır, ama kod karmaşıklaştıkça (birden fazla asenkron adım olduğunda) okunması zorlaşır. Dart, bunun için çok daha temiz bir sözdizimi sunar: async/await.

dart
Future<String> veriGetir() {
  return Future.delayed(Duration(seconds: 2), () => "Sunucudan gelen veri");
}

void main() async {
  print("İstek gönderiliyor...");
  String veri = await veriGetir(); // burada BEKLE, sonucu al
  print("Gelen veri: $veri");
  print("Bu satır, veri geldikten SONRA çalışır");
}

Çıktı:

metin
İstek gönderiliyor...
Gelen veri: Sunucudan gelen veri  (2 saniye sonra)
Bu satır, veri geldikten SONRA çalışır

Dikkat et — davranış değişti! await kullandığımızda, kod artık senkron gibi okunuyor ve davranıyor — await veriGetir() satırı, veri gelene kadar (kod akışını bloklamadan, ama o fonksiyonun kendi içinde bekleyerek) durur, sonra bir sonraki satıra geçer.

Yapıyı parçalayalım:

  • async — bir fonksiyonun içinde await kullanabileceğini belirtir; fonksiyonu işaretler.
  • await — bir Future'ın tamamlanmasını bekler ve gerçek değeri (Future'ın "içindeki" değeri) döndürür.

async Fonksiyonların Dönüş Tipi — Her Zaman Future

dart
Future<int> ikiyleCarp(int sayi) async {
  await Future.delayed(Duration(seconds: 1)); // sahte bir gecikme
  return sayi * 2;
}

void main() async {
  int sonuc = await ikiyleCarp(5);
  print(sonuc); // 10 (1 saniye sonra)
}

Önemli kural: async ile işaretlenen bir fonksiyon, her zaman bir Future döndürür — return sayi * 2; yazsak bile, fonksiyonun gerçek dönüş tipi Future<int>'tir (int değil). Dart, async fonksiyonlarda senin return ettiğin değeri otomatik olarak bir Future içine "sarar" (wrap eder).

dart
void main() async {
  Future<int> sonucFuture = ikiyleCarp(5); // await KULLANMAZSAK, Future'ın kendisini alırız
  print(sonucFuture); // Instance of 'Future<int>' — henüz tamamlanmamış olabilir

  int sonuc = await ikiyleCarp(5); // await ile GERÇEK değeri alırız
  print(sonuc); // 10
}

main() Fonksiyonu da async Olabilir

Yukarıdaki örneklerde void main() async yazdığımızı fark ettin mi? Bölüm 1'de main()'in her zaman void döndürdüğünü öğrenmiştik — bu hâlâ doğru, ama main() de diğer fonksiyonlar gibi async olabilir, bu da içinde await kullanmanı sağlar.

Birden Fazla await — Sıralı Asenkron İşlemler

dart
Future<String> kullaniciGetir() async {
  await Future.delayed(Duration(seconds: 1));
  return "Ahmet";
}

Future<List<String>> siparisleriGetir(String kullanici) async {
  await Future.delayed(Duration(seconds: 1));
  return ["Kalem", "Defter"];
}

void main() async {
  print("Başladı");

  String kullanici = await kullaniciGetir(); // 1. adım — 1 saniye bekler
  print("Kullanıcı: $kullanici");

  List<String> siparisler = await siparisleriGetir(kullanici); // 2. adım — 1 saniye daha bekler
  print("Siparişler: $siparisler");

  print("Bitti"); // toplamda 2 saniye sonra
}

Bu, async/await'in en büyük avantajlarından birini gösteriyor: birbirine bağımlı, sıralı asenkron işlemleri, tıpkı senkron kod yazar gibi, düz ve okunabilir bir akışla yazabiliyorsun. Aynı şeyi .then() zincirleriyle yapmaya çalışsaydın, kod hızla iç içe geçen, okunması zor bir yapıya dönüşürdü (buna "callback hell" denir — bir sonraki derste .then()'i tekrar göreceğiz, bu ismi hatırlarsın).

Future İçinde Hata Yönetimi — try/catch ile

dart
Future<String> riskliIslem() async {
  await Future.delayed(Duration(seconds: 1));
  throw Exception("Bir şeyler ters gitti");
}

void main() async {
  try {
    String sonuc = await riskliIslem();
    print(sonuc);
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Bölüm 8'de öğrendiğimiz try/catch, async/await ile mükemmel uyum içinde çalışır — bir await edilen işlem hata fırlatırsa, bunu tıpkı senkron bir hata gibi try/catch ile yakalayabilirsin. Bu, async/await'in .then()'e göre bir başka büyük avantajıdır.

Flutter'a Bağlantı — FutureBuilder Önizlemesi

Flutter'da, bir Future'ın sonucuna göre ekranı güncellemen gerektiğinde (örneğin "veri yükleniyor..." göstergesi, sonra gerçek veri), FutureBuilder adında özel bir widget kullanılır. Bu widget, tam olarak burada öğrendiğin Future kavramını alıp, UI ile entegre eder — "Future henüz tamamlanmadıysa bir yükleme göstergesi göster, tamamlandığında gerçek veriyi göster" mantığını otomatikleştirir. Bunu Flutter tutorial'ında tam olarak işleyeceğiz; şimdi Future'ın temelini bildiğin için, FutureBuilder'ı öğrenmek çok daha kolay olacak.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Future, gelecekte tamamlanacak bir değeri temsil eder; asenkron (non-blocking) çalışır, programı dondurmaz.
  • async, bir fonksiyonun içinde await kullanılabileceğini belirtir; fonksiyon her zaman bir Future döndürür.
  • await, bir Future'ın tamamlanmasını bekler ve gerçek değeri döndürür — kodu senkron gibi okunabilir kılar.
  • Birden fazla await, sıralı asenkron işlemleri düz ve okunabilir bir akışla yazmanı sağlar.
  • try/catch, async/await ile birlikte, asenkron hataları senkron hatalar gibi yakalamanı sağlar.

📝 Ödevler

  • [ ] Future.delayed ile 2 saniye gecikmeli sahte bir veri getiren fonksiyon yaz, .then() ile sonucu yazdır.
  • [ ] Aynı fonksiyonu async/await ile çağır, iki yaklaşımın kod okunabilirliğini karşılaştır.
  • [ ] Birbirine bağımlı iki asenkron işlemi (örn. önce kullanıcı bilgisi, sonra o kullanıcının siparişleri) sıralı await ile yaz.
  • [ ] async bir fonksiyon içinde throw ile hata fırlat, try/catch ile yakala.
  • [ ] await kullanmadan bir async fonksiyonu çağırıp sonucunu doğrudan print etmeyi dene, Future nesnesinin kendisinin yazdırıldığını gözlemle ve yorumla.

Sıradaki konu: Bölüm 10 — Konu 46: Future.then, Hata Yönetimi (catchError)

45. bölüm

Bölüm 10 — Konu 46: `Future.then`, Hata Yönetimi (`catchError`)

Bir önceki derste .then()'i kısaca görmüştük ve async/await'in genelde daha okunabilir olduğunu vurgulamıştık. Bu derste .then() zincirleme yapısını ve catchError'ı tam olarak işleyeceğiz — çünkü bazı durumlarda (özellikle üçüncü parti kütüphanelerle çalışırken) bu sözdizimiyle karşılaşacaksın.

.then() — Temel Kullanım

dart
Future<String> veriGetir() {
  return Future.delayed(Duration(seconds: 1), () => "Veri");
}

void main() {
  veriGetir().then((veri) {
    print("Alınan veri: $veri");
  });
  print("Bu satır hemen çalışır");
}

.then(), bir Future tamamlandığında çalıştırılacak bir fonksiyon kabul eder. Bu fonksiyon, Future'ın ürettiği değeri parametre olarak alır (veri burada "Veri" olacak).

.then() Zincirleme

dart
Future<int> sayiGetir() => Future.delayed(Duration(milliseconds: 500), () => 5);

void main() {
  sayiGetir()
      .then((sayi) => sayi * 2) // 5 -> 10
      .then((sayi) => sayi + 1) // 10 -> 11
      .then((sonuc) => print("Sonuç: $sonuc")); // Sonuç: 11
}

Her .then(), bir öncekinin döndürdüğü değeri alır ve işleyip yeni bir sonuç üretir — bu, bir zincir (chain) oluşturur. Bu, Bölüm 5'te öğrendiğimiz method chaining kavramına benziyor ama burada her adım asenkron olarak birbirine bağlanıyor.

Aynı işi async/await ile yazsaydık:

dart
void main() async {
  int sayi = await sayiGetir();
  sayi = sayi * 2;
  sayi = sayi + 1;
  print("Sonuç: $sayi");
}

Basit örneklerde iki yaklaşım da okunabilir, ama zincir uzadıkça (özellikle koşullu mantık eklendiğinde), async/await genelde daha net kalır — bu yüzden modern Dart kodunda async/await tercih edilen yöntemdir. .then()'i bilmen önemli çünkü hem eski kodlarda hem bazı API tasarımlarında karşına çıkacak.

catchError — .then() Zincirinde Hata Yakalama

dart
Future<String> riskliIslem() {
  return Future.delayed(Duration(seconds: 1), () {
    throw Exception("Bir hata oluştu");
  });
}

void main() {
  riskliIslem()
      .then((veri) {
        print("Veri: $veri"); // hata olduğu için bu satır ÇALIŞMAZ
      })
      .catchError((hata) {
        print("Hata yakalandı: $hata");
      });
}

.catchError(), zincirdeki herhangi bir .then() içinde oluşan hatayı yakalar — Bölüm 8'de öğrendiğimiz try/catch'in .then() zincirlerindeki karşılığıdır.

Aynı işi async/await ile:

dart
void main() async {
  try {
    String veri = await riskliIslem();
    print("Veri: $veri");
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Burada da try/catch'in, .then()/.catchError()'a göre daha tanıdık ve okunabilir olduğunu görüyorsun — çünkü Bölüm 8'de öğrendiğin senkron hata yönetimi mantığıyla birebir aynı sözdizimini kullanıyorsun.

.then() ile İkinci Parametre — Hata Yönetimini Aynı Yerde Yapma

dart
void main() {
  riskliIslem().then(
    (veri) {
      print("Veri: $veri");
    },
    onError: (hata) {
      print("Hata (onError ile): $hata");
    },
  );
}

.then(), ikinci bir named parametre olan onError ile de hata yakalayabilir — bu, .catchError()'ı zincire ayrı eklemek yerine, aynı .then() çağrısı içinde tanımlamanı sağlar. İkisi de geçerlidir, hangisini kullanacağın genelde stil tercihi veya projenin var olan kod düzenine bağlıdır.

whenComplete — finally'nin Asenkron Karşılığı

dart
void main() {
  riskliIslem()
      .then((veri) => print("Veri: $veri"))
      .catchError((hata) => print("Hata: $hata"))
      .whenComplete(() => print("İşlem tamamlandı (başarılı ya da başarısız)"));
}

.whenComplete(), Bölüm 8'de öğrendiğimiz finally'nin .then() zincirlerindeki karşılığıdır — Future başarılı olsun ya da hata versin, her durumda çalışır. Genelde temizlik işlemleri (örneğin bir yükleme göstergesini kapatmak) için kullanılır.

async/await ile karşılığı:

dart
void main() async {
  try {
    String veri = await riskliIslem();
    print("Veri: $veri");
  } catch (e) {
    print("Hata: $e");
  } finally {
    print("İşlem tamamlandı (başarılı ya da başarısız)");
  }
}

Neden Hem .then() Hem async/await Öğrenmelisin?

Modern Dart/Flutter kod tabanlarında async/await çok daha yaygın kullanılır — okunabilirlik, hata yönetimi kolaylığı ve senkron kodla tutarlılık açısından üstündür. Ama .then()'i bilmen gerekiyor çünkü:

  1. Bazı Dart/Flutter API'leri, Future döndüren metodlarını .then() ile kullanmanı öneren dokümantasyonlarla gelir.
  2. Üçüncü parti paketlerde veya eski kod tabanlarında .then() zincirleriyle sıkça karşılaşacaksın.
  3. Bazı çok basit, tek adımlı durumlarda (örneğin bir butona basıldığında tek bir asenkron işlem tetiklemek), .then() bazen daha kısa olabilir:
dart
// Basit bir durumda .then() bazen daha kısa
void butonaTiklandi() {
  kaydet().then((_) => print("Kaydedildi"));
}

// async/await ile aynı iş
Future<void> butonaTiklandiV2() async {
  await kaydet();
  print("Kaydedildi");
}

Genel Tavsiye

Yeni kod yazarken varsayılan olarak async/await kullan. .then()'i, sadece onu kullanan bir API ile çalışırken veya çok kısa, tek satırlık asenkron zincirlerde tercih et. Bu ders, .then()'i okuyabilmen için önemliydi (çünkü karşına çıkacak), ama yazarken genelde async/await'e yöneleceksin.


🎯 Bu Dersten Çıkarılması Gerekenler

  • .then(), bir Future tamamlandığında çalışacak kodu tanımlar; zincirlenebilir, her adım bir öncekinin sonucunu alır.
  • .catchError(), .then() zincirinde oluşan hataları yakalar — try/catch'in asenkron karşılığıdır.
  • .then()'in ikinci onError parametresi de hata yakalamak için kullanılabilir.
  • .whenComplete(), finally'nin asenkron karşılığıdır — başarılı/başarısız fark etmeksizin her zaman çalışır.
  • Modern Dart'ta async/await genelde tercih edilir, ama .then()'i okuyabilmek de önemlidir.

📝 Ödevler

  • [ ] Bir Future zinciri oluştur (.then() ile en az 3 adım), her adımda bir önceki sonucu işle.
  • [ ] Aynı zinciri async/await ile yeniden yaz, iki yaklaşımı karşılaştır.
  • [ ] .catchError() kullanarak bir hata senaryosunu yakala, aynı senaryoyu try/catch ile de yaz.
  • [ ] .whenComplete() kullanarak, hem başarılı hem başarısız bir senaryoda çalışan bir "temizlik" kodu yaz, finally ile karşılaştır.
  • [ ] .then()'in ikinci parametresi olan onError'ı kullanarak, .catchError()'a alternatif bir hata yakalama örneği yaz.

Sıradaki konu: Bölüm 10 — Konu 47: Stream Temelleri, async*, yield

46. bölüm

Bölüm 10 — Konu 47: `Stream` Temelleri, `async*`, `yield`

Future ile Stream Arasındaki Temel Fark

Bir önceki derste Future'ın "gelecekte bir kere gelecek bir değeri" temsil ettiğini öğrenmiştik. Peki ya bir kaynaktan zamanla, birden fazla değer gelecekse? İşte bunun için Stream kullanılır.

Basit bir benzetme:

  • Future = bir paket kargo (bir kere gelir, elinde tutarsın)
  • Stream = bir haber bülteni aboneliği (zamanla, birden fazla haber gelir)
dart
Stream<int> sayiUret() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i; // her saniyede bir değer "yayınla"
  }
}

void main() {
  sayiUret().listen((sayi) {
    print("Alınan sayı: $sayi");
  });
}

Çıktı (her biri 1 saniye arayla):

metin
Alınan sayı: 1
Alınan sayı: 2
Alınan sayı: 3
Alınan sayı: 4
Alınan sayı: 5

async* — Stream Üreten Fonksiyon

Bölüm 10'da async fonksiyonların Future döndürdüğünü öğrenmiştik. async* (yıldızlı versiyon), bunun yerine bir Stream döndüren bir fonksiyon tanımlar:

dart
Stream<int> sayac() async* {
  // fonksiyon gövdesi, zamanla birden fazla değer "yayınlayabilir"
}

Dönüş tipi her zaman Stream<T>'dir — tıpkı async'in her zaman Future<T> döndürmesi gibi.

yield — Bir Değer "Yayınlamak"

yield, bir Stream'e yeni bir değer eklemenin yoludur — return gibi fonksiyonu sonlandırmaz, sadece bir değeri "dışarı gönderir" ve fonksiyon çalışmaya devam eder:

dart
Stream<String> mesajUret() async* {
  yield "Birinci mesaj";
  await Future.delayed(Duration(seconds: 1));
  yield "İkinci mesaj";
  await Future.delayed(Duration(seconds: 1));
  yield "Üçüncü mesaj";
}

void main() {
  mesajUret().listen((mesaj) {
    print(mesaj);
  });
}

Bu, Bölüm 5'te öğrendiğimiz return'den temelde farklıdır: return, fonksiyonu bir kere sonlandırıp tek bir değer döndürür; yield, fonksiyonu sonlandırmadan art arda birden fazla değer gönderebilir.

.listen() — Stream'i "Dinlemek"

dart
void main() {
  Stream<int> stream = sayiUret();

  stream.listen(
    (veri) {
      print("Veri geldi: $veri");
    },
    onError: (hata) {
      print("Hata: $hata");
    },
    onDone: () {
      print("Stream tamamlandı!");
    },
  );
}

.listen(), bir Stream'e abone olmanın yoludur. Üç önemli callback (geri çağırma fonksiyonu) alabilir:

  • İlk parametre (zorunlu): her yeni veri geldiğinde çalışır.
  • onError: stream içinde bir hata oluşursa çalışır.
  • onDone: stream tamamen bittiğinde (artık yeni veri gelmeyeceğinde) çalışır.

Stream'i await for ile Dinleme — async/await Tarzı

.listen() yerine, async/await'e benzer, daha okunabilir bir sözdizimi de kullanılabilir:

dart
Stream<int> sayiUret() async* {
  for (int i = 1; i <= 3; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

void main() async {
  await for (var sayi in sayiUret()) {
    print("Sayı: $sayi");
  }
  print("Stream bitti");
}

await for, Bölüm 3'te öğrendiğimiz for-in döngüsünün asenkron versiyonudur — her yeni değer geldiğinde döngü gövdesi çalışır, stream bitene kadar bu devam eder. Bu, .listen()'e göre genelde daha okunabilir bulunur, özellikle stream'den gelen her değeri sırayla işlemen gerektiğinde.

Gerçek Dünya Senaryoları — Stream Ne Zaman Kullanılır?

Future, "bir kerelik" asenkron işlemler için uygundur (bir API isteği, bir dosya okuma). Stream ise zamanla tekrar tekrar gelen veriler için kullanılır:

  • Kullanıcının yazdığı her karakteri anlık dinlemek (arama kutusu)
  • Bir sensörden (konum, ivmeölçer) sürekli veri almak
  • Bir sohbet uygulamasında gelen her yeni mesajı dinlemek
  • Bir dosyanın, parça parça (chunk chunk) okunması
dart
// Kavramsal örnek — gerçek bir sohbet uygulamasının basitleştirilmiş hali
Stream<String> mesajlariDinle() async* {
  // Gerçek bir uygulamada bu, bir sunucudan gelen WebSocket verisi olurdu
  await Future.delayed(Duration(seconds: 1));
  yield "Ahmet: Merhaba!";
  await Future.delayed(Duration(seconds: 2));
  yield "Ayşe: Selam, nasılsın?";
}

void main() async {
  print("Sohbete katılındı, mesajlar dinleniyor...");
  await for (var mesaj in mesajlariDinle()) {
    print(mesaj);
  }
}

Stream Hata Yönetimi — try/catch ile

dart
Stream<int> riskliStream() async* {
  yield 1;
  yield 2;
  throw Exception("Stream içinde hata oluştu");
}

void main() async {
  try {
    await for (var deger in riskliStream()) {
      print(deger);
    }
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Çıktı:

metin
1
2
Hata yakalandı: Exception: Stream içinde hata oluştu

Bölüm 8'de öğrendiğimiz try/catch, await for ile de tutarlı bir şekilde çalışır — stream içinde bir hata fırlatılırsa, await for döngüsü durur ve hata catch bloğuna düşer.

Sonlu vs Sonsuz Stream

dart
// Sonlu stream — belirli sayıda değer üretip biter
Stream<int> sonluStream() async* {
  yield 1;
  yield 2;
  yield 3;
} // fonksiyon bittiğinde stream de "tamamlanır" (onDone tetiklenir)

// Sonsuz stream — teorik olarak hiç bitmez (dikkatli kullanılmalı!)
Stream<int> sonsuzStream() async* {
  int sayac = 0;
  while (true) {
    await Future.delayed(Duration(seconds: 1));
    yield sayac++;
  }
}

Bölüm 3'te while (true) için verdiğimiz uyarı burada da geçerli — sonsuz bir stream oluşturursan, onu dinleyen tarafın bir noktada dinlemeyi durdurması (.cancel() ile, bir sonraki konuda değinebiliriz) veya uygulamanın yaşam döngüsüyle yönetilmesi gerekir, aksi halde kaynak sızıntısına (resource leak) yol açabilir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Stream, zamanla birden fazla değer üreten bir asenkron kaynağı temsil eder (Future'ın aksine, tek bir değer değil).
  • async*, bir Stream<T> döndüren fonksiyon tanımlar; yield, fonksiyonu sonlandırmadan bir değer "yayınlar".
  • .listen(), bir stream'e abone olmanın temel yoludur; onError ve onDone callback'leri alabilir.
  • await for, stream'i for-in'e benzer, okunabilir bir şekilde dinlemenin yoludur.
  • try/catch, stream içindeki hataları da senkron kod gibi yakalayabilir.

📝 Ödevler

  • [ ] async* ve yield kullanarak, 1'den 5'e kadar sayıları birer saniye arayla üreten bir Stream yaz, .listen() ile dinle.
  • [ ] Aynı Stream'i await for ile dinle, iki yaklaşımı karşılaştır.
  • [ ] .listen()'in onDone callback'ini kullanarak, stream tamamlandığında özel bir mesaj yazdır.
  • [ ] Bir stream içinde throw ile hata fırlat, try/catch (await for ile) kullanarak yakala.
  • [ ] Kendi senaryonu düşün (örn. bir sipariş takip sistemi, sırayla durum güncellemeleri yayınlayan) ve bunu bir Stream ile modelle.

Sıradaki konu: Bölüm 10 — Konu 48: StreamController, Broadcast Stream

47. bölüm

Bölüm 10 — Konu 48: `StreamController`, Broadcast Stream

Bölüm 10'un son konusundayız. Bir önceki derste async*/yield ile stream üretmeyi gördük — bu, "otomatik" bir stream oluşturma yoluydu. Bu derste, bir stream'e elle, istediğin an veri eklemeni sağlayan StreamController'ı işleyeceğiz.

StreamController Nedir?

dart
import 'dart:async';

void main() {
  StreamController<int> controller = StreamController<int>();

  controller.stream.listen((veri) {
    print("Alınan veri: $veri");
  });

  controller.add(1); // stream'e elle veri ekliyoruz
  controller.add(2);
  controller.add(3);

  controller.close(); // stream'i kapatıyoruz
}

Çıktı:

metin
Alınan veri: 1
Alınan veri: 2
Alınan veri: 3

StreamController, bir Stream'i "programatik olarak" (elle, istediğin zaman) besleyebileceğin bir araçtır. async*/yield ile otomatik akan bir stream'in aksine, burada sen ne zaman veri ekleneceğine karar veriyorsun — controller.add(...) çağırdığın her an, o değer stream'e "yayınlanır."

Not: dart:async kütüphanesini import etmemiz gerekti — StreamController, Dart'ın çekirdek (dart:core) kütüphanesinde değil, dart:async kütüphanesinde tanımlıdır. Bölüm 12'de kütüphaneler ve import'ları detaylı işleyeceğiz; şimdilik bazı ileri özelliklerin ayrı kütüphanelerden geldiğini bilmen yeterli.

StreamController'ın Parçaları

dart
StreamController<int> controller = StreamController<int>();

controller.stream  // dinlemek (listen) için kullanılan Stream nesnesi
controller.sink    // veri eklemek için kullanılan "giriş noktası" (add ile aynı işi görür)
controller.add(5)  // controller.sink.add(5) ile aynı etkiyi yapar, kısayoldur
controller.close() // stream'i kapatır, artık veri eklenemez

controller.stream, dışarıya (dinleyicilere) açılan taraf; controller.add() (veya controller.sink.add()), içeriye veri "besleyen" taraf. Bunu bir su borusu gibi düşünebilirsin — add() ile bir uçtan su akıtırsın, .stream.listen() ile diğer uçtan suyu toplarsın.

Neden StreamController Kullanılır? — Gerçek Dünya Senaryosu

async*/yield, önceden bilinen, otomatik bir akış için uygundur (örneğin "her saniye bir sayı üret"). Ama bazen, stream'e ne zaman veri ekleneceği dışarıdan tetiklenen bir olaya bağlıdır — örneğin bir buton her tıklandığında, ya da bir sensörden veri her geldiğinde:

dart
import 'dart:async';

class ButonTikayici {
  final StreamController<int> _controller = StreamController<int>();
  int _sayac = 0;

  Stream<int> get tiklamaStream => _controller.stream;

  void butonaTikla() {
    _sayac++;
    _controller.add(_sayac); // dışarıdan tetiklenen bir olayda veri ekleniyor
  }

  void kapat() {
    _controller.close();
  }
}

void main() {
  ButonTikayici buton = ButonTikayici();

  buton.tiklamaStream.listen((sayi) {
    print("Tıklama sayısı: $sayi");
  });

  buton.butonaTikla(); // Tıklama sayısı: 1
  buton.butonaTikla(); // Tıklama sayısı: 2
  buton.butonaTikla(); // Tıklama sayısı: 3

  buton.kapat();
}

Bu, Flutter'da çok yaygın bir kalıptır — bir buton her tıklandığında, bir text field her değiştiğinde, veya bir state değişikliği her olduğunda, StreamController ile bu olayları "yayınlayabilirsin", ve uygulamanın farklı yerleri bu stream'i dinleyerek tepki verebilir.

Tek Dinleyicili (Single-Subscription) vs Broadcast Stream

Varsayılan olarak, bir StreamController'ın stream'i sadece bir kere, bir dinleyici tarafından dinlenebilir:

dart
void main() {
  StreamController<int> controller = StreamController<int>();

  controller.stream.listen((veri) => print("Dinleyici 1: $veri"));
  controller.stream.listen((veri) => print("Dinleyici 2: $veri")); // ❌ HATA!

  controller.add(1);
}

Bu kod hata verir — Bad state: Stream has already been listened to. Varsayılan stream'ler, tek kullanımlık kabul edilir (buna "single-subscription stream" denir) — genelde bir dosya okuma gibi, "baştan sona bir kere işlenecek" senaryolar için tasarlanmıştır.

Broadcast Stream — Birden Fazla Dinleyici

Eğer birden fazla dinleyicinin aynı veriyi almasını istiyorsan, StreamController.broadcast() kullanman gerekir:

dart
void main() {
  StreamController<int> controller = StreamController<int>.broadcast();

  controller.stream.listen((veri) => print("Dinleyici 1: $veri"));
  controller.stream.listen((veri) => print("Dinleyici 2: $veri")); // ✅ artık çalışır!

  controller.add(1);
  controller.add(2);
}

Çıktı:

metin
Dinleyici 1: 1
Dinleyici 2: 1
Dinleyici 1: 2
Dinleyici 2: 2

broadcast(), tıpkı bir radyo yayını gibi çalışır — birden fazla "dinleyici" (subscriber) aynı anda aynı veriyi alabilir. Bu, örneğin bir uygulamanın birden fazla farklı ekranının, aynı "kullanıcı oturum durumu" stream'ini aynı anda dinlemesi gerektiğinde kullanışlıdır.

Broadcast Stream'in Önemli Bir Farkı — Geç Katılan Dinleyiciler

dart
void main() {
  StreamController<int> controller = StreamController<int>.broadcast();

  controller.add(1); // henüz kimse dinlemiyor, bu veri KAYBOLUR

  controller.stream.listen((veri) => print("Geç gelen dinleyici: $veri"));

  controller.add(2); // bu veri alınır
}

Çıktı:

metin
Geç gelen dinleyici: 2

Broadcast stream'lerde, bir dinleyici abone olmadan önce yayınlanan veriler, o dinleyici için kaybolur — tıpkı canlı bir radyo yayınına, yayın başladıktan sonra katılmak gibi, geçmiş yayını dinleyemezsin. Bu, single-subscription stream'lerden farklı bir davranıştır ve dikkat edilmesi gereken bir noktadır.

close() — Kaynak Yönetimi

dart
void main() {
  StreamController<int> controller = StreamController<int>();

  controller.stream.listen((veri) => print(veri));
  controller.add(1);

  controller.close(); // artık add() çağrılamaz, kaynaklar serbest bırakılır

  controller.add(2); // ❌ HATA! kapatılmış bir controller'a veri eklenemez
}

Bir önceki derste sonsuz stream'ler için verdiğimiz "kaynak sızıntısı" uyarısı burada somutlaşıyor: bir StreamController artık kullanılmayacaksa, .close() çağrılarak kaynakların serbest bırakılması önemlidir. Flutter'da, bu genelde bir widget'ın dispose() metodunda yapılır (Flutter tutorial'ında bunu tam olarak göreceğiz) — bir widget ekrandan kaldırıldığında, kullandığı StreamController'ları kapatmak, bellek sızıntılarını önler.


🎯 Bu Dersten Çıkarılması Gerekenler

  • StreamController, bir stream'e elle, istediğin an veri eklemeni sağlar (add() ile); dışarıdan tetiklenen olaylar için async*/yield'e göre daha uygundur.
  • Varsayılan StreamController, tek bir dinleyiciye izin verir (single-subscription); birden fazla dinleyici için StreamController.broadcast() kullanılmalıdır.
  • Broadcast stream'lerde, bir dinleyici abone olmadan önce yayınlanan veriler o dinleyici için kaybolur.
  • .close(), bir controller'ın kaynaklarını serbest bırakır — artık kullanılmayacak controller'lar için önemlidir (Flutter'da genelde dispose() içinde yapılır).

📝 Ödevler

  • [ ] Bir StreamController<int> oluştur, elle birkaç değer ekle (.add()), .listen() ile dinle.
  • [ ] Aynı controller'ı iki farklı dinleyici ile dinlemeyi dene (broadcast olmadan), hatayı gözlemle; sonra .broadcast() ile düzelt.
  • [ ] Broadcast bir stream'de, bir dinleyicinin geç abone olduğunda önceki verileri kaçırdığını kanıtlayan bir örnek yaz.
  • [ ] ButonTikayici benzeri bir sınıf yaz — dışarıdan tetiklenen bir olayı (örn. bir mesaj gönderme fonksiyonu) StreamController ile stream'e dönüştür.
  • [ ] Bir controller'ı .close() ile kapat, sonra .add() çağırmayı dene, hatayı gözlemle ve neden close()'un önemli olduğunu yorumla.

🏁 Bölüm 10 Tamamlandı!

Asenkron programlamanın tüm temel araçlarını işledik: Future, async/await, .then()/.catchError(), Stream, async*/yield ve StreamController. Bu, Flutter'da API çağrıları yapmak, gerçek zamanlı veri dinlemek ve kullanıcı etkileşimlerini yönetmek için doğrudan kullanacağın bilgi birikimi.

Sıradaki durak Bölüm 11 — Koleksiyonlarda İleri Fonksiyonel Programlama: map, where, reduce, fold gibi metodlarla, koleksiyonları çok daha güçlü ve kısa bir şekilde işlemeyi öğreneceğiz.

48. bölüm

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

dart
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:

dart
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:

dart
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

dart
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

dart
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:

metin
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:

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

fold — reduce'un Daha Esnek Versiyonu

dart
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:

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

2. Farklı bir tipe "indirgeyebilirsin":

dart
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

Kriter reduce fold
Boş koleksiyonda çalışır mı? ❌ Hata verir ✅ Başlangıç değerini döndürür
Sonuç tipi, eleman tipiyle aynı olmalı mı? ✅ Evet ❌ Hayır, farklı olabilir
Başlangıç değeri belirtebilir misin? ❌ Hayır ✅ Evet

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

dart
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

49. bölüm

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

Basit Sıralama — .sort()

dart
void main() {
  List<int> sayilar = [5, 2, 8, 1, 9, 3];
  sayilar.sort();
  print(sayilar); // [1, 2, 3, 5, 8, 9]
}

.sort(), sayılar ve string'ler gibi doğal bir sıralamaya sahip tipler için, herhangi bir parametre vermeden çağrılabilir — küçükten büyüğe sıralar.

Kritik detay: .sort() listeyi yerinde (in-place) değiştirir!

dart
void main() {
  List<int> sayilar = [5, 2, 8];
  List<int> sonuc = sayilar.sort(); // ❌ HATA! sort() void döndürür, bir liste değil

  sayilar.sort(); // ✅ doğrusu — orijinal listeyi DEĞİŞTİRİR
  print(sayilar); // [2, 5, 8]
}

Bu, Bölüm 11 Konu 49'da öğrendiğimiz .map()/.where()'den temel bir farktır — .map() ve .where() yeni bir koleksiyon üretirken, .sort() var olan listeyi doğrudan değiştirir (mutate eder) ve void döndürür. Bu yüzden .sort()'u bir değişkene atayamazsın, sadece çağırırsın.

String Listesi Sıralama

dart
void main() {
  List<String> isimler = ["Zeynep", "Ahmet", "Mehmet", "Ayşe"];
  isimler.sort();
  print(isimler); // [Ahmet, Ayşe, Mehmet, Zeynep] — alfabetik sıra
}

Stringler, alfabetik olarak (aslında karakterlerin Unicode değerlerine göre) sıralanır.

Custom Comparator — Kendi Sıralama Mantığını Tanımlamak

Sayı ve string dışındaki tipler (kendi class'ların gibi) için, Dart nasıl sıralayacağını bilemez — bu yüzden bir comparator (karşılaştırıcı) fonksiyon vermen gerekir:

dart
class Kisi {
  String isim;
  int yas;
  Kisi(this.isim, this.yas);

  @override
  String toString() => "$isim ($yas)";
}

void main() {
  List<Kisi> kisiler = [
    Kisi("Ahmet", 30),
    Kisi("Ayşe", 25),
    Kisi("Mehmet", 35),
  ];

  kisiler.sort((a, b) => a.yas.compareTo(b.yas)); // yaşa göre küçükten büyüğe
  print(kisiler); // [Ayşe (25), Ahmet (30), Mehmet (35)]
}

compareTo() nasıl çalışır? Bölüm 9'da Comparable interface'ini görmüştük — compareTo(), iki değeri karşılaştırıp şunlardan birini döndürür:

  • Negatif bir sayı: a, b'den küçükse
  • Sıfır: a ve b eşitse
  • Pozitif bir sayı: a, b'den büyükse

.sort()'a verdiğin fonksiyon, tam olarak bu mantığı takip etmeli — negatif dönerse a önce gelir, pozitif dönerse b önce gelir.

Büyükten Küçüğe Sıralama (Descending)

dart
void main() {
  List<int> sayilar = [5, 2, 8, 1, 9];
  sayilar.sort((a, b) => b.compareTo(a)); // a ve b'nin yeri DEĞİŞTİ!
  print(sayilar); // [9, 8, 5, 2, 1]
}

a.compareTo(b) yerine b.compareTo(a) yazmak, sıralamayı tersine çevirir — bu basit bir kalıptır, küçükten büyüğe sıralamanın "aynasıdır."

Alternatif, daha okunabilir bir yöntem:

dart
void main() {
  List<int> sayilar = [5, 2, 8, 1, 9];
  sayilar.sort((a, b) => (b - a)); // sayılar için, çıkarma ile de yapılabilir
  print(sayilar); // [9, 8, 5, 2, 1]
}

Sayısal tipler için b - a, b.compareTo(a) ile aynı sonucu verir (negatif/pozitif/sıfır mantığı korunur) — ama compareTo() kullanmak, her tipte (sadece sayılarda değil) çalıştığı için daha genel ve tercih edilen bir yaklaşımdır.

Birden Fazla Kritere Göre Sıralama

dart
class Ogrenci {
  String isim;
  int not;
  Ogrenci(this.isim, this.not);

  @override
  String toString() => "$isim: $not";
}

void main() {
  List<Ogrenci> ogrenciler = [
    Ogrenci("Ahmet", 85),
    Ogrenci("Ayşe", 90),
    Ogrenci("Mehmet", 85),
    Ogrenci("Zeynep", 90),
  ];

  // önce nota göre (büyükten küçüğe), eşitse isme göre (alfabetik) sırala
  ogrenciler.sort((a, b) {
    int notKarsilastirma = b.not.compareTo(a.not);
    if (notKarsilastirma != 0) return notKarsilastirma;
    return a.isim.compareTo(b.isim);
  });

  print(ogrenciler);
  // [Ayşe: 90, Zeynep: 90, Ahmet: 85, Mehmet: 85]
}

Bu kalıp, birincil ve ikincil sıralama kriterleri kurmanı sağlıyor: önce nota göre karşılaştır, eğer notlar eşitse (0 döndüyse), isim karşılaştırmasına "geç." Bu, gerçek uygulamalarda (örneğin bir liderlik tablosu — leaderboard) çok sık karşılaşacağın bir gereksinimdir.

List.sort() vs Yeni Bir Sıralı Liste Oluşturma

Bazen orijinal listeyi değiştirmeden, sıralanmış yeni bir liste istersin. .sort() bunu yapmaz (yerinde değiştirir), ama şu kalıp işe yarar:

dart
void main() {
  List<int> orijinal = [5, 2, 8, 1];
  List<int> siraliKopya = List.from(orijinal)..sort(); // önce kopyala, sonra sırala

  print(orijinal);    // [5, 2, 8, 1] — DEĞİŞMEDİ
  print(siraliKopya); // [1, 2, 5, 8] — yeni, sıralı liste
}

List.from(orijinal), orijinal listenin bir kopyasını oluşturur; ..sort() (cascade notasyonu — Bölüm 11 Konu 52'de tam olarak işleyeceğiz) bu kopyayı sıralar. Bu sayede orijinal liste korunmuş olur.

List.sorted — Alternatif (Immutable) Yaklaşım

Bazı modern Dart sürümlerinde/paketlerinde, orijinal listeyi değiştirmeyen sıralama fonksiyonları da mevcuttur — ama bu, temel dart:core kütüphanesinin standart bir parçası değildir (genelde collection gibi ek paketlerden gelir). Şimdilik yukarıdaki List.from(...)..sort() kalıbını bilmen, temel ihtiyaçların için yeterlidir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • .sort(), listeyi yerinde (in-place) değiştirir, void döndürür — yeni bir liste üretmez.
  • Sayı ve String gibi doğal sıralamaya sahip tipler, parametresiz .sort() ile sıralanabilir.
  • Kendi tiplerin için, compareTo() mantığını takip eden bir comparator fonksiyonu ((a, b) => ...) vermen gerekir.
  • b.compareTo(a) ile sıralama tersine çevrilebilir (büyükten küçüğe).
  • Birden fazla kritere göre sıralama, ilk kriter eşit çıktığında ikinci bir karşılaştırmaya "düşerek" yapılır.
  • Orijinal listeyi korumak istiyorsan, önce List.from(...) ile kopyala, sonra kopyayı sırala.

📝 Ödevler

  • [ ] Bir sayı listesini önce küçükten büyüğe, sonra büyükten küçüğe sırala.
  • [ ] Kendi yazdığın bir class'ın listesini (örn. Urun — ad ve fiyat alanlarıyla), fiyata göre custom comparator ile sırala.
  • [ ] Aynı listeyi büyükten küçüğe (fiyata göre) sırala, compareTo() sırasını değiştirerek.
  • [ ] Birden fazla kritere göre sıralama yap (örn. önce şehre göre, sonra isme göre) — en az 2 kriterli bir örnek yaz.
  • [ ] List.from(...)..sort() kalıbını kullanarak, orijinal listeyi değiştirmeden sıralanmış yeni bir liste oluştur, ikisinin de farklı olduğunu kanıtla.

Sıradaki konu: Bölüm 11 — Konu 51: Iterable Kavramı Derinlemesine (Lazy Evaluation)

50. bölüm

Bölüm 11 — Konu 51: Iterable Kavramı Derinlemesine (Lazy Evaluation)

Bir önceki derste .map()'in Iterable döndürdüğünü, .toList() ile bir listeye çevirmemiz gerektiğini görmüştük. Bu derste, Iterable gerçekte nedir ve neden map/where bu tipi döndürür sorularının cevabını tam olarak vereceğiz.

Iterable Nedir?

Iterable, Bölüm 4'te öğrendiğimiz List, Set gibi tüm "gezinebilir" koleksiyonların üst tipidir (Bölüm 7'de öğrendiğimiz kalıtım kavramını hatırla). Yani List ve Set, aslında Iterable'ın alt sınıflarıdır:

dart
void main() {
  List<int> liste = [1, 2, 3];
  Set<int> set = {1, 2, 3};

  print(liste is Iterable); // true
  print(set is Iterable);   // true
}

Iterable, "üzerinde for-in ile gezinilebilen" anlamına gelen genel bir sözleşmedir (Bölüm 7'de öğrendiğimiz soyut sınıf/interface mantığına benzer). List, buna ek olarak indeksli erişim (liste[0]) gibi ekstra özellikler sağlar; Iterable'ın kendisi bunu garanti etmez.

Lazy Evaluation (Tembel Değerlendirme) — Temel Kavram

.map() ve .where()'in Iterable döndürmesinin asıl sebebi budur: bu metodlar, çağrıldıkları anda hesaplamayı hemen yapmazlar — hesaplama, sonuç gerçekten kullanılana kadar ertelenir. Buna lazy evaluation (tembel değerlendirme) denir.

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

  print("map() çağrılıyor...");
  Iterable<int> kareler = sayilar.map((sayi) {
    print("  $sayi işleniyor");
    return sayi * sayi;
  });
  print("map() çağrısı bitti, ama hiçbir 'işleniyor' yazısı GÖRMEDİK!");

  print("Şimdi toList() çağrılıyor...");
  List<int> kareListesi = kareler.toList(); // İŞTE ŞİMDİ hesaplama gerçekten çalışır
}

Çıktı:

metin
map() çağrılıyor...
map() çağrısı bitti, ama hiçbir 'işleniyor' yazısı GÖRMEDİK!
Şimdi toList() çağrılıyor...
  1 işleniyor
  2 işleniyor
  3 işleniyor
  4 işleniyor
  5 işleniyor

Bu çok önemli bir gözlem: sayilar.map(...) satırı çalıştığında, verdiğimiz fonksiyon (print(" $sayi işleniyor") içeren) hiç çalışmadı. Sadece .toList() çağrıldığında (yani sonucun gerçekten kullanılacağı an geldiğinde), hesaplama fiilen gerçekleşti.

Neden Lazy Evaluation Faydalıdır?

1. Gereksiz hesaplamadan kaçınma:

dart
void main() {
  List<int> sayilar = List.generate(1000000, (i) => i); // 1 milyon eleman

  Iterable<int> ilkBesKare = sayilar.map((sayi) => sayi * sayi).take(5);
  print(ilkBesKare.toList()); // [0, 1, 4, 9, 16]
}

Burada, .map() 1 milyon elemanın hepsini işlemek yerine, .take(5) ile sadece ilk 5 sonuca ihtiyacımız olduğunu belirttik. Lazy evaluation sayesinde, Dart aslında sadece ilk 5 eleman için map fonksiyonunu çalıştırır — geri kalan 999.995 eleman hiç işlenmez. Eğer .map() "eager" (hemen, istekli) çalışsaydı, gereksiz yere milyonlarca işlem yapılırdı.

2. Zincirleme işlemler, tek bir geçişte birleşir:

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

  var sonuc = sayilar
      .where((s) => s % 2 == 0)
      .map((s) => s * 10)
      .toList();

  print(sonuc); // [20, 40]
}

Bu zincirde, .where() ve .map(), ayrı ayrı, tam listeler oluşturarak çalışmaz (yani önce tüm liste filtrelenip yeni bir liste oluşturulmaz, sonra o listenin tamamı map edilmez). Bunun yerine, .toList() çağrıldığında, her eleman için, önce where kontrolü, hemen ardından (eleman geçtiyse) map dönüşümü art arda, o eleman üzerinde uygulanır. Bu, büyük koleksiyonlarda daha az ara bellek kullanımı anlamına gelir.

Iterable mı List mi Döndürmeli? — Kendi Fonksiyonlarını Yazarken

dart
// Iterable döndüren fonksiyon — çağıran taraf ne zaman "gerçekleştireceğine" karar verir
Iterable<int> ciftSayilariGetir(List<int> sayilar) {
  return sayilar.where((s) => s % 2 == 0);
}

// List döndüren fonksiyon — hesaplama hemen, burada tamamlanır
List<int> ciftSayilariGetirListe(List<int> sayilar) {
  return sayilar.where((s) => s % 2 == 0).toList();
}

Pratik tavsiye: Çoğu durumda, özellikle küçük/orta boyutlu koleksiyonlarla çalışırken, .toList() çağırıp List döndürmek daha basit ve öngörülebilirdir — çünkü sonucu birden fazla kere kullanacaksan (örneğin .length almak, sonra elemanlara erişmek), her seferinde yeniden hesaplanmasını istemezsin. Iterable'ı olduğu gibi (lazy) bırakmak, genelde sadece performans kritik, büyük veri setleriyle çalışırken veya tek seferlik bir gezinme yapacaksan tercih edilir.

Lazy Evaluation'ın Bir Tuzağı — Her Erişimde Yeniden Hesaplama

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

  Iterable<int> sonuc = sayilar.map((s) {
    sayac++;
    return s * 2;
  });

  print(sonuc.toList()); // sayac 3 kez artar (1, 2, 3 işlenir)
  print(sayac); // 3

  print(sonuc.toList()); // ❌ TEKRAR hesaplanır! sayac yine 3 artar
  print(sayac); // 6 — beklenmedik bir şekilde iki katına çıktı!
}

Bu, lazy evaluation'ın dikkat edilmesi gereken bir yönüdür: Iterable, sonucu saklamaz (cache'lemez) — her .toList() (veya başka bir "gerçekleştirme" işlemi) çağrıldığında, hesaplama baştan tekrar yapılır. Eğer sonucu birden fazla kere kullanacaksan, bir kere .toList() çağırıp sonucu bir değişkende saklamak çok daha güvenli ve performanslıdır:

dart
void main() {
  List<int> sayilar = [1, 2, 3];
  List<int> sonuc = sayilar.map((s) => s * 2).toList(); // BİR KERE hesapla

  print(sonuc); // [2, 4, 6] — bu, listeden okumak, tekrar hesaplamak değil
  print(sonuc); // aynı liste, tekrar hesaplama YOK
}

Diğer Iterable Metodları — Kısa Bir Bakış

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

  print(sayilar.take(3));       // (1, 2, 3) — ilk 3 eleman
  print(sayilar.skip(2));       // (3, 4, 5) — ilk 2'yi atla
  print(sayilar.any((s) => s > 4)); // true — en az bir eleman koşulu sağlıyor mu?
  print(sayilar.every((s) => s > 0)); // true — TÜM elemanlar koşulu sağlıyor mu?
  print(sayilar.firstWhere((s) => s > 3)); // 4 — koşulu sağlayan ilk eleman
}

Bu metodlar da (.take(), .skip() gibi) aynı lazy evaluation prensibiyle çalışır — .any() ve .every() gibi bazıları ise sonucu doğrudan bool olarak ürettiği için "gerçekleştirme" (toList gibi) gerektirmez, doğrudan kullanılabilir.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Iterable, List ve Set gibi "gezinebilir" koleksiyonların üst tipidir.
  • .map(), .where() gibi metodlar lazy (tembel) çalışır — hesaplama, sonuç gerçekten kullanılana (.toList(), for-in vb.) kadar ertelenir.
  • Lazy evaluation, gereksiz hesaplamalardan kaçınmayı ve zincirleme işlemlerde verimliliği sağlar.
  • Sonucu birden fazla kere kullanacaksan, bir kere .toList() çağırıp sonucu saklamak gerekir — aksi halde her erişimde hesaplama tekrar yapılır.
  • .take(), .skip(), .any(), .every(), .firstWhere() gibi metodlar da Iterable üzerinde çalışan, benzer prensiplere sahip yardımcı araçlardır.

📝 Ödevler

  • [ ] Bir .map() çağrısı içine bir print koyarak, .toList() çağrılmadan önce hiçbir işlemin çalışmadığını kanıtla.
  • [ ] 1 milyon elemanlı bir listede .map() ve .take(5) kullanarak, sadece gerekli elemanların işlendiğini bir sayaç ile kanıtla.
  • [ ] Bir Iterable sonucunu iki kere .toList() ile "gerçekleştir", bir sayaç kullanarak hesaplamanın iki kere yapıldığını göster; sonra sonucu bir değişkende saklayarak bu tekrarı önle.
  • [ ] .take(), .skip(), .any(), .every() metodlarından her birini kullanan birer örnek yaz.
  • [ ] Kendi cümlelerinle, "neden map() ve where() doğrudan List değil de Iterable döndürür" sorusunu, bu dersten öğrendiklerinle açıkla.

Sıradaki konu: Bölüm 11 — Konu 52: Cascade Notasyonu (..)

51. bölüm

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

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.

52. bölüm

Bölüm 12 — Konu 53: `pubspec.yaml`, pub.dev'den Paket Ekleme

Bölüm 12'ye hoş geldin — bu bölüm, tek dosyalık script'lerden gerçek, çok dosyalı projelere geçişi işliyor. İlk durağımız, Bölüm 1'de kısaca gördüğümüz pubspec.yaml'ı derinlemesine anlamak.

pubspec.yaml Nedir?

Bölüm 1'de bir Dart projesi oluşturduğumuzda karşımıza çıkan pubspec.yaml, projenin kimlik kartı ve bağımlılık listesidir. Her Dart/Flutter projesinin kök dizininde bulunur.

yaml
name: benim_projem
description: Bu benim ilk Dart projem
version: 1.0.0
environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  http: ^1.1.0

dev_dependencies:
  test: ^1.24.0
  lints: ^3.0.0

Temel alanları inceleyelim:

  • name: Projenin adı (alt çizgi kullanır, tire değil — Dart paket isimlendirme kuralı).
  • description: Projenin kısa açıklaması.
  • version: Projenin sürüm numarası (genelde semantic versioning — major.minor.patch formatında).
  • environment: Bu projenin hangi Dart SDK sürümleriyle uyumlu olduğunu belirtir.
  • dependencies: Uygulamanın çalışması için gereken paketler (örneğin http — API istekleri için).
  • dev_dependencies: Sadece geliştirme sırasında gereken paketler (örneğin test — test yazmak için, üretim kodunda gerekmez).

YAML Formatı — Kısa Bir Not

pubspec.yaml, YAML formatında yazılır — bu, JSON'a benzer ama daha okunabilir bir veri formatıdır, girintiye (indentation) duyarlıdır (tıpkı Python gibi). Bölüm 1'de "Dart girintiye duyarlı değildir, süslü parantez kullanır" demiştik — ama pubspec.yaml, Dart kodu değil, YAML dosyasıdır, bu yüzden farklı kurallara tabidir. Girinti hatası (yanlış boşluk sayısı), YAML dosyalarında gerçek bir hataya yol açar.

Semantic Versioning (Semver) — ^ İşaretinin Anlamı

yaml
dependencies:
  http: ^1.1.0

^1.1.0, "1.1.0 ile başlayan, ama 1.x.x aralığında kalan (2.0.0'a geçmeyen) herhangi bir sürüm" anlamına gelir. Bunun mantığı, semantic versioning kuralına dayanır: sürüm numaraları major.minor.patch şeklindedir ve:

  • major (ilk sayı) değişirse: kırıcı (breaking) değişiklikler olabilir.
  • minor (ikinci sayı) değişirse: yeni özellikler, geriye dönük uyumlu.
  • patch (üçüncü sayı) değişirse: hata düzeltmeleri, geriye dönük uyumlu.

^1.1.0, "1.1.0'dan itibaren, major sürüm değişmeden (yani 2.0.0'a kadar, dahil değil) her güncellemeyi otomatik kabul et" demektir — bu, hata düzeltmelerini ve yeni özellikleri otomatik alırken, kırıcı değişikliklerden korunmanı sağlar.

Paket Ekleme — pub add Komutu

bash
dart pub add http

Bu komut, http paketini otomatik olarak pubspec.yaml'a ekler ve indirir. Manuel olarak pubspec.yaml'ı düzenleyip sonra dart pub get çalıştırmak yerine, bu komut süreci hızlandırır.

Dev dependency eklemek için:

bash
dart pub add --dev test

--dev bayrağı, paketin dev_dependencies altına eklenmesini sağlar.

dart pub get — Bağımlılıkları İndirme

bash
dart pub get

Bu komut, pubspec.yaml'da listelenen tüm bağımlılıkları indirir (ve gerekli alt bağımlılıklarını da çözümler). Bir projeyi ilk kez klonladığında (örneğin GitHub'dan indirdiğinde), pub get çalıştırman gerekir — çünkü paket dosyalarının kendisi genelde projeyle birlikte paylaşılmaz, sadece hangi paketlerin gerektiği listelenir.

pubspec.lock — Kesin Sürümleri Kilitleme

dart pub get çalıştırdığında, otomatik olarak pubspec.lock adında bir dosya da oluşur/güncellenir. Bu dosya, pubspec.yaml'daki ^1.1.0 gibi esnek sürüm aralıklarının, o an tam olarak hangi sürüme çözümlendiğini kaydeder (örneğin 1.2.3). Bu, önemlidir çünkü:

pubspec.lock olmadan: İki farklı geliştirici, aynı pubspec.yaml ile çalışsa bile, ^1.1.0 farklı zamanlarda dart pub get çalıştırdıklarında farklı sürümler (örneğin biri 1.2.0, diğeri 1.3.0) alabilir — bu, "benim bilgisayarımda çalışıyor ama seninkinde çalışmıyor" tarzı sorunlara yol açabilir.

pubspec.lock ile: Herkes, dosyada kayıtlı tam olarak aynı sürümleri kullanır — bu, projenin tutarlı ve tekrarlanabilir (reproducible) olmasını sağlar. pubspec.lock, genelde versiyon kontrol sistemine (Git) dahil edilir (uygulamalar için — paketler/kütüphaneler için farklı bir pratik uygulanır, ama bu ileri bir detay).

pub.dev — Dart'ın Paket Deposu

pub.dev, Dart/Flutter ekosisteminin resmi paket deposudur — tıpkı JavaScript'in npm'i, Python'un PyPI'ı gibi. Buradan binlerce açık kaynak paket bulabilirsin: HTTP istekleri için http veya dio, tarih işlemleri için intl, yerel depolama için shared_preferences gibi (bunların birçoğunu ileride Flutter tutorial'ında kullanacağız).

Bir paketi pub.dev'de değerlendirirken dikkat edilmesi gerekenler:

  • Popularity/Likes: Ne kadar yaygın kullanılıyor?
  • Pub Points: Paketin kod kalitesi, dokümantasyonu gibi otomatik değerlendirilen bir puan.
  • Son güncelleme tarihi: Terk edilmiş (uzun süredir güncellenmemiş) bir pakete bağımlı olmak risklidir.
  • Null safety desteği: Modern bir paket olup olmadığı.

import ile Kullanma — Bölüm 1'e Bağlantı

dart
import 'package:http/http.dart' as http;

void main() async {
  // http paketini artık kullanabilirsin (Bölüm 5'te API çağrılarında detaylı göreceğiz)
}

pubspec.yaml'a eklenen bir paket, kodunda import 'package:paket_adi/...' şeklinde import edilerek kullanılabilir hale gelir. Bu sözdizimini bir sonraki derste (kütüphane oluşturma, import/export) tam olarak işleyeceğiz.


🎯 Bu Dersten Çıkarılması Gerekenler

  • pubspec.yaml, bir Dart/Flutter projesinin kimliğini ve bağımlılıklarını tanımlayan YAML dosyasıdır.
  • dependencies, uygulamanın çalışması için gereken paketleri; dev_dependencies, sadece geliştirme sırasında gereken araçları listeler.
  • ^1.1.0 gibi sürüm belirteçleri, semantic versioning kurallarına göre, kırıcı olmayan güncellemeleri otomatik kabul eder.
  • dart pub get, bağımlılıkları indirir; dart pub add paket_adi, bir paketi otomatik ekler.
  • pubspec.lock, tam sürümleri kilitleyerek projenin farklı ortamlarda tutarlı çalışmasını sağlar.
  • pub.dev, Dart'ın resmi paket deposudur; popülerlik, pub points ve güncellik gibi kriterlerle paket seçimi yapılmalıdır.

📝 Ödevler

  • [ ] Yeni bir Dart projesi oluştur (dart create), pubspec.yaml dosyasını incele, her alanın ne işe yaradığını yorum olarak not et.
  • [ ] dart pub add ile pub.dev'den bir paket ekle (örn. http veya intl), pubspec.yaml'ın nasıl güncellendiğini gözlemle.
  • [ ] pubspec.lock dosyasını aç, pubspec.yaml'daki esnek sürüm belirteçlerinin burada nasıl "kilitlendiğini" incele.
  • [ ] pub.dev'e git, bir paket ara, Popularity/Pub Points/son güncelleme tarihi gibi kriterlere bakarak "bu paketi kullanır mıydım" diye değerlendir.
  • [ ] --dev bayrağıyla bir geliştirme bağımlılığı ekle (örn. test), dependencies ile dev_dependencies arasındaki farkı pubspec.yaml'da gözlemle.

Sıradaki konu: Bölüm 12 — Konu 54: Kütüphane Oluşturma, import/export, part/part of

53. bölüm

Bölüm 12 — Konu 54: Kütüphane Oluşturma, `import`/`export`, `part`/`part of`

Dart'ta "Kütüphane" (Library) Kavramı

Bölüm 6'da _ (alt çizgi) ile private alan/metod tanımlamayı öğrenmiştik ve "bu, dosyaya (library) özeldir" demiştik. Şimdi bu "library" kavramını tam olarak açıklayalım: Dart'ta, her .dart dosyası aslında kendi başına bir kütüphanedir (özel bir library anahtar kelimesi yazmasan bile).

Basit Bir Proje Yapısı Örneği

metin
benim_projem/
  lib/
    matematik_yardimci.dart
    main.dart
  pubspec.yaml

lib/matematik_yardimci.dart:

dart
int kare(int x) => x * x;
int kup(int x) => x * x * x;

int _dahiliYardimci(int x) => x + 1; // alt çizgi ile private

lib/main.dart:

dart
import 'matematik_yardimci.dart'; // aynı klasördeki dosyayı import ediyoruz

void main() {
  print(kare(5)); // 25
  print(kup(3));  // 27

  print(_dahiliYardimci(5)); // ❌ HATA! private, başka dosyadan erişilemez
}

import 'matematik_yardimci.dart';, bir dosyanın public (alt çizgisiz) tüm üyelerini (fonksiyonlar, sınıflar, değişkenler) mevcut dosyaya "getirir." Bölüm 6'da öğrendiğimiz _ kuralı burada devreye giriyor — _dahiliYardimci, sadece matematik_yardimci.dart dosyasının kendi içinde kullanılabilir, main.dart'a import edilmez.

package: Prefix'i ile Import

Aynı proje içinde, lib/ klasörünün kökünden import etmek için package: sözdizimi kullanılır:

dart
import 'package:benim_projem/matematik_yardimci.dart';

Bu, bir üstteki basit import 'matematik_yardimci.dart'; (relative/göreli import) ile aynı dosyayı işaret eder, ama package: sözdizimi, dosyanın projenin neresinde olursa olsun, her zaman aynı şekilde import edilmesini sağlar (Flutter projelerinde, farklı klasörlerdeki dosyalar arasında import yaparken bunu sıkça göreceksin).

Ne zaman hangisi kullanılır?

  • Relative import ('matematik_yardimci.dart' veya '../utils/matematik.dart'): Aynı proje içinde, birbirine yakın dosyalar arasında.
  • package: import: Dış bir pakete (Bölüm 12 Konu 53'te öğrendiğimiz pub.dev paketleri) erişirken zorunludur, kendi projen içinde de kullanılabilir ama genelde relative import tercih edilir.

Dış Bir Paketi Import Etme

dart
import 'package:http/http.dart' as http;

void main() async {
  // http paketinin fonksiyonlarını 'http.' öneki ile kullanabiliriz
}

as http, import edilen paketin tüm üyelerine http. öneki ile erişmeni sağlar — bu, isim çakışmalarını önlemek için kullanılır. Eğer iki farklı paket, aynı isimde bir fonksiyon/sınıf tanımlıyorsa, as ile bunları ayırt edebilirsin.

dart
import 'package:paket_a/paket_a.dart' as a;
import 'package:paket_b/paket_b.dart' as b;

void main() {
  a.birFonksiyon(); // paket_a'daki fonksiyon
  b.birFonksiyon();  // paket_b'daki, aynı isimli ama FARKLI fonksiyon
}

export — Bir Kütüphaneyi Yeniden Dışa Aktarma

dart
// lib/matematik.dart
export 'matematik_temel.dart';
export 'matematik_ileri.dart';

export, başka dosyaların içeriğini, senin dosyan üzerinden de erişilebilir hale getirir. Bu, birden fazla küçük dosyayı tek bir "giriş noktası" altında birleştirmek için kullanılır:

dart
// main.dart
import 'matematik.dart'; // hem matematik_temel.dart hem matematik_ileri.dart'ın içeriğine erişebiliyoruz!

Bu kalıp, özellikle kendi paketini yazarken (Bölüm 13'te pub.dev'e paket yayınlamayı işleyeceğiz) çok kullanışlıdır — paketini kullanan kişi, sadece tek bir dosyayı import ederek, senin içeride nasıl organize ettiğinle ilgilenmeden, tüm public API'ye erişebilir.

Sadece Belirli Üyeleri Import/Export Etme

dart
import 'matematik_yardimci.dart' show kare; // sadece 'kare' fonksiyonunu getir

void main() {
  print(kare(5)); // ✅ çalışır
  print(kup(3));  // ❌ HATA! kup import edilmedi
}
dart
import 'matematik_yardimci.dart' hide kup; // her şeyi getir, 'kup' HARİÇ

void main() {
  print(kare(5)); // ✅ çalışır
  print(kup(3));  // ❌ HATA! kup bilerek hariç tutuldu
}

show ve hide, bir import'un hangi üyeleri getireceğini kontrol etmeni sağlar — bu, büyük kütüphanelerden sadece ihtiyacın olan kısmı almak veya isim çakışmalarını önlemek için kullanışlıdır.

part / part of — Bir Dosyayı Birden Fazla Fiziksel Dosyaya Bölme

Bazen, tek bir mantıksal kütüphaneyi, okunabilirlik için birden fazla fiziksel dosyaya bölmek istersin — ama bu dosyaların hepsinin aynı kütüphanenin parçası olduğunu belirtmen gerekir. İşte bunun için part/part of kullanılır:

dart
// lib/hayvan.dart (ana dosya)
part 'hayvan_metodlari.dart';

class Hayvan {
  String isim;
  Hayvan(this.isim);
}
dart
// lib/hayvan_metodlari.dart (parça dosya)
part of 'hayvan.dart';

extension HayvanUzantisi on Hayvan {
  void selamVer() => print("Merhaba, ben ${isim}");
}

part/part of ile import arasındaki fark: import, iki ayrı kütüphane arasında bir bağlantı kurar (her biri kendi private alanına sahiptir). part/part of ise, birden fazla dosyayı tek bir kütüphane olarak birleştirir — yani hayvan.dart ve hayvan_metodlari.dart, aslında aynı private scope'u paylaşır (birindeki _ozelAlan, diğerinde de erişilebilir).

Ne zaman kullanılır? part/part of, genelde code generation (kod üretimi — Bölüm 13'te build_runner konusunda göreceğiz) ile otomatik üretilen dosyalarda veya çok büyük, tek bir mantıksal birim olan sınıfları (örneğin çok sayıda extension method içeren bir sınıf) organize etmek için kullanılır. Günlük kodlamada import/export çok daha yaygındır — part/part of'u bilmen yeterli, sık sık yazman gerekmeyebilir.

Gerçek Bir Proje Organizasyonu Örneği

metin
lib/
  models/
    kullanici.dart
    urun.dart
  services/
    api_servisi.dart
  utils/
    formatlayici.dart
  main.dart
dart
// main.dart
import 'models/kullanici.dart';
import 'models/urun.dart';
import 'services/api_servisi.dart';
import 'utils/formatlayici.dart';

Bu, gerçek Dart/Flutter projelerinde standart bir organizasyon kalıbıdır — ilgili dosyalar klasörlere gruplanır, main.dart (veya başka bir merkezi dosya) gerektiği yerlerden import eder. Bunu Flutter tutorial'ında proje yapısı konusunda çok daha detaylı göreceksin.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Her .dart dosyası, kendi başına bir kütüphanedir; _ ile başlayan üyeler o dosyaya özeldir.
  • import, başka bir dosyanın public üyelerini mevcut dosyaya getirir; relative ('dosya.dart') veya package: sözdizimiyle yapılabilir.
  • as ile import edilen bir kütüphaneye önek vererek isim çakışmalarını önleyebilirsin.
  • export, birden fazla dosyayı tek bir "giriş noktası" altında birleştirmeni sağlar.
  • show/hide, bir import'un hangi üyeleri getireceğini sınırlar.
  • part/part of, birden fazla fiziksel dosyayı tek bir kütüphane (aynı private scope) olarak birleştirir — import'tan farklı olarak ayrı kütüphaneler oluşturmaz.

📝 Ödevler

  • [ ] Kendi küçük bir yardımcı kütüphaneni (lib/matematik_yardimci.dart) yaz, içinde en az 2 public ve 1 private fonksiyon olsun, başka bir dosyadan import edip kullan.
  • [ ] Aynı isimde bir fonksiyon tanımlayan iki farklı dosya oluştur, as kullanarak ikisini de aynı dosyada, çakışmadan kullan.
  • [ ] export kullanarak, iki ayrı dosyayı tek bir "giriş dosyası" üzerinden dışa aktar, başka bir dosyadan tek bir import ile ikisine de eriş.
  • [ ] show ve hide kullanarak, aynı dosyadan farklı üyeleri seçici olarak import eden iki örnek yaz.
  • [ ] Basit bir part/part of örneği dene — bir sınıfı ana dosyada tanımla, bir extension'ı part ile ayrı bir dosyada tanımla.

Sıradaki konu: Bölüm 12 — Konu 55: Dart'ta Test Yazımı (test Paketi, Unit Test Mantığı)

54. bölüm

Bölüm 12 — Konu 55: Dart'ta Test Yazımı (`test` Paketi, Unit Test Mantığı)

Neden Test Yazmalısın?

Şimdiye kadar kodunu test etmek için genelde print() kullanıp çıktıyı elle kontrol ettik. Bu, küçük örnekler için işe yarar ama gerçek bir projede sürdürülebilir değildir — her değişiklikten sonra onlarca print() çıktısını elle kontrol etmek hem yavaş hem hataya açıktır. Unit test (birim test), bu kontrolü otomatikleştirir.

test Paketini Ekleme

Bölüm 12 Konu 53'te öğrendiğimiz gibi, bu bir dev dependency'dir (sadece geliştirme sırasında gerekir, üretim kodunda değil):

bash
dart pub add --dev test

İlk Testini Yazma

Dart projelerinde, test dosyaları geleneksel olarak test/ klasöründe, _test.dart uzantısıyla biter:

metin
lib/
  matematik.dart
test/
  matematik_test.dart

lib/matematik.dart:

dart
int topla(int a, int b) => a + b;
int kare(int x) => x * x;

test/matematik_test.dart:

dart
import 'package:test/test.dart';
import 'package:benim_projem/matematik.dart';

void main() {
  test('topla fonksiyonu iki sayıyı doğru toplamalı', () {
    expect(topla(2, 3), equals(5));
  });

  test('kare fonksiyonu doğru hesaplamalı', () {
    expect(kare(4), equals(16));
  });
}

Yapıyı parçalayalım:

  • test('açıklama', () { ... }) — bir test tanımlar. İlk parametre, testin ne test ettiğini açıklayan bir string; ikinci parametre, testin gerçek kodunu içeren bir fonksiyon.
  • expect(gercekDeger, matcher) — testin kalbi. Elde ettiğin gerçek değeri (topla(2, 3)), beklediğin değerle (equals(5)) karşılaştırır.

Testleri Çalıştırma

bash
dart test

Bu komut, test/ klasöründeki tüm test dosyalarını bulur ve çalıştırır. Çıktı, her testin geçip geçmediğini gösterir:

metin
00:01 +2: All tests passed!

Eğer bir test başarısız olursa:

dart
test('kare fonksiyonu doğru hesaplamalı', () {
  expect(kare(4), equals(17)); // bilerek YANLIŞ beklenti
});
metin
00:01 +1 -1: kare fonksiyonu doğru hesaplamalı [E]
  Expected: <17>
    Actual: <16>

Test çıktısı, tam olarak neyin beklendiğini ve gerçekte neyin döndüğünü gösterir — bu, hatayı hızlıca anlamanı sağlar.

expect() ve Matcher'lar

dart
import 'package:test/test.dart';

void main() {
  test('çeşitli matcher örnekleri', () {
    expect(5, equals(5));           // eşitlik kontrolü
    expect(5, isNot(equals(6)));    // eşit OLMAMA kontrolü
    expect(5 > 3, isTrue);          // bool kontrolü
    expect(null, isNull);           // null kontrolü
    expect([1, 2, 3], hasLength(3)); // liste uzunluğu
    expect([1, 2, 3], contains(2)); // eleman içeriyor mu
    expect(() => throw Exception(), throwsException); // hata fırlatıyor mu
  });
}

Dart'ın test paketi, birçok hazır matcher (eşleştirici) sunar — bunlar, expect()'in ikinci parametresinde kullanılan, farklı türde kontroller yapmanı sağlayan yardımcı araçlardır. equals() en yaygın kullanılanı olsa da, duruma göre isTrue, contains(), throwsException gibi daha spesifik matcher'lar kullanmak, testin niyetini daha net ifade eder.

group() — Testleri Gruplama

dart
import 'package:test/test.dart';

void main() {
  group('Matematik fonksiyonları', () {
    test('topla doğru çalışmalı', () {
      expect(topla(2, 3), equals(5));
    });

    test('kare doğru çalışmalı', () {
      expect(kare(4), equals(16));
    });
  });

  group('String fonksiyonları', () {
    test('büyük harfe çevirme çalışmalı', () {
      expect("merhaba".toUpperCase(), equals("MERHABA"));
    });
  });
}

group(), ilgili testleri mantıksal olarak bir araya toplar — bu hem test çıktısını daha okunabilir yapar hem de büyük projelerde testleri organize etmeni sağlar (Bölüm 12 Konu 54'te öğrendiğimiz dosya organizasyonuna benzer bir mantık).

setUp() ve tearDown() — Her Testten Önce/Sonra Çalışan Kod

dart
import 'package:test/test.dart';

class SepetHesaplayici {
  List<double> urunler = [];
  void ekle(double fiyat) => urunler.add(fiyat);
  double toplam() => urunler.fold(0, (t, f) => t + f);
}

void main() {
  late SepetHesaplayici sepet;

  setUp(() {
    sepet = SepetHesaplayici(); // HER testten önce çalışır, temiz bir sepet garantiler
  });

  test('boş sepetin toplamı sıfır olmalı', () {
    expect(sepet.toplam(), equals(0));
  });

  test('ürün eklenince toplam artmalı', () {
    sepet.ekle(10);
    sepet.ekle(20);
    expect(sepet.toplam(), equals(30));
  });
}

setUp(), her testten önce çalışan bir fonksiyondur — burada her test için temiz, sıfırlanmış bir SepetHesaplayici oluşturuyoruz. Bu önemli çünkü testler birbirinden bağımsız olmalıdır — bir testin, bir öncekinin bıraktığı durumdan etkilenmemesi gerekir. late kullanımını Bölüm 8'de hatırlarsan — burada sepet, setUp() içinde atanacağı için late olarak tanımlandı.

tearDown(), benzer şekilde her testten sonra çalışır — genelde temizlik işlemleri için (örneğin bir test veritabanı bağlantısını kapatmak) kullanılır.

Neden Test Yazmak Önemli? — Somut Faydalar

1. Regresyon (geri kaçma) önleme: Kodunu değiştirdiğinde, testler otomatik olarak eskiden çalışan bir şeyi bozup bozmadığını kontrol eder.

2. Dokümantasyon işlevi: İyi yazılmış testler, bir fonksiyonun nasıl kullanılması gerektiğini ve hangi durumları ele aldığını gösterir — bazen kod yorumlarından bile daha güvenilir bir "dokümantasyon" olabilir.

3. Güvenle refactor etme: Bölüm 7'de öğrendiğimiz gibi, kodun iç yapısını değiştirmek (refactoring) isteyebilirsin — testler varsa, değişiklikten sonra hiçbir şeyi bozmadığından emin olabilirsin.

Hata Durumlarını Test Etme

Bölüm 8'de öğrendiğimiz exception'ları da test edebilirsin:

dart
void yasKontrolEt(int yas) {
  if (yas < 0) throw Exception("Yaş negatif olamaz");
}

void main() {
  test('negatif yaş exception fırlatmalı', () {
    expect(() => yasKontrolEt(-5), throwsException);
  });

  test('geçerli yaş hata fırlatmamalı', () {
    expect(() => yasKontrolEt(25), returnsNormally);
  });
}

() => yasKontrolEt(-5) — dikkat et, expect()'e fonksiyonu çağırarak değil, bir closure olarak (Bölüm 5'te öğrendiğimiz kavram) veriyoruz. Bunun nedeni, test paketinin fonksiyonu kendisinin çağırıp, hatanın gerçekten fırlatılıp fırlatılmadığını kontrol edebilmesi gerekmesidir — eğer yasKontrolEt(-5) yazsaydık, hata hemen, expect() çağrılmadan önce fırlatılır ve testin kendisi çökerdi.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Unit test, kodunun doğru çalıştığını otomatik olarak doğrulamanı sağlar; print() ile elle kontrol etmenin yerini alır.
  • test('açıklama', () { ... }), bir testi tanımlar; expect(gercekDeger, matcher), testin kalbi olan karşılaştırmayı yapar.
  • group(), ilgili testleri mantıksal olarak bir araya toplar.
  • setUp()/tearDown(), her testten önce/sonra çalışan, testlerin birbirinden bağımsız kalmasını sağlayan kod bloklarıdır.
  • Hata fırlatan kodu test ederken, fonksiyonu çağırmadan, bir closure olarak expect()'e vermelisin (throwsException matcher'ı ile).
  • Testler, regresyon önleme, dokümantasyon ve güvenli refactoring için değerlidir.

📝 Ödevler

  • [ ] Basit bir fonksiyon için (örn. topla, kare) test paketiyle en az 3 unit test yaz, dart test ile çalıştır.
  • [ ] Bilerek başarısız olacak bir test yaz (yanlış bir expect beklentisiyle), hata çıktısını oku ve yorumla.
  • [ ] group() kullanarak, ilgili testleri (örn. tüm matematik fonksiyonları) bir arada grupla.
  • [ ] setUp() kullanarak, her testten önce sıfırlanan bir nesne (örn. bir sayaç veya sepet sınıfı) ile en az 2 bağımsız test yaz.
  • [ ] throwsException matcher'ını kullanarak, hata fırlatması beklenen bir fonksiyonu test et; returnsNormally ile de normal çalışan bir durumu test et.

Sıradaki konu: Bölüm 12 — Konu 56: Extension Methods

55. bölüm

Bölüm 12 — Konu 56: Extension Methods

Sorun: Var Olan Bir Sınıfa Nasıl Metod Eklersin?

Diyelim ki String sınıfına, ilk harfini büyük yapan bir metod eklemek istiyorsun. Ama Bölüm 7'de öğrendiğimiz gibi, String Dart'ın kendi kütüphanesinde tanımlı — onun kaynak koduna doğrudan erişimin yok, extends String de yapamazsın (çünkü String'in kendi iç yapısı buna izin vermez).

dart
void main() {
  String isim = "ahmet";
  print(isim.capitalize()); // ❌ Böyle bir metod yok!
}

Extension methods, tam olarak bu problemi çözmek için var: var olan herhangi bir sınıfa (kendi yazdığın veya Dart'ın kendi sınıfları), yeni metodlar "ekleyebilmeni" sağlar — sınıfın kendisini değiştirmeden.

Extension Tanımlama

dart
extension StringUzantilari on String {
  String capitalize() {
    if (isEmpty) return this;
    return this[0].toUpperCase() + substring(1);
  }
}

void main() {
  String isim = "ahmet";
  print(isim.capitalize()); // Ahmet
}

Sözdizimi: extension UzantiAdi on HedefTip { ... }

  • StringUzantilari — extension'ın adı (isteğe bağlı, ama koyman önerilir — adsız extension'lar da yazılabilir, birazdan göreceğiz).
  • on String — bu extension'ın hangi tipe uygulandığını belirtir.
  • İçindeki metodlar, sanki String sınıfının kendi metodlarıymış gibi çağrılabilir hale gelir.

Extension İçinde this Kullanımı

dart
extension StringUzantilari on String {
  String tersCevir() {
    return String.fromCharCodes(this.runes.toList().reversed);
  }
}

void main() {
  print("merhaba".tersCevir()); // abahrem
}

Extension metodu içinde this, extension'ın uygulandığı nesnenin kendisini temsil eder (burada, çağrıldığı String'i) — Bölüm 6'da öğrendiğimiz this kullanımıyla aynı mantık, sadece burada "kendi sınıfın" değil, "genişlettiğin" sınıfın bir örneğine işaret ediyor.

Kendi Sınıflarına Extension Ekleme

Extension'lar sadece Dart'ın kendi sınıfları için değil, senin yazdığın sınıflar için de kullanılabilir — bu, özellikle bir sınıfa her zaman erişimin olmadığı durumlarda (örneğin başka bir kütüphaneden gelen bir sınıf) veya sınıfın ana tanımını sade tutmak istediğinde kullanışlıdır:

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

extension UrunUzantilari on Urun {
  String get formatliFiyat => "${fiyat.toStringAsFixed(2)} TL";

  bool get indirimdeMi => fiyat < 50;
}

void main() {
  Urun urun = Urun("Kalem", 15.5);
  print(urun.formatliFiyat); // 15.50 TL
  print(urun.indirimdeMi);   // true
}

Bölüm 6'da öğrendiğimiz getter kavramını, extension içinde de kullanabildiğimizi görüyorsun — extension'lar, metodların yanında getter/setter da tanımlayabilir.

Neden Urun Sınıfının İçine Yazmıyoruz? — Ayrım Nedeni

dart
// Alternatif: doğrudan sınıfın içinde
class Urun {
  String ad;
  double fiyat;
  Urun(this.ad, this.fiyat);

  String get formatliFiyat => "${fiyat.toStringAsFixed(2)} TL"; // burada da tanımlanabilirdi
}

Bu, teknik olarak da geçerlidir — peki extension'ın avantajı ne? İki temel senaryo:

  1. Sınıfın kaynak koduna erişimin yoksa (örneğin bir paketten gelen bir sınıf, String gibi Dart'ın kendi sınıfları) — extension, tek çözümdür.
  2. Sınıfın "temel" tanımını, ona ait farklı "yeteneklerden" ayırmak istiyorsan — örneğin bir Urun sınıfının temel veri yapısı bir dosyada, "gösterim mantığı" (formatlama gibi) ayrı bir dosyada extension olarak tutulabilir. Bu, Bölüm 12 Konu 54'te öğrendiğimiz dosya organizasyonu mantığına benzer bir ayrım sağlar.

Birden Fazla Extension — Çakışma Durumu

dart
extension A on String {
  String selamla() => "A: Merhaba $this";
}

extension B on String {
  String selamla() => "B: Merhaba $this";
}

void main() {
  print("Ahmet".selamla()); // ❌ HATA! Birden fazla extension aynı metodu tanımlıyor, belirsiz
}

Eğer aynı tipte, aynı isimli metod tanımlayan iki extension aynı anda kullanılabilir durumdaysa (ikisi de import edilmişse), Dart hangisini çağıracağını bilemez ve hata verir. Bu durumda, hangi extension'ı kastettiğini açıkça belirtmen gerekir:

dart
void main() {
  print(A("Ahmet").selamla()); // A extension'ını açıkça belirt
}

Bu senaryo nadir karşına çıkar (genelde farklı paketlerden gelen extension'lar çakıştığında), ama var olduğunu bilmen faydalı.

Extension'lar Nesnenin Kendisini Değiştiremez

dart
extension SayiUzantisi on int {
  void ikiyeKatla() {
    this = this * 2; // ❌ HATA! 'this' değiştirilemez
  }
}

Extension metodları, yeni bir değer döndürebilir ama çağrıldıkları nesneyi doğrudan değiştiremez (mutate edemez) — çünkü extension'lar, aslında arka planda statik fonksiyonlar gibi çalışır (Bölüm 6'da öğrendiğimiz static kavramına benzer bir mekanizma), gerçek bir kalıtım veya nesne değişikliği söz konusu değildir:

dart
extension SayiUzantisi on int {
  int ikiyeKatla() => this * 2; // ✅ doğrusu — yeni bir değer DÖNDÜR
}

void main() {
  int sayi = 5;
  int sonuc = sayi.ikiyeKatla();
  print(sonuc); // 10
  print(sayi);  // 5 — orijinal değer değişmedi!
}

Nullable Tipler Üzerinde Extension

dart
extension NullableStringUzantisi on String? {
  bool get boşMuYaDaNull => this == null || this!.isEmpty;
}

void main() {
  String? isim1 = null;
  String? isim2 = "";
  String? isim3 = "Ahmet";

  print(isim1.boşMuYaDaNull); // true
  print(isim2.boşMuYaDaNull); // true
  print(isim3.boşMuYaDaNull); // false
}

Bölüm 2'de öğrendiğimiz null safety, extension'larla da uyumlu çalışır — on String? yazarak, extension'ı nullable bir tip üzerinde de tanımlayabilirsin. Bu, null kontrolü içeren yardımcı metodlar yazmak için kullanışlıdır (yukarıdaki örnek, ??/?.'ye ek bir kolaylık sağlıyor).

Gerçek Dünya Kullanımı — Flutter Bağlantısı

Extension'lar, Flutter geliştirmede son derece yaygındır — örneğin BuildContext (Flutter'ın temel bir sınıfı) üzerine, ekran boyutunu almak, tema renklerine kolayca erişmek gibi extension'lar yazmak çok sık karşılaşacağın bir pratiktir. Bunu Flutter tutorial'ında somut örneklerle göreceğiz; burada öğrendiğin temel mekanizma, orada doğrudan işine yarayacak.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Extension methods, var olan bir sınıfa (kendi sınıfların veya Dart'ın kendi sınıfları) yeni metod/getter/setter eklemeni sağlar, sınıfın kendisini değiştirmeden.
  • extension Ad on Tip { ... } sözdizimiyle tanımlanır; içinde this, genişletilen nesnenin kendisini temsil eder.
  • Extension'lar, nesneyi doğrudan değiştiremez — her zaman yeni bir değer döndürmelidir.
  • Aynı tipte, aynı isimli birden fazla extension çakışırsa, hangisinin kullanılacağını açıkça belirtmen gerekir.
  • Nullable tipler üzerinde de extension tanımlanabilir (on String? gibi).
  • Flutter geliştirmede, özellikle BuildContext gibi çekirdek sınıflara ek kolaylıklar eklemek için çok sık kullanılır.

📝 Ödevler

  • [ ] String sınıfına, bir cümledeki her kelimenin ilk harfini büyük yapan bir extension metodu yaz (capitalizeWords() gibi).
  • [ ] Kendi yazdığın bir sınıfa (örn. Urun), en az bir metod ve bir getter içeren bir extension ekle.
  • [ ] int sınıfına, bir sayının asal olup olmadığını kontrol eden bir extension metodu yaz.
  • [ ] Nullable bir tip üzerinde (on int? gibi) bir extension tanımla, null kontrolü içeren kullanışlı bir getter/metod ekle.
  • [ ] Extension'ın nesneyi değiştiremediğini (sadece yeni değer döndürebildiğini) kanıtlayan bir örnek yaz — önce yanlış (mutate etmeye çalışan) bir versiyon dene, hatayı gözlemle, sonra doğru (yeni değer döndüren) versiyonu yaz.

Sıradaki konu: Bölüm 12 — Konu 57: Dart'ın Derleme Modelleri (JIT vs AOT) ve Bunun Flutter'a Etkisi

56. bölüm

Bölüm 12 — Konu 57: Dart'ın Derleme Modelleri (JIT vs AOT) ve Bunun Flutter'a Etkisi

Bölüm 1 Konu 1'de, Flutter'ın Dart'ı seçmesinin nedenlerinden biri olarak "hem JIT hem AOT derleme desteği"nden bahsetmiştik. Şimdi, tüm bu tutorial boyunca dart run ile kod çalıştırdığın deneyimin ışığında, bu kavramları tam olarak anlayacağız.

Derleme (Compilation) Nedir? — Temel Kavram

Bir programlama dilinde yazdığın kod (kaynak kod), bilgisayarın doğrudan anlayabileceği bir forma (makine kodu) çevrilmelidir. Bu çevirme işlemine derleme (compilation) denir. Dart, bunu iki farklı stratejiyle yapabilir: JIT ve AOT.

JIT (Just-In-Time) Derleme

JIT, kodu çalıştırma anında, parça parça derler — "tam ihtiyaç duyulduğu anda" (just in time) derleme yapılır.

bash
dart run merhaba.dart

Bölüm 1'de her dart run çalıştırdığında, aslında JIT derleme kullanıyordun! Dart, dosyanı okur, çalıştığı anda gerekli kısımları makine koduna çevirir ve hemen çalıştırır.

JIT'in avantajları:

  • Hızlı başlangıç ve yeniden derleme — kod her değiştiğinde, tüm programı baştan derlemek gerekmez, sadece değişen kısımlar hızlıca derlenir.
  • Hot reload'ın temelini oluşturur — Bölüm 1'de gördüğümüz hot reload, tam olarak bu JIT derlemenin hızından faydalanır: kod değiştiğinde, çalışan uygulamanın belleğe zaten yüklenmiş halini güncelleyip, saniyeler içinde sonucu görebilirsin.

JIT'in dezavantajları:

  • Çalışma zamanı performansı daha düşüktür — çünkü derleme, programın çalışması sırasında ek bir yük getirir (kod, çalışırken derlenmeye devam eder).
  • Uygulama boyutu daha büyüktür — çünkü derleyicinin kendisi de, çalışan uygulamayla birlikte taşınmalıdır.

AOT (Ahead-Of-Time) Derleme

AOT, kodu çalıştırılmadan önce, tamamen makine koduna çevirir — "önceden" (ahead of time) derleme yapılır.

bash
dart compile exe merhaba.dart

Bu komut, merhaba.dart dosyasını, doğrudan çalıştırılabilir bir native makine kodu dosyasına dönüştürür — artık Dart runtime'ına veya derleyicisine ihtiyaç duymadan, doğrudan işletim sistemi tarafından çalıştırılabilir.

AOT'nin avantajları:

  • Çok daha hızlı çalışma zamanı performansı — çünkü program çalışırken hiç derleme yükü yoktur, doğrudan native kod çalışır.
  • Daha küçük, daha öngörülebilir başlangıç süresi — uygulama açılır açılmaz, derlemeyi beklemeden çalışmaya başlar.

AOT'nin dezavantajları:

  • Yeniden derleme yavaştır — kodda küçük bir değişiklik bile, tüm programın yeniden derlenmesini gerektirir (bu, hot reload'ı imkansız kılar).
  • Bu yüzden AOT, geliştirme sürecinde değil, üretime hazırlarken kullanılır.

Karşılaştırma Tablosu

JIT AOT
Ne zaman derlenir? Çalışma anında Çalıştırılmadan önce
Yeniden derleme hızı Çok hızlı (hot reload mümkün) Yavaş (tüm program yeniden derlenir)
Çalışma zamanı performansı Daha düşük Çok daha yüksek
Uygulama boyutu Daha büyük Daha küçük
Kullanım alanı Geliştirme (development) Üretim (production/release)

Flutter'da Bu İkilik Nasıl Kullanılıyor?

Bölüm 1 Konu 1'de bahsettiğimiz gibi, Flutter'ın Dart'ı seçmesinin en büyük stratejik sebeplerinden biri tam olarak budur — Flutter, geliştirme ve üretim aşamalarında farklı derleme modlarını kullanır:

bash
# Geliştirme sırasında (JIT kullanılır, hot reload aktif)
flutter run

# Üretime hazırlarken (AOT kullanılır, maksimum performans)
flutter build apk
flutter build ios

Geliştirme sırasında (flutter run): Dart, JIT derleme kullanır. Bu sayede, bir widget'ın rengini değiştirdiğinde, uygulamayı baştan başlatmadan, saniyeler içinde değişikliği görebilirsin — bu, Bölüm 1'de deneyimlediğin hot reload'ın teknik temelidir.

Üretime hazırlarken (flutter build): Flutter, AOT derleme kullanır. Kullanıcının telefonuna kurulan uygulama, native ARM makine koduna önceden derlenmiştir — bu, uygulamanın hızlı açılmasını ve akıcı çalışmasını sağlar, çünkü kullanıcının cihazında hiçbir derleme yükü yoktur.

Neden Bu Kombinasyon Bu Kadar Değerli?

Bu, Bölüm 1'de "Flutter'ın Dart'ı seçme sebeplerinden biri" olarak bahsettiğimiz konunun tam açıklamasıdır: Diğer birçok teknoloji, ya hızlı geliştirme deneyimi (JavaScript gibi, hep yorumlanan/JIT diller) ya da yüksek performans (C++ gibi, hep AOT derlenen diller) sunar — genelde ikisi bir arada olmaz. Dart, aynı kod tabanını, geliştirme sırasında JIT'in hızıyla, üretimde AOT'nin performansıyla çalıştırabilme esnekliğini sağlıyor. Bu, geliştiricinin hem hızlı iterasyon yapabilmesini hem de kullanıcının yüksek performanslı bir uygulama almasını aynı anda mümkün kılıyor.

dart compile — Diğer Çıktı Formatları

bash
dart compile exe merhaba.dart      # native çalıştırılabilir dosya
dart compile js merhaba.dart       # JavaScript'e derleme (web için)
dart compile aot-snapshot merhaba.dart  # AOT snapshot (Flutter'ın kullandığı format)

Dart, AOT derlemeyi farklı hedef platformlar için de yapabilir — bu, Bölüm 7'de (Flutter müfredatında, "Flutter Web ve Desktop desteği" konusunda) göreceğimiz çoklu platform desteğinin derleme tarafındaki temelini oluşturuyor.

Kısa Bir Özet — Zihinsel Model

JIT'i şöyle düşün: Bir tercüman, konuştuğun her cümleyi anında çeviriyor — hızlı başlarsın ama her cümle biraz gecikmeli çıkar.

AOT'yi şöyle düşün: Bir kitabı, konuşmadan önce, baştan sona tamamen çevirmişsin — hazırlık biraz uzun sürer, ama okurken hiç gecikme yaşamazsın.

Flutter, geliştirme sırasında "tercüman" modelini (hızlı iterasyon), üretimde "önceden çevrilmiş kitap" modelini (maksimum performans) kullanıyor — ve Dart, bu iki modeli de aynı kod tabanıyla desteklemesiyle bu esnekliği mümkün kılıyor.


🎯 Bu Dersten Çıkarılması Gerekenler

  • JIT, kodu çalışma anında derler — hızlı yeniden derleme sağlar (hot reload'ın temeli), ama çalışma zamanı performansı daha düşüktür.
  • AOT, kodu çalıştırılmadan önce tamamen derler — çok daha yüksek çalışma zamanı performansı sağlar, ama yeniden derleme yavaştır.
  • Flutter, geliştirme sırasında (flutter run) JIT, üretime hazırlarken (flutter build) AOT kullanır.
  • Bu ikili derleme modeli, Dart'ın Flutter için seçilmesinin temel stratejik sebeplerinden biridir — hem hızlı geliştirme deneyimi hem yüksek üretim performansı sağlar.
  • dart compile, farklı hedef formatlara (native exe, JavaScript, AOT snapshot) derleme yapabilir.

📝 Ödevler

  • [ ] dart run dosya.dart ile bir programı JIT derlemesiyle çalıştır, çalışma süresini gözlemle (kabaca).
  • [ ] dart compile exe dosya.dart ile aynı programı AOT derle, oluşan çalıştırılabilir dosyayı doğrudan çalıştır (./dosya veya dosya.exe), JIT ile aradaki başlangıç hızı farkını gözlemle.
  • [ ] Kendi cümlelerinle, "neden Flutter geliştirme sırasında JIT, üretimde AOT kullanıyor" sorusunu, bu dersten öğrendiklerinle açıkla.
  • [ ] Hot reload'ın, JIT derlemenin hangi özelliğinden (hızlı, kısmi yeniden derleme) faydalandığını yorumla.
  • [ ] JIT ile AOT arasındaki farkı, "tercüman vs önceden çevrilmiş kitap" benzetmesini kullanarak kendi örneğinle (farklı bir benzetmeyle de olabilir) açıkla.

Sıradaki konu: Bölüm 12 — Konu 58: İzole (Isolate) Kavramı — Dart'ta Çoklu İş Parçacığı Mantığı

57. bölüm

Bölüm 13 — Konu 59: Dart 3 Pattern Matching — Records, Destructuring, Sealed Classes, Exhaustive Switch

Bölüm 13'e — gerçek uzmanlık bölümüne — hoş geldin. Bu, Dart 3 ile gelen, dilin en modern ve güçlü özelliklerinden biri: pattern matching (örüntü eşleştirme).

Records (Kayıtlar) — Anonim, Yapılandırılmış Veri

Bölüm 6'da sınıflar öğrendik — birden fazla değeri bir arada tutmak için bir class tanımlıyorduk. Ama bazen, sadece geçici olarak birkaç değeri bir arada döndürmek istersin, tam bir class yazmak "fazla" gelir. İşte record, bunun için var:

dart
void main() {
  var kisi = (isim: "Ahmet", yas: 25); // named field'lı bir record
  print(kisi.isim); // Ahmet
  print(kisi.yas);  // 25
  print(kisi);       // (isim: Ahmet, yas: 25)
}

Positional (isimsiz) record da mümkündür:

dart
void main() {
  var koordinat = (10, 20); // positional record
  print(koordinat.$1); // 10 — ilk eleman
  print(koordinat.$2); // 20 — ikinci eleman
}

Bir Fonksiyondan Birden Fazla Değer Döndürme

Bölüm 5'te fonksiyonların tek bir değer döndürdüğünü öğrenmiştik. Eğer birden fazla değer döndürmek istiyorsan, önceden ya bir class yazman ya da bir Map/List kullanman gerekiyordu. Artık record ile doğrudan birden fazla değer döndürebilirsin:

dart
(double, double) minMaxBul(List<double> sayilar) {
  double min = sayilar[0];
  double max = sayilar[0];
  for (var sayi in sayilar) {
    if (sayi < min) min = sayi;
    if (sayi > max) max = sayi;
  }
  return (min, max); // record döndürüyoruz
}

void main() {
  var sonuc = minMaxBul([5, 2, 8, 1, 9]);
  print("Min: ${sonuc.$1}, Max: ${sonuc.$2}"); // Min: 1.0, Max: 9.0
}

Named field'larla daha okunabilir:

dart
({double min, double max}) minMaxBulV2(List<double> sayilar) {
  double min = sayilar[0];
  double max = sayilar[0];
  for (var sayi in sayilar) {
    if (sayi < min) min = sayi;
    if (sayi > max) max = sayi;
  }
  return (min: min, max: max);
}

void main() {
  var sonuc = minMaxBulV2([5, 2, 8, 1, 9]);
  print("Min: ${sonuc.min}, Max: ${sonuc.max}"); // Min: 1.0, Max: 9.0
}

Destructuring — Record'u Ayrı Değişkenlere Ayırma

Bölüm 4'te collection'larla çalışırken hep "önce bütünü al, sonra parçalarına eriş" yaptık. Destructuring, bir record'u (veya başka yapıları) tek bir satırda, doğrudan ayrı değişkenlere ayırmanı sağlar:

dart
(double, double) minMaxBul(List<double> sayilar) {
  // ... (yukarıdaki gibi)
  return (1.0, 9.0);
}

void main() {
  var (min, max) = minMaxBul([5, 2, 8, 1, 9]); // DESTRUCTURING
  print("Min: $min, Max: $max"); // Min: 1.0, Max: 9.0
}

var (min, max) = ... satırı, record'un $1 ve $2 elemanlarını doğrudan min ve max adında iki ayrı değişkene atıyor — .min/.max veya .$1/.$2 yazmana gerek kalmıyor. Bu, Bölüm 6'daki this.x constructor kısayoluna benzer bir "sözdizimsel şeker" (syntactic sugar) — kodu daha kısa ve okunabilir kılıyor.

Named record'larda destructuring:

dart
void main() {
  var kisi = (isim: "Ahmet", yas: 25);
  var (isim: i, yas: y) = kisi;
  print("$i, $y"); // Ahmet, 25
}

Listelerde de destructuring çalışır:

dart
void main() {
  List<int> sayilar = [1, 2, 3];
  var [birinci, ikinci, ucuncu] = sayilar;
  print("$birinci, $ikinci, $ucuncu"); // 1, 2, 3
}

Sealed Classes — "Kapalı" Kalıtım Hiyerarşisi

Bölüm 7'de abstract class öğrenmiştik — soyut sınıflar, alt sınıfların belirli metodları implemente etmesini zorunlu kılıyordu. sealed class, bunun bir adım ötesine geçer: hangi sınıfların bu sınıftan türeyebileceğini de sınırlar — sadece aynı dosyada tanımlanan sınıflar türeyebilir.

dart
sealed class Sekil {}

class Daire extends Sekil {
  final double yaricap;
  Daire(this.yaricap);
}

class Kare extends Sekil {
  final double kenar;
  Kare(this.kenar);
}

class Ucgen extends Sekil {
  final double taban, yukseklik;
  Ucgen(this.taban, this.yukseklik);
}

Bu üç sınıf (Daire, Kare, Ucgen), Sekil'in bilinen, sabit tüm alt tipleridir — başka bir dosyadan gelip Sekil'i extend eden dördüncü bir sınıf olamaz (Dart bunu engeller). Bu, önemli bir garanti sağlıyor: Dart derleyicisi, Sekil'in tam olarak kaç ve hangi alt tipi olduğunu bilir.

Sealed Class + Exhaustive Switch — Asıl Güç Burada

Bölüm 3'te ve Bölüm 7'de enum'larla exhaustiveness kontrolünü görmüştük. Sealed class'lar, bunu enum'un ötesine, tam class hiyerarşilerine taşır:

dart
double alanHesapla(Sekil sekil) {
  return switch (sekil) {
    Daire(:var yaricap) => 3.14159 * yaricap * yaricap,
    Kare(:var kenar) => kenar * kenar,
    Ucgen(:var taban, :var yukseklik) => 0.5 * taban * yukseklik,
  };
}

void main() {
  print(alanHesapla(Daire(5)));      // 78.53975
  print(alanHesapla(Kare(4)));       // 16.0
  print(alanHesapla(Ucgen(6, 8)));   // 24.0
}

default (_) yazmadık ve Dart buna izin verdi — çünkü Sekil, sealed olduğu için, Dart kesin olarak bilir ki sadece Daire, Kare, Ucgen olabilir. Eğer birisi ileride Sekil'e dördüncü bir alt sınıf (örneğin Besgen) eklerse, ama bu switch'i güncellemeyi unutursa, Dart derleyicisi anında hata verir: "bu switch artık eksik (non-exhaustive)."

Bu, Bölüm 7'de öğrendiğimiz abstract class'ın sağladığı garantiden çok daha güçlüdür — abstract class, sadece "her alt sınıf şu metodu implemente etmeli" der; sealed class + switch, "kod tabanının her yerinde, bu tipin tüm olasılıkları ele alınmalı" garantisini verir.

Daire(:var yaricap) — Object Pattern (Nesne Örüntüsü)

Yukarıdaki switch örneğinde gördüğün Daire(:var yaricap) sözdizimi, bir object pattern'dir — "eğer bu değer bir Daire ise, onun yaricap alanını doğrudan yaricap adında bir değişkene ata" anlamına gelir. Bu, is operatörü (Bölüm 3) ile tip kontrolü yapıp sonra .yaricap ile erişmenin birleştirilmiş, kısa halidir:

dart
// Object pattern OLMADAN, klasik yöntem
double alanHesaplaEski(Sekil sekil) {
  if (sekil is Daire) {
    double yaricap = sekil.yaricap;
    return 3.14159 * yaricap * yaricap;
  } else if (sekil is Kare) {
    double kenar = sekil.kenar;
    return kenar * kenar;
  }
  // ...
  return 0;
}

Pattern matching versiyonu, bu tip kontrolü + destructuring işlemini tek bir satırda, çok daha okunabilir şekilde birleştiriyor.

switch İçinde Guard (when) — Ek Koşul

dart
String sekilYorumu(Sekil sekil) {
  return switch (sekil) {
    Daire(:var yaricap) when yaricap > 10 => "Büyük bir daire",
    Daire() => "Küçük bir daire",
    Kare() => "Bir kare",
    Ucgen() => "Bir üçgen",
  };
}

when, bir pattern'e ek bir koşul eklemeni sağlar — "bu bir Daire ise VE yarıçapı 10'dan büyükse" gibi daha spesifik durumları ayırt etmeni sağlıyor.

Neden Bu Kadar Önemli? — Gerçek Dünya Kullanımı

Sealed class + pattern matching, özellikle "durum" (state) modellemede çok güçlüdür — örneğin bir API çağrısının sonucunu modellemek için:

dart
sealed class ApiSonucu<T> {}

class Basarili<T> extends ApiSonucu<T> {
  final T veri;
  Basarili(this.veri);
}

class Basarisiz<T> extends ApiSonucu<T> {
  final String hataMesaji;
  Basarisiz(this.hataMesaji);
}

class Yukleniyor<T> extends ApiSonucu<T> {}

String sonucGoster(ApiSonucu<String> sonuc) {
  return switch (sonuc) {
    Basarili(:var veri) => "Veri: $veri",
    Basarisiz(:var hataMesaji) => "Hata: $hataMesaji",
    Yukleniyor() => "Yükleniyor...",
  };
}

Bu kalıp, Flutter'da state management (Bölüm 6, Flutter müfredatında) yaparken son derece yaygın hale geldi — Riverpod gibi modern state management çözümleri, bu tarz sealed class + pattern matching yapılarını yoğun şekilde kullanıyor. Bu dersten öğrendiğin temel, Flutter'a geçtiğinde doğrudan işine yarayacak.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Record'lar, birden fazla değeri geçici olarak bir arada tutan, hafif ve yapılandırılmış veri türleridir ((a, b) veya (isim: a, yas: b)).
  • Destructuring, bir record'u (veya liste/map'i) tek satırda ayrı değişkenlere ayırmayı sağlar (var (a, b) = ...).
  • sealed class, bir sınıfın alt tiplerini aynı dosyayla sınırlar — bu, Dart'ın tüm olası alt tipleri bilmesini sağlar.
  • Sealed class + switch expression, default olmadan tam kapsayıcı (exhaustive) kontrol sağlar; yeni bir alt tip eklenip switch güncellenmezse, derleyici hata verir.
  • Object pattern (Daire(:var yaricap)), tip kontrolü ve destructuring'i tek adımda birleştirir.
  • when guard'ı, bir pattern'e ek koşul ekler.

📝 Ödevler

  • [ ] Positional ve named iki farklı record oluştur, her ikisinin elemanlarına farklı yollarla eriş.
  • [ ] Birden fazla değer döndüren bir fonksiyon yaz (örn. bir listenin ortalamasını ve medyanını döndüren), destructuring ile sonuçları ayrı değişkenlere ata.
  • [ ] Sealed class ile bir Sekil hiyerarşisi tanımla (en az 3 alt sınıf), exhaustive switch expression ile her şeklin çevresini hesapla.
  • [ ] Sealed class'a dördüncü bir alt sınıf ekle ama switch'i güncelleme, derleyicinin seni nasıl uyardığını gözlemle.
  • [ ] when guard'ı kullanarak, bir pattern'e ek bir koşul ekleyen bir örnek yaz.

Sıradaki konu: Bölüm 13 — Konu 60: Never Tipi, covariant ve Generic Variance Detayları

58. bölüm

Bölüm 13 — Konu 60: `Never` Tipi, `covariant` ve Generic Variance Detayları

Bölüm 9 Konu 44'te kovaryansı kısaca görmüş ve "bunu Bölüm 13'te derinlemesine işleyeceğiz" demiştik. Şimdi o sözü tutuyoruz — hem Never tipini hem de variance'ın tam mekaniğini işleyeceğiz.

Never Tipi — "Bu Fonksiyon Asla Normal Şekilde Bitmez"

Bölüm 2'de Dart'ın tip hiyerarşisini görmüştük — her şey Object?'ten türer. Never, bu hiyerarşinin tam tersi uçta, en özel (en "alt") tiptir — hiçbir değerin sahip olamayacağı bir tiptir.

dart
Never hataFirlat(String mesaj) {
  throw Exception(mesaj);
}

void main() {
  int x = 5;
  if (x < 0) {
    hataFirlat("x negatif olamaz"); // fonksiyon buradan ASLA geri dönmez
  }
  print("x pozitif: $x"); // Dart, bu satırın güvenle çalışacağını BİLİR
}

Never dönüş tipi, "bu fonksiyon her zaman bir hata fırlatır (veya sonsuz döngüye girer), asla normal şekilde geri dönmez" demektir. Bu, sadece bir dokümantasyon notu değil — Dart'ın akış analizini (flow analysis) etkiler:

dart
String durumBelirle(int? deger) {
  if (deger == null) {
    hataFirlat("Değer null olamaz");
    // Dart burada BİLİR ki bu satırdan sonrası hiç çalışmaz
  }
  return "Değer: ${deger.toString()}"; // deger burada NON-NULLABLE olarak biliniyor!
}

Normalde, deger nullable (int?) olduğu için deger.toString() çağırmak için deger! veya deger?.toString() ?? "..." gibi bir null kontrolüne ihtiyacın olurdu (Bölüm 2'yi hatırla). Ama hataFirlat'ın dönüş tipi Never olduğu için, Dart "bu satırdan sonra kesinlikle deger null değil, çünkü null olsaydı zaten hataFirlat() çalışıp fonksiyon bitmiş olurdu" çıkarımını yapabiliyor. Bu, Bölüm 2'de öğrendiğimiz type promotion (tip daraltma) kavramının, Never tipi sayesinde daha da güçlü hale gelmiş halidir.

Never ile void Arasındaki Fark

dart
void birSeyYap() {
  print("Yapıldı");
  // fonksiyon normal şekilde BİTER (bir değer döndürmese de)
}

Never sonsuzDongu() {
  while (true) {
    // asla bitmez
  }
}

void, "bu fonksiyon bir değer döndürmez ama normal şekilde biter" demektir. Never, "bu fonksiyon hiçbir zaman normal şekilde bitmez" demektir (ya hata fırlatır ya da sonsuza kadar çalışır). Bu ince ama önemli bir farktır — void dönen bir fonksiyonun ardından yazılan kod her zaman çalışır, Never dönen bir fonksiyonun ardından yazılan kod asla çalışmaz (Dart bunu bilir).

Kovaryans — Bölüm 9'daki Sözü Tutmak

Bölüm 9 Konu 44'te şunu görmüştük:

dart
void main() {
  List<int> tamSayilar = [1, 2, 3];
  List<num> sayilar = tamSayilar; // ✅ çalışır

  sayilar.add(3.14); // ❌ RUNTIME HATASI
}

Şimdi bunun tam olarak neden böyle çalıştığını açıklayalım. List<int>'in List<num>'a atanabilmesine kovaryans (covariance) denir. Dart'ın generic koleksiyonları, varsayılan olarak kovaryanttır — yani int, num'ın alt tipiyse, List<int> de List<num>'ın "alt tipi" gibi davranır.

Bu neden riskli? Çünkü List<num> tipindeki bir değişkenin, gerçekte List<int>'i işaret ettiğini derleme zamanında bilemezsin. sayilar.add(3.14) yazdığında, Dart derleme zamanında "bu geçerli, çünkü 3.14 bir num'dır" der — ama çalışma zamanında, altta yatan gerçek liste hâlâ List<int> olduğu için, bir double eklemeye çalışmak hata verir. Buna "kovaryansın güvensizliği" (unsoundness of covariance) denir — teorik olarak tip sistemi bunu tam olarak engelleyemez, bu yüzden Dart bunu çalışma zamanı kontrolüyle yakalar.

covariant Anahtar Kelimesi

Bölüm 7'de metod override etmeyi öğrenmiştik — override edilen bir metodun parametre tipleri, üst sınıfla uyumlu olmalı demiştik. Bazen, bir alt sınıfta, override edilen bir parametreyi daha spesifik bir tipe daraltmak istersin — bu normalde tip güvenliği açısından tehlikelidir, ama bazı durumlarda mantıklıdır. covariant, bunu bilerek ve açıkça yapmanı sağlar:

dart
class Hayvan {
  void beslenirken(Hayvan digerHayvan) {
    print("Hayvanlar besleniyor");
  }
}

class Kedi extends Hayvan {
  @override
  void beslenirken(covariant Kedi digerHayvan) { // parametre tipini DARALTTIK
    print("Kediler mama yiyor");
  }
}

void main() {
  Kedi kedi1 = Kedi();
  Kedi kedi2 = Kedi();
  kedi1.beslenirken(kedi2); // ✅ çalışır
}

covariant olmadan, Kedi.beslenirken'in parametresini Hayvan yerine Kedi yapmak derleme hatası verirdi (çünkü Bölüm 7'de öğrendiğimiz "override edilen metodun imzası üst sınıfla uyumlu olmalı" kuralını ihlal eder). covariant anahtar kelimesi, Dart'a "bu daralmayı bilerek yapıyorum, riski kabul ediyorum" demenin yoludur — Dart, bu durumda çalışma zamanında bir tip kontrolü ekler (tıpkı List<num>/List<int> örneğinde olduğu gibi), yanlış bir tip geçilirse runtime'da hata verir.

dart
void main() {
  Hayvan hayvan = Kedi();
  Hayvan digerHayvan = Hayvan(); // Kedi DEĞİL, sade bir Hayvan

  hayvan.beslenirken(digerHayvan); // ❌ RUNTIME HATASI! covariant kontrolü devreye girer
}

Ne Zaman covariant Kullanılır?

covariant, nadiren kullanılan, ileri bir özelliktir. En yaygın kullanım alanı, Flutter'ın kendi iç kod tabanında (örneğin bazı RenderObject metodlarında) görülür — kendi günlük kodunda muhtemelen çok az kullanacaksın, ama Flutter'ın (veya başka bir kütüphanenin) kaynak kodunu okurken bu anahtar kelimeyle karşılaştığında, ne anlama geldiğini bilmen önemlidir.

Kovaryans, Kontravaryans, Invaryans — Kısa Bir Kavramsal Harita

Bu terimleri sadece duyman için, çok kısa bir özet (derinlemesine tip teorisi bu tutorial'ın kapsamı dışında):

  • Kovaryans: List<int> → List<num> yönünde "genişleme" kabul edilir (Dart'ın koleksiyonlarının varsayılan davranışı).
  • Kontravaryans: Fonksiyon parametrelerinde, ters yönde bir uyumluluk kabul edilebilir (örneğin void Function(num), void Function(int)'in yerine geçebilir) — bu, fonksiyon tipleriyle ilgili ileri bir konudur.
  • Invaryans: Hiçbir yönde otomatik uyumluluk kabul edilmez — tipin tam olarak eşleşmesi gerekir.

Dart, generic koleksiyonlarda kovaryansı tercih eder (kullanım kolaylığı için), ama bunun çalışma zamanı güvenlik kontrolleriyle desteklenmesi gerektiğini bu derste gördün.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Never, bir fonksiyonun asla normal şekilde bitmediğini (her zaman hata fırlattığını veya sonsuza kadar çalıştığını) belirtir; bu, Dart'ın akış analizini ve type promotion'ı güçlendirir.
  • void, fonksiyonun normal bittiğini ama değer döndürmediğini; Never, fonksiyonun hiç bitmediğini belirtir.
  • Dart'ın generic koleksiyonları (List, Map gibi) kovaryanttır — List<int>, List<num>'a atanabilir, ama bu çalışma zamanı hatalarına yol açabilir.
  • covariant, bir override edilen metodun parametresini bilerek daha spesifik bir tipe daraltmanı sağlar; Dart bunu çalışma zamanı kontrolüyle güvenli hale getirir.
  • Bu özellikler nadiren günlük kodda kullanılır, ama Flutter'ın iç kod tabanını ve ileri seviye tip sistemi tartışmalarını anlamak için değerlidir.

📝 Ödevler

  • [ ] Never dönüş tipli bir hata fırlatma fonksiyonu yaz, bunu bir null kontrolünde kullanarak type promotion'dan faydalan (fonksiyondan sonra nullable bir değişkenin non-nullable olarak davranmasını sağla).
  • [ ] List<int>'i List<num>'a atayıp, .add() ile bir double eklemeyi dene, runtime hatasını gözlemle ve bu derste öğrendiğin "kovaryansın güvensizliği" kavramıyla açıkla.
  • [ ] covariant kullanarak bir override örneği yaz (örn. Hayvan/Kedi senaryosu), hem doğru hem yanlış tiple çağırarak davranışı gözlemle.
  • [ ] Kendi cümlelerinle, "Never ile void arasındaki fark nedir" sorusunu, akış analizi bağlamında açıkla.
  • [ ] Kovaryans, kontravaryans, invaryans terimlerini kendi cümlelerinle özetleyen kısa bir not yaz (derinlemesine tip teorisi gerekmez, sadece temel farkı anlaman yeterli).

Sıradaki konu: Bölüm 13 — Konu 61: Event Loop Derinlemesine — Microtask Queue vs Event Queue

59. bölüm

Bölüm 13 — Konu 61: Event Loop Derinlemesine — Microtask Queue vs Event Queue

Bölüm 10'da Future/async/await'i kullanmayı öğrenmiştik. Bu derste, bunların arka planda tam olarak nasıl çalıştığını — Dart'ın "event loop" mekanizmasını — işleyeceğiz.

Tek İş Parçacığı, Ama Nasıl "Eşzamanlı" Görünüyor?

Bölüm 12'de Dart'ın tek isolate'te (tek iş parçacığında) çalıştığını öğrenmiştik. Peki, tek bir iş parçacığı varsa, Future'lar nasıl "aynı anda" birden fazla işi yönetiyormuş gibi görünüyor? Cevap: event loop (olay döngüsü) mekanizması.

Zihinsel model: Dart'ın çalışma zamanı, sürekli dönen bir döngüdür — bu döngü, sırayla şunları kontrol eder: "yapılacak bir iş var mı? Varsa yap. Yoksa bekle." Future'lar, bu döngüye "ileride yapılacak işler" olarak eklenir.

İki Kuyruk: Microtask Queue ve Event Queue

Dart'ın event loop'u, iki ayrı kuyruk (queue) kullanır:

  1. Microtask Queue: Küçük, dahili işler için (genelde Future sonuçlarının işlenmesi).
  2. Event Queue: Daha "büyük" dış olaylar için (I/O tamamlanması, zamanlayıcılar — Timer, kullanıcı girdileri).

Kritik kural: Microtask queue, event queue'dan HER ZAMAN önce boşaltılır.

dart
void main() {
  print('1. Senkron kod');

  Future(() => print('4. Event queue (Future ile eklendi)'));

  Future.microtask(() => print('3. Microtask queue'));

  print('2. Senkron kod (devam)');
}

Çıktı:

metin
1. Senkron kod
2. Senkron kod (devam)
3. Microtask queue
4. Event queue (Future ile eklendi)

Bunu adım adım açıklayalım:

  1. Program, önce tüm senkron kodu çalıştırır (1. ve 2. satırları) — event loop, senkron kod çalışırken hiçbir şeye dokunmaz.
  2. Senkron kod bittiğinde, event loop önce microtask queue'yu tamamen boşaltır (3.).
  3. Microtask queue tamamen boşaldıktan sonra, event queue'dan bir sonraki işi alır (4.).

await Aslında Ne Yapıyor?

Bölüm 10'da await'in "Future'ı bekler" dediğimizi hatırlarsan, şimdi bunun tam mekaniğini görelim:

dart
void main() async {
  print('1');
  await Future(() => print('bu bir future'));
  print('3'); // bu satır, future TAMAMLANDIKTAN sonra çalışır
}

await ile karşılaşıldığında, Dart şunu yapar: fonksiyonun geri kalanını (o satırdan sonraki her şeyi), bir microtask olarak "kaydeder" ve o Future tamamlanana kadar bu fonksiyonun çalışmasını duraklatır — ama bu, programın tamamının durması anlamına gelmez! Diğer senkron kod (varsa) ve diğer bekleyen işler, bu sırada çalışmaya devam edebilir.

Bir Future Zincirinde Hata Yayılımı — Tam Mekanik

Bölüm 8'de try/catch'i, Bölüm 10'da bunun asenkron kodla birlikte kullanımını öğrenmiştik. Şimdi bir hatanın, bir Future zincirinde tam olarak nasıl "yayıldığını" görelim:

dart
Future<int> adim1() async {
  print("Adım 1 çalışıyor");
  throw Exception("Adım 1'de hata!");
}

Future<int> adim2() async {
  print("Adım 2 çalışıyor"); // Bu satır HİÇ çalışmaz
  return 42;
}

void main() async {
  try {
    int sonuc1 = await adim1(); // hata burada fırlatılır
    int sonuc2 = await adim2(); // BU SATIRA HİÇ ULAŞILMAZ
    print("Sonuç: $sonuc2");
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Çıktı:

metin
Adım 1 çalışıyor
Hata yakalandı: Exception: Adım 1'de hata!

Mekanik olarak ne oluyor? adim1() içindeki throw, o Future'ı "hata durumunda tamamlanmış" (completed with error) olarak işaretler. await adim1() satırı, bu hatayı yakalar ve o anda fırlatır — tıpkı senkron bir throw gibi davranır. Bu, try/catch bloğunun onu doğal olarak yakalamasını sağlar. adim2()'ye hiç ulaşılmaz çünkü Dart, await satırında hata görür görmez, o try bloğunun geri kalanını atlayıp doğrudan catch'e geçer — tıpkı Bölüm 8'de öğrendiğimiz senkron throw davranışı gibi.

Yakalanmayan Bir Hata — Ne Olur?

dart
Future<int> riskliIslem() async {
  throw Exception("Yakalanmayan hata");
}

void main() async {
  int sonuc = await riskliIslem(); // try/catch YOK!
  print(sonuc); // bu satıra hiç ulaşılmaz
}

Bu durumda, hata yakalanmadan üst katmanlara "yayılmaya" devam eder — eğer main()'in kendisi de bunu yakalamıyorsa, program bir "Unhandled exception" hatasıyla çöker. Bu, Bölüm 8'de öğrendiğimiz "hata, en yakın uygun try/catch'e kadar yukarı doğru yayılır" prensibinin, asenkron Future zincirlerinde de birebir aynı şekilde işlediğini gösteriyor.

Future.then() Zincirinde Hata Yayılımı

Bölüm 10 Konu 46'da öğrendiğimiz .then() zincirlerinde de aynı mantık geçerlidir:

dart
void main() {
  Future(() => throw Exception("Hata!"))
      .then((veri) => print("Bu ÇALIŞMAZ: $veri"))
      .then((veri) => print("Bu da ÇALIŞMAZ"))
      .catchError((hata) => print("Yakalandı: $hata"));
}

Bir .then() zincirinde hata oluştuğunda, zincirdeki sonraki tüm .then() blokları atlanır ve kontrol doğrudan en yakın .catchError()'a (veya zincirde bir .then()'in onError parametresine) geçer — tıpkı try/catch'te olduğu gibi.

Neden Bu Mekaniği Bilmek Önemli? — Pratik Sonuçlar

1. Debugging (hata ayıklama) kolaylaşır: Bir asenkron kod parçası beklenmedik sırada çalışıyorsa (örneğin bir print'in "olması gerekenden" önce/sonra çıktığını görüyorsan), microtask/event queue mantığını bilmek, neden böyle olduğunu anlamana yardımcı olur.

2. Performans sorunlarını anlama: Çok sayıda microtask, event queue'nun (kullanıcı etkileşimleri, zamanlayıcılar gibi) gecikmesine yol açabilir — çünkü microtask queue tamamen boşalana kadar event queue'ya sıra gelmez. Bu, Flutter'da UI'ın "tepkisiz" görünmesine yol açabilecek senaryoları anlamak için önemlidir.

3. Hata yönetimi tasarımı: Bir Future zincirinde nereye try/catch veya .catchError() koyman gerektiğine karar verirken, hatanın tam olarak nasıl yayılacağını bilmek, doğru yerde yakalamanı sağlar.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Dart'ın event loop'u, senkron kodu önce çalıştırır, sonra microtask queue'yu tamamen boşaltır, sonra event queue'dan bir iş alır — bu sıra kesindir.
  • await, fonksiyonun geri kalanını bir microtask olarak zamanlar ve o Future tamamlanana kadar (programın tamamını değil, sadece o fonksiyonu) duraklatır.
  • Bir Future zincirinde (async/await veya .then ile) oluşan hata, senkron throw gibi davranır — en yakın try/catch veya .catchError()'a kadar sonraki adımları atlayarak yayılır.
  • Yakalanmayan bir asenkron hata, programın "Unhandled exception" ile çökmesine yol açar.
  • Bu mekaniği bilmek, asenkron kodun çalışma sırasını tahmin etmeni, performans sorunlarını anlamanı ve hata yönetimini doğru tasarlamanı sağlar.

📝 Ödevler

  • [ ] Future ve Future.microtask ile senkron print çağrılarını karışık sırada yazıp, çalıştırmadan önce çıktı sırasını tahmin et; sonra çalıştırıp doğrula.
  • [ ] await kullanan iki adımlı bir asenkron fonksiyonda, ilk adımda throw ile hata fırlat, ikinci adımın hiç çalışmadığını print ile kanıtla.
  • [ ] .then() zincirinde bir hata oluştur, zincirdeki sonraki .then() bloklarının atlandığını, .catchError()'ın çalıştığını göster.
  • [ ] Yakalanmayan bir asenkron hata örneği yaz (try/catch olmadan), "Unhandled exception" davranışını gözlemle.
  • [ ] Kendi cümlelerinle, "microtask queue neden her zaman event queue'dan önce boşaltılır" sorusunu, bu dersten öğrendiklerinle açıkla.

Sıradaki konu: Bölüm 13 — Konu 62: Memory Model & Performans — Garbage Collection, const Nesnelerin Bellek Avantajı

60. bölüm

Bölüm 13 — Konu 62: Memory Model & Performans — Garbage Collection, `const` Nesnelerin Bellek Avantajı

Bellek Yönetimi Neden Önemli?

Bölüm 1'de, Flutter'ın Dart'ı seçme sebeplerinden biri olarak "UI-dostu garbage collection"dan bahsetmiştik. Şimdi bu ifadenin tam olarak ne anlama geldiğini işleyeceğiz.

Bellekte Nesneler Nasıl Saklanır? — Kısa Bir Zihinsel Model

Bir program çalışırken, oluşturduğun her nesne (Bölüm 6'da öğrendiğimiz class örnekleri, listeler, string'ler) bellekte (RAM'de) bir yer kaplar. Bu bellek alanına genelde heap (yığın) denir. Bir nesne oluşturduğunda, Dart runtime'ı heap'te ona yer ayırır; nesne artık kullanılmadığında, o bellek alanının boşaltılması (serbest bırakılması) gerekir — aksi halde bellek dolar ve program çöker (buna "memory leak" — bellek sızıntısı denir).

Garbage Collection (Çöp Toplama) Nedir?

C gibi bazı dillerde, belleği elle yönetmen gerekir — bir nesneyi oluşturur, işin bitince sen onu serbest bırakırsın. Bu, hataya çok açık bir süreçtir (unutulan bir serbest bırakma, bellek sızıntısına; erken bırakılan bir bellek, çökmeye yol açabilir).

Dart (Java, Python, JavaScript gibi birçok modern dil gibi), garbage collection (GC) kullanır — bu, artık kullanılmayan nesneleri otomatik olarak tespit edip belleği geri kazanan bir mekanizmadır. Sen elle bellek yönetmezsin; Dart runtime'ı, arka planda periyodik olarak çalışan bir "çöp toplayıcı" ile bunu senin için yapar.

dart
void ornekFonksiyon() {
  List<int> gecici = [1, 2, 3, 4, 5]; // heap'te yer ayrılır
  print(gecici.length);
} // fonksiyon bitince, 'gecici' artık erişilemez -> GC tarafından temizlenmeye ADAY olur

void main() {
  ornekFonksiyon();
  // 'gecici' listesi artık hiçbir yerden erişilemiyor, GC bir noktada bu belleği geri kazanır
}

Dart'ın Generational (Nesiller Arası) Garbage Collector'ı

Dart'ın GC'si, generational (nesillere dayalı) bir stratejiyle çalışır — bu, gerçek dünya gözleminden gelen bir optimizasyondur: çoğu nesne, çok kısa ömürlüdür (bir fonksiyon içinde oluşturulup hemen kullanılıp atılır), az sayıda nesne ise uzun süre yaşar (örneğin uygulamanın ana state'i).

Bu gözleme dayanarak, Dart'ın çöp toplayıcısı belleği iki bölgeye ayırır:

  1. Young generation (genç nesil / "new space"): Yeni oluşturulan nesneler buraya konur. Bu bölge sık sık ve çok hızlı taranır — çünkü buradaki nesnelerin çoğu kısa ömürlüdür, hızlıca "çöp" haline gelir.
  2. Old generation (eski nesil / "old space"): Young generation'da birkaç tarama sürecinden hayatta kalan (hâlâ kullanılan) nesneler buraya "terfi eder." Bu bölge, daha az sıklıkla taranır çünkü buradaki nesnelerin uzun süre yaşayacağı varsayılır.

Bu neden "UI-dostu"dur? Çünkü young generation taramaları (en sık yapılan tarama türü) çok hızlıdır ve genelde milisaniyelerin altında tamamlanır — bu, Flutter'ın her saniye onlarca kez ekranı yeniden çizmesi (widget'ları yeniden oluşturması) gerektiğinde, GC'nin UI'ı fark edilir şekilde durdurmamasını sağlar. Eğer GC, her taramada tüm belleği kontrol etseydi, bu "jank" (takılma) yaratabilirdi.

const Nesnelerin Bellek Avantajı — Bölüm 2 ve Bölüm 6'ya Geri Dönüş

Bölüm 2'de const'un "derleme zamanında sabit" anlamına geldiğini öğrenmiştik. Şimdi bunun bellek üzerindeki gerçek etkisini görelim:

dart
class Nokta {
  final double x;
  final double y;
  const Nokta(this.x, this.y); // const constructor
}

void main() {
  var n1 = const Nokta(1, 2);
  var n2 = const Nokta(1, 2);

  print(identical(n1, n2)); // true — AYNI bellek adresini işaret ediyorlar!
}

identical(), iki değişkenin tam olarak aynı nesneyi (bellekte aynı adresi) işaret edip etmediğini kontrol eder. const Nokta(1, 2) iki kere yazılmasına rağmen, Dart bunları tek bir nesne olarak "birleştiriyor" (deduplication/canonicalization) — çünkü const nesneler değişmezdir (immutable), bu yüzden aynı değerlere sahip iki const nesne, güvenle aynı bellek konumunu paylaşabilir.

Karşılaştıralım — const olmadan:

dart
class Nokta {
  final double x;
  final double y;
  Nokta(this.x, this.y); // const OLMAYAN constructor
}

void main() {
  var n1 = Nokta(1, 2);
  var n2 = Nokta(1, 2);

  print(identical(n1, n2)); // false — İKİ AYRI nesne, iki ayrı bellek alanı
}

Burada, her Nokta(1, 2) çağrısı yeni bir nesne oluşturur — iki ayrı bellek alanı kullanılır, ikisi de ayrı ayrı GC tarafından takip edilmesi gerekir.

Neden Bu, Performans Açısından Önemli?

1. Daha az bellek kullanımı: Aynı const değer, kodun her yerinde tekrar tekrar kullanılıyorsa (örneğin bir renk sabiti, bir boşluk değeri), her kullanımda yeni bir nesne oluşturmak yerine, tek bir paylaşılan nesne kullanılır.

2. Daha az GC yükü: Daha az nesne oluşturulduğu için, garbage collector'ın taraması gereken nesne sayısı azalır — bu, Bölüm 13'te öğrendiğimiz young generation taramalarının daha hızlı olmasına katkıda bulunur.

3. Flutter'da doğrudan performans etkisi: Flutter'da bir widget'ı const olarak işaretlediğinde (const Text("Merhaba") gibi — bunu Flutter tutorial'ında detaylı göreceğiz), Flutter bu widget'ın hiç değişmeyeceğini bilir ve onu yeniden oluşturmaktan (rebuild) tamamen kaçınabilir. Bu, Flutter'ın performans optimizasyonlarının en temel ve en etkili yöntemlerinden biridir — ve şimdi öğrendiğin bellek modeli sayesinde, neden bu kadar etkili olduğunu anlıyorsun.

Değişmezlik (Immutability) ile Bellek Verimliliği Arasındaki İlişki

Bu derste öğrendiğin şey, aslında daha genel bir prensibin somut bir örneği: değişmez (immutable) veri yapıları, paylaşılabilir (shareable) oldukları için bellek açısından daha verimlidir. Bölüm 2'de final/const'u öğrenirken "kodun okunabilirliği ve güvenliği için" demiştik — şimdi buna performans boyutunu da ekliyoruz. Bu, Dart'ın (ve Flutter'ın) neden "mümkün olduğunca const kullan" tavsiyesini bu kadar sık verdiğinin teknik temelidir.

hashCode ve == ile İlişki — Kısa Bir Not

identical()'ın kontrol ettiği "aynı bellek adresi", Bölüm 6'da gördüğümüz == operatöründen farklıdır — ==, varsayılan olarak (override edilmediği sürece) identical() ile aynı davranır, ama bir class kendi == operatörünü override ederse (örneğin "içerik eşitse eşit say" mantığıyla), iki farklı bellek adresindeki nesne == ile eşit sayılabilir, identical() ile sayılamaz. Bu, ileri bir detay — şimdilik identical()'ın gerçek bellek adresini kontrol ettiğini, =='nin ise class'ın tanımladığı eşitlik mantığını kullandığını bilmen yeterli.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Garbage collection, artık kullanılmayan nesnelerin belleğini otomatik olarak geri kazanan bir mekanizmadır; Dart'ta elle bellek yönetimi gerekmez.
  • Dart'ın GC'si "generational"dır — kısa ömürlü nesneler (young generation) sık ve hızlı, uzun ömürlü nesneler (old generation) daha seyrek taranır; bu, UI-dostu performans sağlar.
  • const nesneler, aynı değerlere sahip olduklarında tek bir bellek konumunu paylaşır (identical() ile doğrulanabilir) — bu, daha az bellek kullanımı ve daha az GC yükü sağlar.
  • Flutter'da const widget'lar, gereksiz yeniden oluşturmadan (rebuild) tamamen kaçınılmasını sağlayarak doğrudan performans katkısı sunar.
  • Değişmezlik (immutability), paylaşılabilirlik sayesinde bellek verimliliğine katkıda bulunan genel bir prensiptir.

📝 Ödevler

  • [ ] const bir constructor'lı bir sınıf yaz, aynı değerlerle iki const nesne oluştur, identical() ile aynı bellek adresini paylaştıklarını kanıtla.
  • [ ] Aynı sınıfı const olmadan iki kere oluştur, identical() ile bu sefer farklı nesneler olduklarını göster.
  • [ ] Kendi cümlelerinle, "neden const nesneler paylaşılabilir ama normal nesneler paylaşılamaz" sorusunu, değişmezlik kavramıyla ilişkilendirerek açıkla.
  • [ ] Generational garbage collection'ın "young generation" ve "old generation" ayrımını, kendi örneğinle (örn. bir döngü içinde oluşturulan geçici değişkenler vs uygulamanın ana state'i) açıkla.
  • [ ] Kendi cümlelerinle, "Flutter'da const widget kullanmanın performans üzerindeki etkisi nedir" sorusunu, bu derste öğrendiğin bellek modeliyle bağlantı kurarak yanıtla.

Sıradaki konu: Bölüm 13 — Konu 63: Isolate'ler Arası Mesajlaşmanın Maliyeti ve compute() Fonksiyonunun İç İşleyişi

61. bölüm

Bölüm 13 — Konu 63: Isolate'ler Arası Mesajlaşmanın Maliyeti ve `compute()`'un İç İşleyişi

Bölüm 12 Konu 58'de isolate'lerin kendi bağımsız belleklerine sahip olduğunu, aralarında doğrudan bellek paylaşımı olmadığını öğrenmiştik. Bu derste, bu izolasyonun nasıl sağlandığını ve bunun maliyetini işleyeceğiz.

Isolate'ler Arasında Veri Nasıl "Gönderilir"?

Bölüm 12'de Isolate.run()'ın sonucu bir Future olarak döndürdüğünü görmüştük. Peki, ana isolate ile yeni isolate arasında veri nasıl aktarılıyor, eğer bellek paylaşımı yoksa?

Cevap: Mesaj geçişi (message passing) ile — ve bu mesajlar, "kopyalanır" (copy), "paylaşılmaz" (share).

dart
import 'dart:isolate';

List<int> agirIslem(List<int> girdi) {
  return girdi.map((x) => x * 2).toList();
}

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

  List<int> sonuc = await Isolate.run(() => agirIslem(veri));

  print(sonuc); // [2, 4, 6, 8, 10]
}

Burada veri listesi, yeni isolate'e gönderiliyor gibi görünüyor — ama gerçekte olan şu: Dart runtime'ı, veri'yi serileştirir (serialize eder), yeni isolate'e bu serileştirilmiş veriyi kopyalar, yeni isolate bu kopya üzerinde çalışır, sonucu tekrar serileştirip ana isolate'e geri kopyalar.

Bu "Kopyalama" Neden Var? — Güvenlik ile İlişkisi

Bölüm 12'de, isolate izolasyonunun race condition gibi karmaşık senkronizasyon sorunlarını mimari olarak imkansız kıldığını öğrenmiştik. Bu güvenlik, tam olarak bu kopyalama mekanizması sayesinde sağlanıyor: eğer iki isolate aynı listeyi (aynı bellek adresini) paylaşsaydı, biri listeyi değiştirirken diğeri okumaya çalışırsa, öngörülemez sonuçlar (data race) oluşabilirdi. Kopyalayarak, Dart bu riski tamamen ortadan kaldırıyor — her isolate, kendi kopyasıyla güvenle çalışır.

Kopyalamanın Maliyeti — Neden Her Şey İçin Isolate Kullanılmaz?

Bu kopyalama işlemi ücretsiz değildir — özellikle büyük veri yapıları için, serileştirme ve kopyalama zaman ve bellek maliyeti getirir:

dart
import 'dart:isolate';

void main() async {
  // KÜÇÜK bir liste - isolate kullanmak muhtemelen GEREKSIZ, kopyalama maliyeti hesaplamadan fazla olabilir
  List<int> kucukListe = [1, 2, 3];
  await Isolate.run(() => kucukListe.map((x) => x * 2).toList());

  // BÜYÜK bir liste, AĞIR bir işlem - isolate kullanmak MANTIKLI
  List<int> buyukListe = List.generate(10000000, (i) => i);
  await Isolate.run(() => buyukListe.where((x) => x % 7 == 0).length);
}

Pratik kural: Isolate kullanmanın faydalı olması için, işlemin kendisinin (hesaplama), veri kopyalama maliyetinden çok daha ağır olması gerekir. Küçük bir hesaplama için isolate oluşturmak (yeni bellek alanı ayırmak, veri kopyalamak, sonucu geri kopyalamak), aslında doğrudan ana isolate'te çalıştırmaktan daha yavaş olabilir — bu, Bölüm 12'de "çok kısa işlemler için isolate'e gerek yoktur" dediğimiz tavsiyenin tam teknik gerekçesidir.

Hangi Veri Tipleri "Gönderilebilir"?

Isolate'ler arası mesajlaşmada, her tip gönderilemez — sadece "gönderilebilir" (sendable) olarak kabul edilen tipler kopyalanabilir:

dart
import 'dart:isolate';

void main() async {
  // ✅ Gönderilebilir tipler: int, double, String, bool, List, Map, Set (basit içerikli)
  await Isolate.run(() => "Merhaba"); // ✅ çalışır
  await Isolate.run(() => [1, 2, 3]); // ✅ çalışır

  // ❌ Gönderilemeyen tipler: örneğin açık bir dosya bağlantısı, bir Function referansı (bazı durumlarda)
}

Genel bir kural: temel veri tipleri (sayılar, string'ler, bool) ve bunlardan oluşan koleksiyonlar (List, Map, Set) güvenle gönderilebilir. Karmaşık nesneler (özellikle dış kaynaklara — dosya, ağ bağlantısı gibi — referans tutan nesneler) genelde gönderilemez, çünkü bu tür kaynaklar isolate'ler arasında anlamlı şekilde kopyalanamaz.

compute() — Flutter'ın Sunduğu Kolaylık

Bölüm 12'de bahsettiğimiz gibi, Flutter, Isolate.run()'a çok benzeyen compute() fonksiyonunu sunar. İçeride aynı mekanizmayı kullanır — bir fonksiyonu ve onun girdisini yeni bir isolate'e kopyalar, orada çalıştırır, sonucu geri kopyalar.

dart
// Kavramsal örnek — gerçek Flutter kullanımını Flutter tutorial'ında göreceğiz
Future<List<int>> agirIslemFlutter(List<int> girdi) async {
  return await compute(agirIslemFonksiyonu, girdi);
}

List<int> agirIslemFonksiyonu(List<int> girdi) {
  return girdi.map((x) => x * x).toList();
}

compute()'un imzasında bile bu mekaniği görebilirsin: bir fonksiyon ve bir parametre alır (fonksiyonun kendisi değil, çağrısı değil — referansı ve girdisi ayrı ayrı) — bunun nedeni, Dart'ın bu ikisini ayrı ayrı yeni isolate'e "gönderebilmesi" gerektiğidir.

Ne Zaman Isolate/compute() Kullanmaya Değer? — Karar Rehberi

Senaryo Isolate kullan mı?
Küçük bir liste üzerinde basit bir işlem (< birkaç bin eleman) ❌ Muhtemelen gerek yok, doğrudan çalıştır
Büyük bir JSON dosyasını parse etmek (Flutter'da API cevapları) ✅ Evet, compute() kullanmaya değer
Basit bir string formatlaması ❌ Hayır, gereksiz overhead
Büyük bir resmi işlemek (filtre uygulamak, yeniden boyutlandırmak) ✅ Evet
Bir API isteği (network call) ❌ Hayır! Bu bir I/O işlemi, async/await yeterli — isolate gerekmiyor (Bölüm 12'yi hatırla)

Son madde özellikle önemli — Bölüm 12'de vurguladığımız gibi, I/O bekleme (ağ isteği, dosya okuma) ile CPU-yoğun hesaplamayı karıştırmamak gerekir. Isolate, sadece ikinciyi hızlandırır; birincisi zaten async/await ile verimli bir şekilde yönetiliyor.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Isolate'ler arası veri aktarımı, kopyalama (mesaj geçişi) ile yapılır — bellek doğrudan paylaşılmaz, bu da veri yarışlarını (race condition) mimari olarak engeller.
  • Bu kopyalama, ücretsiz değildir — büyük veriler için maliyetli olabilir, bu yüzden isolate kullanmak, işlemin kazancının bu maliyeti aşacağı durumlarda mantıklıdır.
  • Sadece "gönderilebilir" (temel tipler ve basit koleksiyonlar) veriler isolate'ler arasında aktarılabilir; karmaşık, dış kaynaklara bağlı nesneler genelde gönderilemez.
  • Flutter'ın compute() fonksiyonu, Isolate.run() ile aynı temel mekanizmayı kullanır — bir fonksiyon ve girdisini ayrı ayrı yeni isolate'e "gönderir."
  • Isolate, sadece CPU-yoğun hesaplamalar için anlamlıdır; I/O bekleme işlemleri için async/await zaten yeterlidir.

📝 Ödevler

  • [ ] Küçük bir liste üzerinde basit bir işlemi hem doğrudan hem Isolate.run() ile çalıştır, hangisinin daha "mantıklı" olduğunu (kopyalama maliyeti bağlamında) yorumla.
  • [ ] Büyük bir listede (örn. milyonlarca eleman) ağır bir filtreleme işlemini Isolate.run() ile çalıştır, ana isolate'in bloklanmadığını göster.
  • [ ] Kendi cümlelerinle, "isolate'ler arası veri neden kopyalanır, paylaşılmaz" sorusunu, race condition kavramıyla ilişkilendirerek açıkla.
  • [ ] Bir tabloda, en az 4 farklı senaryo (küçük/büyük veri, I/O/CPU işlemi) için isolate kullanmanın mantıklı olup olmadığına karar ver ve gerekçelendir.
  • [ ] Kendi cümlelerinle, "neden bir API isteği için isolate kullanmaya gerek yok ama büyük bir JSON parse etmek için compute() kullanmak mantıklı olabilir" sorusunu açıkla.

Sıradaki konu: Bölüm 13 — Konu 64: FFI (Foreign Function Interface) — C Koduna Erişim

62. bölüm

Bölüm 13 — Konu 64: FFI (Foreign Function Interface) — C Koduna Erişim

FFI Nedir ve Neden Var?

Bölüm 1'de Dart'ın "native koda derlenebildiğini" (AOT, Bölüm 12 Konu 57) öğrenmiştik. Bazen, Dart'ın kendi kütüphanelerinde olmayan, ama C dilinde yazılmış güçlü, optimize edilmiş kütüphanelere erişmen gerekebilir — örneğin görüntü işleme, kriptografi, veya donanıma yakın işlemler için onlarca yıllık, yüksek performanslı C kütüphaneleri mevcuttur. FFI (Foreign Function Interface), Dart kodundan doğrudan C fonksiyonlarını çağırmanı sağlayan bir köprüdür.

Ne Zaman FFI Gerekir?

  • Var olan, optimize edilmiş bir C/C++ kütüphanesini (örneğin bir görüntü işleme kütüphanesi, bir sıkıştırma algoritması) Dart'tan kullanmak istediğinde.
  • İşletim sisteminin native API'lerine (bazı düşük seviyeli sistem çağrıları) erişmen gerektiğinde.
  • Performansın son derece kritik olduğu, C'nin sağladığı donanım-yakını kontrolün gerektiği nadir senaryolarda.

Önemli not: Bu, çok nadir ihtiyaç duyacağın bir özelliktir — günlük Flutter geliştirmede, hatta çoğu Dart projesinde FFI'a hiç gerek duymazsın. Ama var olduğunu ve ne işe yaradığını bilmek, "uzman seviye" bir anlayış için önemli.

Basit Bir FFI Örneği — Kavramsal Bakış

dart
import 'dart:ffi';
import 'dart:io';

// C tarafındaki fonksiyonun Dart'taki "imzası"
typedef CTopla = Int32 Function(Int32 a, Int32 b);
typedef DartTopla = int Function(int a, int b);

void main() {
  // C kütüphanesini (paylaşımlı kütüphane dosyası - .so, .dll, .dylib) yükle
  final DynamicLibrary cKutuphanesi = Platform.isWindows
      ? DynamicLibrary.open('matematik.dll')
      : DynamicLibrary.open('libmatematik.so');

  // C fonksiyonuna bir Dart referansı al
  final DartTopla topla = cKutuphanesi
      .lookupFunction<CTopla, DartTopla>('topla');

  // Artık C fonksiyonunu, sıradan bir Dart fonksiyonu gibi çağırabiliriz!
  print(topla(5, 3)); // 8 (C tarafında hesaplandı)
}

Bu kod, matematik.dll/libmatematik.so adında, C dilinde derlenmiş bir kütüphanenin içindeki topla fonksiyonunu doğrudan Dart'tan çağırıyor. Kavramsal olarak neler oluyor:

  1. DynamicLibrary.open(...): İşletim sisteminin, derlenmiş bir C kütüphanesini (paylaşımlı kütüphane — shared library) belleğe yüklemesini sağlar.
  2. typedef: Bölüm 5'te öğrendiğimiz fonksiyon tiplerine benzer şekilde, C tarafındaki fonksiyonun imzasını (parametre/dönüş tipleri) Dart'a tanımlıyoruz — biri C'nin kendi tip sistemiyle (Int32 gibi), diğeri Dart'ın tip sistemiyle (int gibi).
  3. .lookupFunction<...>(...): Kütüphane içindeki, ismiyle belirtilen fonksiyonu bulur ve Dart'tan çağrılabilir bir referansa dönüştürür.

C ile Dart Arasındaki Tip Eşleştirmesi

FFI'ın en hassas kısmı, C'nin tip sistemi ile Dart'ın tip sisteminin birbirine doğru eşleştirilmesidir:

dart
// C tipleri -> Dart FFI tipleri
// int (C)      -> Int32 veya Int64
// float (C)    -> Float
// double (C)   -> Double
// char* (C)    -> Pointer<Utf8> (string'ler için özel işlem gerekir)

Bölüm 2'de Dart'ın kendi tip sisteminin (int, double gibi) sound null safety ile nasıl güvenli olduğunu öğrenmiştik — FFI kullanırken, bu güvenliğin sınırına geliyorsun: C tarafındaki tipleri yanlış eşleştirirsen, Dart bunu derleme zamanında yakalayamayabilir, ve bu, çalışma zamanında çökme veya öngörülemez davranışlara yol açabilir. Bu yüzden FFI, Dart'ın normal tip güvenliği garantilerinin dışında kalan bir alandır — dikkatli kullanılması gerekir.

Pointer — C'nin Bellek Modeline Köprü

C, Dart'ın aksine, işaretçiler (pointers) ile doğrudan bellek adreslerine erişime izin verir — Dart'ın kendi güvenli, garbage-collected bellek modelinden çok farklı bir yaklaşım. FFI, bu farkı köprülemek için Pointer<T> tipini sunar:

dart
import 'dart:ffi';

void main() {
  Pointer<Int32> pointer = calloc<Int32>(); // C tarzı bellek ayırma
  pointer.value = 42;
  print(pointer.value); // 42
  calloc.free(pointer); // ELLE bellek serbest bırakma — GC bunu YAPMAZ!
}

Kritik fark: Bölüm 13 Konu 62'de öğrendiğimiz garbage collection, sadece Dart'ın kendi nesneleri için geçerlidir. FFI ile ayrılan bellek (calloc<Int32>() gibi), C'nin bellek modeline aittir — bu belleği elle serbest bırakman (calloc.free(...)) gerekir, aksi halde bellek sızıntısı oluşur. Bu, Bölüm 13 Konu 62'de "Dart'ta elle bellek yönetimi gerekmez" dediğimiz genel kuralın istisnasıdır — FFI, seni C'nin dünyasına soktuğu için, C'nin kurallarına (elle bellek yönetimi) da uymanı gerektirir.

Gerçek Dünya Kullanımı — package:ffi ve Kod Üretimi

Pratikte, FFI kodu elle yazmak (yukarıdaki gibi) hataya açık ve zahmetlidir. Bu yüzden Dart ekosisteminde, FFI binding'lerini otomatik üretmeye yardımcı olan araçlar vardır (ffigen gibi) — bu araçlar, bir C header dosyasını (.h) okuyup, karşılık gelen Dart FFI kodunu otomatik olarak üretirler. Bu, Bölüm 12'de bahsettiğimiz build_runner / code generation ekosistemine benzer bir yaklaşımdır (bunu bir sonraki derste tam olarak işleyeceğiz).

Flutter'da FFI

Flutter uygulamaları da FFI kullanabilir — bu, özellikle platform-spesifik, yüksek performanslı işlemler gerektiğinde (örneğin bir ses işleme kütüphanesi, bir video codec) kullanılır. Ama günlük Flutter geliştirmede, çok nadir karşına çıkacak bir ihtiyaçtır — çoğu zaman, Bölüm 9'da (Flutter müfredatı) göreceğimiz Platform Channels (native Android/iOS koduna erişim için farklı bir mekanizma) daha yaygın kullanılır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • FFI, Dart kodundan doğrudan C fonksiyonlarını çağırmanı sağlayan bir köprüdür; nadir, ama var olan optimize edilmiş C kütüphanelerinden faydalanmak için kullanılır.
  • DynamicLibrary.open(), bir C kütüphanesini yükler; lookupFunction(), içindeki bir fonksiyonu Dart'tan çağrılabilir hale getirir.
  • C ve Dart'ın tip sistemleri arasında doğru eşleştirme yapılmalıdır — yanlış eşleştirme, Dart'ın normal tip güvenliği dışında kalır ve çalışma zamanı sorunlarına yol açabilir.
  • Pointer<T>, C'nin işaretçi (pointer) tabanlı bellek modeline köprü kurar; bu bellek, Dart'ın garbage collector'ı tarafından yönetilmez, elle serbest bırakılmalıdır.
  • Pratikte, FFI binding'leri genelde ffigen gibi araçlarla otomatik üretilir; elle yazmak nadirdir ve hataya açıktır.

📝 Ödevler

  • [ ] Kendi cümlelerinle, "FFI ne zaman gerekli olur, ne zaman gereksizdir" sorusunu, bu dersten öğrendiğin kriterlerle açıkla.
  • [ ] FFI ile ayrılan belleğin neden garbage collector tarafından yönetilmediğini, Bölüm 13 Konu 62'de öğrendiğin GC modeliyle karşılaştırarak açıkla.
  • [ ] typedef kullanarak, hayali bir C fonksiyonunun (örn. int carp(int a, int b)) Dart tarafındaki imza tanımını (CFonksiyon ve DartFonksiyon typedef'leri) yaz (çalıştırmana gerek yok, sadece sözdizimini pratik et).
  • [ ] Kendi cümlelerinle, "Pointer ile normal bir Dart nesnesi arasındaki temel fark nedir" sorusunu yanıtla.
  • [ ] Flutter'da FFI ile Platform Channels arasındaki farkı (ne zaman hangisinin tercih edileceğini) araştırıp kısaca özetle.

Sıradaki konu: Bölüm 13 — Konu 65: Sunucu Tarafında Dart — dart:io, shelf Paketiyle Basit Bir Backend/CLI Aracı Yazma

63. bölüm

Bölüm 13 — Konu 65: Sunucu Tarafında Dart — `dart:io`, `shelf` Paketiyle Basit Bir Backend/CLI Aracı Yazma

Bölüm 1'de "Dart, sadece Flutter'ın dili değil, sunucu tarafında da kullanılabilir" demiştik. Bu derste bu iddiayı somut olarak göreceğiz.

dart:io — Dosya Sistemi ve Ağ Erişimi

Bölüm 12 Konu 54'te dart:async'i (Stream'ler için) import ettiğimizi görmüştük. dart:io, benzer şekilde, dosya sistemi, ağ soketleri, işlem (process) yönetimi gibi, sunucu/CLI ortamına özgü işlemleri sağlayan bir kütüphanedir.

Önemli not: dart:io, Flutter Web'de kullanılamaz (tarayıcılar, dosya sistemine doğrudan erişime izin vermez) — ama Flutter mobil/masaüstü uygulamalarında ve saf Dart (sunucu/CLI) projelerinde kullanılabilir.

Basit Bir Dosya Okuma/Yazma Örneği

dart
import 'dart:io';

void main() async {
  File dosya = File('ornek.txt');

  await dosya.writeAsString('Merhaba, bu bir test dosyası!');
  print('Dosya yazıldı');

  String icerik = await dosya.readAsString();
  print('Dosya içeriği: $icerik');

  await dosya.delete();
  print('Dosya silindi');
}

Bölüm 10'da öğrendiğimiz async/await'in, burada doğal bir şekilde kullanıldığını görüyorsun — dosya işlemleri, tıpkı bir API çağrısı gibi, I/O bekleme gerektiren asenkron işlemlerdir. writeAsString(), readAsString() gibi metodlar, Future döndürür ve await ile beklenir.

Basit Bir HTTP Sunucusu — dart:io ile (Ham Yöntem)

dart
import 'dart:io';

void main() async {
  HttpServer sunucu = await HttpServer.bind('localhost', 8080);
  print('Sunucu çalışıyor: http://localhost:8080');

  await for (HttpRequest istek in sunucu) {
    istek.response
      ..write('Merhaba, Dart sunucusundan!')
      ..close();
  }
}

Bölüm 10 Konu 47'de öğrendiğimiz await for'un burada gerçek bir kullanım alanı bulduğunu görüyorsun — sunucu, aslında bir Stream'dir (her gelen HTTP isteği, bu stream'e bir "eleman" olarak akar). Her yeni istek geldiğinde, await for döngüsü çalışır ve bir cevap gönderir.

Bu çalışır, ama gerçek dünyada, route yönetimi (farklı URL'lere farklı cevaplar vermek), middleware (istekleri işlemeden önce/sonra ortak işlemler yapmak) gibi ihtiyaçlar için çok ham kalır — her şeyi elle yönetmen gerekir. İşte bu yüzden shelf gibi paketler var.

shelf Paketi — Daha Yapılandırılmış Bir Web Sunucusu

bash
dart pub add shelf
dart
import 'dart:io';
import 'package:shelf/shelf.dart';
import 'package:shelf/shelf_io.dart' as shelf_io;

Response _istekIsleyici(Request istek) {
  return Response.ok('Merhaba, ${istek.url.path} yolundan istek geldi!');
}

void main() async {
  var sunucu = await shelf_io.serve(_istekIsleyici, 'localhost', 8080);
  print('Sunucu çalışıyor: http://${sunucu.address.host}:${sunucu.port}');
}

shelf, Bölüm 12'de öğrendiğimiz paket ekosistemi sayesinde, ham dart:io HTTP sunucusunun üzerine daha kullanışlı bir katman ekliyor — Request/Response gibi net soyutlamalar sunuyor.

Route Yönetimi — shelf_router ile

bash
dart pub add shelf_router
dart
import 'package:shelf/shelf.dart';
import 'package:shelf/shelf_io.dart' as shelf_io;
import 'package:shelf_router/shelf_router.dart';

Response anaSayfa(Request istek) => Response.ok('Ana sayfa');
Response kullaniciGetir(Request istek, String id) => Response.ok('Kullanıcı ID: $id');

void main() async {
  final router = Router();

  router.get('/', anaSayfa);
  router.get('/kullanici/<id>', kullaniciGetir);

  var sunucu = await shelf_io.serve(router.call, 'localhost', 8080);
  print('Sunucu çalışıyor: http://${sunucu.address.host}:${sunucu.port}');
}

Bu, Bölüm 4'te (Flutter müfredatı) göreceğimiz Navigator/routing kavramının, sunucu tarafındaki karşılığı gibi düşünülebilir — farklı URL "yollarına" (/, /kullanici/<id>), farklı fonksiyonlar atanıyor. <id> gibi bir parametre, URL'nin dinamik bir kısmını yakalayıp, işleyici fonksiyona parametre olarak geçiriyor.

Basit Bir CLI (Komut Satırı) Aracı Yazma

Bölüm 1 Konu 3'te main(List<String> args)'ı kısaca görmüştük — şimdi bunu gerçek bir CLI aracı yazmak için kullanalım:

dart
import 'dart:io';

void main(List<String> args) {
  if (args.isEmpty) {
    print('Kullanım: dart run bin/araç.dart <komut>');
    exit(1); // dart:io'dan gelen, programı belirli bir çıkış koduyla sonlandıran fonksiyon
  }

  String komut = args[0];

  switch (komut) {
    case 'merhaba':
      print('Merhaba, Dünya!');
    case 'tarih':
      print('Bugünün tarihi: ${DateTime.now()}');
    default:
      print('Bilinmeyen komut: $komut');
      exit(1);
  }
}

Terminalden çalıştırma:

bash
dart run bin/arac.dart merhaba
# Merhaba, Dünya!

dart run bin/arac.dart tarih
# Bugünün tarihi: 2026-...

Bu, Bölüm 3'te öğrendiğimiz switch expression'ı, Bölüm 1'de öğrendiğimiz main(args)'ı ve dart:io'dan gelen exit() fonksiyonunu bir araya getiren gerçek, çalışan bir araç. exit(1), programı hata koduyla (genelde 0 başarı, 0 dışındaki değerler hata anlamına gelir — bu, işletim sistemi/script'ler arası bir konvansiyondur) sonlandırır.

CLI Argümanlarını Daha Yapılandırılmış İşleme — args Paketi

bash
dart pub add args
dart
import 'package:args/args.dart';

void main(List<String> arguments) {
  final parser = ArgParser()
    ..addOption('isim', abbr: 'i', help: 'Selamlanacak kişinin adı')
    ..addFlag('detayli', abbr: 'd', help: 'Detaylı çıktı göster');

  final sonuclar = parser.parse(arguments);

  String isim = sonuclar['isim'] ?? 'Dünya';
  print('Merhaba, $isim!');

  if (sonuclar['detayli']) {
    print('Detaylı mod aktif');
  }
}
bash
dart run bin/arac.dart --isim Ahmet --detayli
# Merhaba, Ahmet!
# Detaylı mod aktif

args paketi, --isim, -i gibi standart komut satırı argümanı kalıplarını (Bölüm 12'de öğrendiğimiz pub.dev paket ekosisteminin bir başka faydalı örneği) otomatik olarak ayrıştırmanı sağlıyor — elle string parse etmek yerine, yapılandırılmış bir API kullanıyorsun.

Neden Bu Konuyu Bilmek Değerli?

Flutter geliştiricisi olarak, doğrudan sunucu kodu yazman gerekmeyebilir (genelde backend, farklı bir ekip veya farklı bir teknoloji ile yönetilir). Ama bu konuyu bilmek şunları sağlar:

  1. Tam yığın (full-stack) potansiyeli — aynı dil ile hem frontend (Flutter) hem backend yazabileceğini bilmek, küçük projelerde veya prototiplemede değerlidir.
  2. Kendi CLI araçlarını yazabilme — geliştirme sürecini otomatikleştiren küçük script'ler (Bölüm 12'de gördüğümüz dart pub gibi araçların kendisi de Dart ile yazılmıştır) yazabilirsin.
  3. Backend API'lerin nasıl çalıştığını anlama — Flutter'da API çağrıları yaparken (Bölüm 5, Flutter müfredatı), "öbür taraftaki" sunucunun nasıl çalıştığını anlamak, hata ayıklamanı kolaylaştırır.

🎯 Bu Dersten Çıkarılması Gerekenler

  • dart:io, dosya sistemi, ağ ve işlem yönetimi gibi sunucu/CLI'ye özgü işlevler sağlar; Flutter Web'de kullanılamaz.
  • Ham HttpServer ile bir web sunucusu yazılabilir, ama shelf gibi paketler, route yönetimi ve daha temiz bir API için tercih edilir.
  • shelf_router, farklı URL yollarına farklı işleyici fonksiyonlar atamayı sağlar.
  • main(List<String> args), gerçek CLI araçları yazmak için kullanılır; args paketi, komut satırı argümanlarını yapılandırılmış şekilde ayrıştırır.
  • Dart'ın sunucu tarafı yetenekleri, tam yığın potansiyeli, kendi geliştirme araçlarını yazabilme ve backend mantığını anlama açısından değerlidir.

📝 Ödevler

  • [ ] dart:io ile basit bir dosyaya yazıp okuyan, sonra silen bir program yaz.
  • [ ] Ham HttpServer ile tek bir endpoint'e ("/") cevap veren basit bir sunucu yaz, tarayıcıdan test et.
  • [ ] shelf paketiyle en az iki farklı route'a (/ ve /merhaba gibi) cevap veren bir sunucu yaz.
  • [ ] main(List<String> args) kullanarak, en az 2 farklı komutu (switch ile) destekleyen bir CLI aracı yaz.
  • [ ] args paketiyle, en az bir --option ve bir --flag destekleyen bir CLI aracı yaz, terminalden farklı argümanlarla test et.

Sıradaki konu: Bölüm 13 — Konu 66: Derleyici & Analiz Araçları — dart analyze, Custom Lint Kuralları, build_runner Mimarisi

64. bölüm

Bölüm 13 — Konu 66: Derleyici & Analiz Araçları — `dart analyze`, Custom Lint Kuralları, `build_runner` Mimarisi

Bu, tüm Dart müfredatının son dersi. Bölüm 1 Konu 2'de kısaca değindiğimiz dart analyze'ı derinlemesine işleyip, kod üretimi (code generation) ekosistemini anlayarak tutorial'ı tamamlayacağız.

dart analyze — Statik Analiz Derinlemesine

Bölüm 1'de dart analyze'ın "kod kalitesini kontrol eden bir araç" olduğunu söylemiştik. Şimdi bunun tam olarak neyi kontrol ettiğini görelim:

bash
dart analyze

Bu komut, projenin tüm .dart dosyalarını tarar ve şunları tespit eder:

  • Tip hataları (Bölüm 2'de öğrendiğimiz tip güvenliği ihlalleri)
  • Kullanılmayan import'lar (Bölüm 12'de öğrendiğimiz import mekanizmasının gereksiz kullanımı)
  • Potansiyel null safety sorunları
  • Stil kuralları ihlalleri (isimlendirme kuralları — Bölüm 1'de öğrendiğimiz lowerCamelCase gibi kurallar)
  • Deprecated (kullanımdan kaldırılmış) API kullanımı
dart
import 'dart:math'; // eğer hiç kullanılmıyorsa, dart analyze bunu UYARIR

void main() {
  print("Merhaba");
}

dart analyze çalıştırıldığında: info - Unused import: 'dart:math' gibi bir uyarı alırsın — bu, hata değil, sadece bir öneri (kod kalitesini artırmak için).

analysis_options.yaml — Analiz Kurallarını Özelleştirme

Projenin kök dizininde bir analysis_options.yaml dosyası oluşturarak, dart analyze'ın hangi kuralları ne kadar katı uygulayacağını özelleştirebilirsin:

yaml
include: package:lints/recommended.yaml

analyzer:
  errors:
    unused_import: error # bunu sadece "info" değil, gerçek bir HATA yap

linter:
  rules:
    - prefer_const_constructors # Bölüm 13 Konu 62'de öğrendiğimiz const kullanımını teşvik eder
    - avoid_print # print() kullanımını caydırır (üretim kodunda genelde loglama araçları tercih edilir)

include: package:lints/recommended.yaml, Dart ekibinin önerdiği standart kural setini projene dahil eder — Bölüm 12'de gördüğümüz dev_dependencies altındaki lints paketinden geliyordu, hatırlarsan.

Custom Lint Kuralları — Neden ve Nasıl?

Yukarıdaki linter: rules: bölümünde gördüğün gibi, hazır kuralları açıp kapatabilirsin. Bazı büyük şirketler/takımlar, kendi özel lint kurallarını da yazarlar (örneğin "şirketimizin API'lerini belirli bir şekilde çağırmayı zorunlu kıl" gibi) — bu, custom_lint gibi paketlerle mümkündür, ama bu ileri düzey bir konudur ve günlük Dart geliştirmede nadiren ihtiyaç duyulur. Bilmen gereken temel şey: lint kuralları, takımların kod tabanında tutarlılığı zorunlu kılmasının bir yoludur — Bölüm 1'de "isimlendirme kuralları zorunlu değil ama önerilir" dediğimizi hatırlarsan, lint kuralları bu önerileri derleme sürecinin bir parçası haline getirir.

build_runner — Kod Üretimi (Code Generation) Nedir?

Bölüm 13 Konu 64'te (FFI) ffigen'den bahsetmiştik — "bir header dosyasını okuyup Dart kodu üreten bir araç" demiştik. build_runner, Dart ekosisteminde bu tarz kod üretiminin genel altyapısıdır.

Neden kod üretimine ihtiyaç duyulur? Bazı görevler, tekrarlayıcı, mekanik kod yazmayı gerektirir — örneğin bir class'ın JSON'a nasıl dönüştürüleceğini (toJson()/fromJson()) elle yazmak, büyük class'larda çok can sıkıcı ve hataya açık olabilir. Kod üretimi, bunun yerine, sen bir class'ı belirli bir şekilde "işaretlersin", ve bir araç, bu işaretlemeye bakarak gerekli kodu otomatik olarak üretir.

dart
import 'package:json_annotation/json_annotation.dart';

part 'kullanici.g.dart'; // Bölüm 12'de öğrendiğimiz 'part' burada devreye giriyor!

@JsonSerializable()
class Kullanici {
  final String isim;
  final int yas;

  Kullanici(this.isim, this.yas);

  factory Kullanici.fromJson(Map<String, dynamic> json) => _$KullaniciFromJson(json);
  Map<String, dynamic> toJson() => _$KullaniciToJson(this);
}
bash
dart run build_runner build

Bu komut çalıştırıldığında, build_runner, @JsonSerializable() annotation'ını (Bölüm 6'da @override'ı gördüğümüz annotation mekanizmasının bir başka kullanımı) görür ve kullanici.g.dart adında otomatik olarak bir dosya üretir — bu dosya, _$KullaniciFromJson ve _$KullaniciToJson fonksiyonlarının gerçek implementasyonunu içerir (sen bunları elle yazmıyorsun).

Bölüm 12'de öğrendiğimiz part/part of mekanizması, tam olarak burada devreye giriyor — üretilen kullanici.g.dart dosyası, kullanici.dart ile aynı kütüphanenin bir parçası olarak tanımlanır (part of 'kullanici.dart'; ile), bu sayede private alanlara bile erişebilir.

build_runner'ın İç İşleyişi — Kavramsal Bir Bakış

  1. Annotation'ları tara: build_runner, projendeki tüm dosyaları tarar ve @JsonSerializable() gibi özel annotation'ları arar.
  2. Kod şablonu uygula: Her annotation için, ilgili "builder" (örneğin json_serializable paketinin kendi builder'ı), o class'ın yapısına (alanları, tipleri) bakarak uygun Dart kodunu oluşturur.
  3. .g.dart dosyası üret: Üretilen kod, orijinal dosyanın yanına, .g.dart uzantısıyla yeni bir dosya olarak yazılır.
  4. part of ile bağla: Bu üretilen dosya, orijinal dosyaya part of ile bağlanır (Bölüm 12'de öğrendiğimiz mekanizma).

Bu süreç, Bölüm 12'de öğrendiğimiz JIT/AOT derleme sürecinden ayrı, ona ek bir "önceki adım" (pre-processing step) olarak düşünülebilir — build_runner, Dart kodunu çalıştırmadan önce, bazı dosyaları otomatik olarak üretir, sonra normal derleme süreci (JIT veya AOT) bu üretilen kodu da içeren tüm projeyi derler.

freezed — Kod Üretiminin Bir Başka Güçlü Örneği

Bölüm 13 Konu 59'da öğrendiğimiz sealed class + pattern matching'i hatırlarsan — freezed paketi, bu tarz "değişmez veri sınıfları" yazmayı otomatikleştiren, çok popüler bir kod üretim aracıdır. Elle ==, hashCode, copyWith(), toString() gibi metodları yazmak yerine (Bölüm 6'da bunların bazılarını elle yazmıştık), freezed bunları otomatik üretir. Bunu Flutter tutorial'ında, state management konusunda muhtemelen karşına çıkacak.

Neden Bu Konuyu Bilmek "Uzmanlık" İçin Önemli?

Bu ders, aslında tüm tutorial'ın kapanış noktası: dart analyze, kod kalitesini korumanın; build_runner, tekrarlayan işleri otomatikleştirmenin araçlarıdır. Bir "uzman" Dart geliştiricisi, sadece dili bilmekle kalmaz — kod tabanını sürdürülebilir, tutarlı ve verimli tutan bu tür araçları da etkin şekilde kullanır. Bu, Bölüm 1'de sorduğun "bu tutorial'ı bitiren biri uzman diyebilir mi" sorusuna verdiğimiz cevabın tam olarak neyi kapsadığını gösteriyor — sadece sözdizimi değil, ekosistem araçları da uzmanlığın bir parçası.


🎯 Bu Dersten Çıkarılması Gerekenler

  • dart analyze, tip hataları, kullanılmayan kod, stil ihlalleri gibi sorunları statik olarak (kod çalıştırılmadan) tespit eder.
  • analysis_options.yaml, hangi lint kurallarının ne kadar katı uygulanacağını özelleştirmeni sağlar.
  • build_runner, annotation'lara (@JsonSerializable() gibi) dayanarak, tekrarlayan kodu otomatik olarak üreten bir altyapıdır.
  • Üretilen .g.dart dosyaları, part/part of mekanizmasıyla orijinal dosyaya bağlanır.
  • json_serializable, freezed gibi paketler, bu kod üretim altyapısını kullanarak geliştirici verimliliğini artırır.

📝 Ödevler

  • [ ] Kendi bir projende dart analyze çalıştır, çıkan uyarıları oku ve en az 3 tanesini düzelt.
  • [ ] analysis_options.yaml dosyası oluştur, package:lints/recommended.yaml'ı dahil et, en az bir kuralı özelleştir (aç/kapat veya seviyesini değiştir).
  • [ ] json_serializable paketini kur, basit bir class'a @JsonSerializable() ekle, build_runner ile kod üret, üretilen .g.dart dosyasını incele.
  • [ ] Kendi cümlelerinle, "build_runner'ın JIT/AOT derleme sürecinden nasıl farklı bir aşama olduğunu" açıkla.
  • [ ] Bu tutorial boyunca öğrendiğin konulardan, "artık günlük kodlamada rahatlıkla kullanabilirim" dediğin 5 konuyu ve "hâlâ pratik yapmam gerekiyor" dediğin 2 konuyu listele — kendi öğrenme yolculuğunu değerlendir.

🏁🎓 TÜM DART MÜFREDATI TAMAMLANDI!

Tebrikler — Bölüm 1'den Bölüm 13'e, 66 konuyu kapsayan bu yolculuğu tamamladın. Sıfırdan başlayıp:

  • Dart'ın temellerini (değişkenler, kontrol akışı, koleksiyonlar, fonksiyonlar)
  • Nesne yönelimli programlamayı (class'lar, kalıtım, interface'ler, mixin'ler)
  • Hata yönetimini ve null safety'yi
  • Generics'i
  • Asenkron programlamayı (Future, Stream, isolate'ler)
  • Fonksiyonel koleksiyon programlamasını
  • Paket ekosistemini ve proje organizasyonunu
  • Ve son olarak, dilin internals'ını (pattern matching, event loop, memory model, FFI, sunucu tarafı Dart, kod üretimi)

...baştan sona işledin. Bölüm 1'de sorduğun soruya geri dönersek: bu müfredatı gerçekten bitiren ve ödevleri yapan biri, artık dürüstçe "Dart'ı uzman seviyede biliyorum" diyebilir.

Şimdi sıra, daha önce hazırladığımız Flutter tutorial müfredatına geçmekte — Dart bilgin, Flutter'ın widget mimarisini, state management'ını ve tüm ekosistemini anlamak için sağlam bir temel oluşturuyor. Hazır olduğunda, Flutter Bölüm 1'den başlayabiliriz.