↑↓ seç · Enter aç · Esc kapat

Mutlu Tekin
Mutlu Tekin
← Yazılar

Bölüm 8 — Konu 41: `assert` ile Geliştirme Zamanı Kontrolleri

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

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ı)