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.
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.
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.
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)
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).
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.
VS Code içinde Extensions (Uzantılar) sekmesine git, "Dart" eklentisini ara ve kur.
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.
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:
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.
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.
#print() ile String Birleştirme — Küçük Bir Önizleme
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.
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.
[ ] 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.
/// 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.
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.)
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 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.
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.
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.
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.
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.
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.
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.
[ ] 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`
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
}
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.
Ö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.
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ı
}
Ö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.
Ö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.
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.
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).
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.
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:
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 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.
// 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.
[ ] 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
Ö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:
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 tipiniObject 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.
✅ 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.
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.
// 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.
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.
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.
[ ] 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.
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.
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.
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.
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.
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.
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)
! 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.
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.
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.
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.
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).
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.
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).
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ş):
() parantezler
!, ++, -- (unary operatörler)
*, /, ~/, %
+, -
<, >, <=, >=
==, !=
&&
||
??
=, +=, -= 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;
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");
}
}
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ı.
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).
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.
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.
[ ] 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)
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.
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 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:
: 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.
// 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:
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.
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.
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.
[ ] 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.
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:
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).
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
}
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.
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 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.
[ ] 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
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.
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
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.
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
}
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.
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, 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.
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.
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.
#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
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
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.
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.
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).
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>
}
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.
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.
Ö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.
[ ] 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
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<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); // {}
}
Ö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.
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.
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.
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):
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).
[ ] Ü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.
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:
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.
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.
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.
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.
[ ] 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"
... (üç 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.
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.
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 indirimVarMifalse 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]
}
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:
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.
[ ] İ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).
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.
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.
Ş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
}
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.
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.
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:
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
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.
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.
[ ] 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.
#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
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.
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.
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).
[ ] 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
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ç
}
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.
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.
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.
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
}
Arrow function, Dart/Flutter kodunda inanılmaz derecede yaygındır çünkü:
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.
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.
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;
}
[ ] Üç 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:
Bir fonksiyonu bir değişkene atayabilirsin
Bir fonksiyonu başka bir fonksiyona parametre olarak geçebilirsin
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).
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.
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.
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.
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.
[ ] 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, 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.
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.
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
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ı
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.
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.
[ ] 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).
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.
Her recursive (özyinelemeli) fonksiyonun iki temel parçası olmalıdır:
Base case (taban durumu): Fonksiyonun kendini çağırmayı durdurduğu koşul. Yukarıdaki örnekte n <= 0 durumu budur.
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.
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
}
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.
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.
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ı.
[ ] 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.
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.
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())
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.
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ı).
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.
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.
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:
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.
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.
[ ] 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.
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.
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).
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.
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
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.
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:
@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
}
[ ] 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, 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)
}
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.
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.
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.
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.
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.
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.
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.
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?
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.
[ ] 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.
Ş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.nesneSayisideğil. Static üyelere, class adı üzerinden erişilir, çünkü onlar herhangi bir spesifik nesneye değil, class'ın kendisine aittir.
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);
}
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ı).
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).
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.
[ ] 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.
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 (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ı.
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'ı mutlakasuper(...) 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.
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.
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.
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).
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 mutlakasuper(...) 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");
}
}
// 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.
[ ] 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 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.
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 @overrideyazmasaydı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.
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.
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.
[ ] 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`)
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ğrudanSekil() 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).
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.
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.
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
}
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.
[ ] 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
}
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:
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.
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.
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:
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.
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.
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.
[ ] 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, 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
}
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).
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).
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.
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.
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.
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 switchderleme zamanında eksik (non-exhaustive) olarak işaretlenir — böylece unutkanlıktan kaynaklı hatalar baştan engellenir.
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 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.
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.
[ ] 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.
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.
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.
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.
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.
Ş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:
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).
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.
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.
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.
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ıpon ile spesifik olarak yakalayabilirsin.
Ö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
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).
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.
Ö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.
[ ] 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.
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.
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:
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.
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, 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.
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.
[ ] 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 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.
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.
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'ı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.
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.
[ ] 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.
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.
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.
<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 kesinlikleString tutacağını bilir ve tip güvenliğini tam olarak korur — dynamic kullanmadığımız için hiçbir tip belirsizliği yok.
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çaKutu<String>(...) yazmak okunabilirlik açısından tercih edilir.
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.
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.
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
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.
[ ] 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.
<T extends Comparable>, "T, sadeceComparable 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.
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.
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 sadeceHayvan'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).
#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.
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.
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.
[ ] 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.
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 kendiList<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.
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.
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):
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.
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.
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.
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.
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.
Çı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, ş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.
İ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.
.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
Ö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
}
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.
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).
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'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.
[ ] 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(), 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).
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.
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/awaittercih edilen yöntemdir. .then()'i bilmen önemli çünkü hem eski kodlarda hem bazı API tasarımlarında karşına çıkacak.
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.
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
.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(), 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)");
}
}
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ü:
Bazı Dart/Flutter API'leri, Future döndüren metodlarını .then() ile kullanmanı öneren dokümantasyonlarla gelir.
Üçüncü parti paketlerde veya eski kod tabanlarında .then() zincirleriyle sıkça karşılaşacaksın.
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");
}
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.
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
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:
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(), 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<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 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.
[ ] 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, 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<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:
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:
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(), 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.
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.
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).
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(), 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.
.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.
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."
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.
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!
}
.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.
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.
[ ] 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
.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.
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.
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.
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.
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.
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.
[ ] 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, 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.
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.
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çinmap 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ı.
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
}
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.
[ ] 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.
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.
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:
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.
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.
Burada, adres alanına atama yaparken, içindekiAdres 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.
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.
// 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.
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.
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.
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.
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.
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.
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/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 '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.
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).
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.
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.
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, 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.
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.
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.
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.
[ ] 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ığı)
Ş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.
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.
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(), 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.
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.
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.
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, StringDart'ı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 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.
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:
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:
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.
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.
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 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!
}
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).
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.
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.
[ ] 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.
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, 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, 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.
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.
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, 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.
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.
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.
[ ] 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
}
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:
var (min, max) = ... satırı, record'un $1 ve $2 elemanlarını doğrudanmin 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
}
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:
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.
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.
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.
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.
[ ] 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.
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).
Ş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çekteList<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.
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
}
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.
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.
[ ] 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.
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:
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.
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.
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 nereyetry/catch veya .catchError() koyman gerektiğine karar verirken, hatanın tam olarak nasıl yayılacağını bilmek, doğru yerde yakalamanı sağlar.
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.
[ ] 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ı
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).
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 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:
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.
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.
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.
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.
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.
[ ] 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.
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).
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.
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.
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.
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.
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.
[ ] 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
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.
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.
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:
DynamicLibrary.open(...): İşletim sisteminin, derlenmiş bir C kütüphanesini (paylaşımlı kütüphane — shared library) belleğe yüklemesini sağlar.
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).
.lookupFunction<...>(...): Kütüphane içindeki, ismiyle belirtilen fonksiyonu bulur ve Dart'tan çağrılabilir bir referansa dönüştürür.
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.
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 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.
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.
[ ] 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.
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.
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)
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
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.
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.
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.
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:
Tam yığın (full-stack) potansiyeli — aynı dil ile hem frontend (Flutter) hem backend yazabileceğini bilmek, küçük projelerde veya prototiplemede değerlidir.
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.
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.
[ ] 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.
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).
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.
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ış
Annotation'ları tara: build_runner, projendeki tüm dosyaları tarar ve @JsonSerializable() gibi özel annotation'ları arar.
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.
.g.dart dosyası üret: Üretilen kod, orijinal dosyanın yanına, .g.dart uzantısıyla yeni bir dosya olarak yazılır.
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.
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.
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ı.
[ ] 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.
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.