Dart dilinde döngü kontrolleri, programlama süreçlerinde tekrar eden işlemleri kolaylaştırmak ve optimize etmek için kullanılan temel yapı taşlarıdır. Bu kontroller, belirli koşullara göre bir dizi işlemi yinelemek veya bir liste üzerinde gezinmek için kullanılır. İşte Dart dilinde döngü kontrollerini anlamak için temel başlıklar:
Döngü nedir?
Döngüler, belirli bir işlemi veya bloğu, belirli bir koşul sağlandığı sürece tekrar tekrar yürüten programlama yapılarıdır. Dart dilindeki döngüler, çeşitli tiplerde gelir ve her biri belirli bir kullanım senaryosuna uygun avantajlar sunar.
Dart’ta Döngü Çeşitleri
Dart dilinde kullanılan temel döngü çeşitleri for
, while
ve do-while
‘dır. Her bir döngü türü, farklı koşul ve senaryolara uygun olarak tasarlanmıştır. Bu çeşitlilik, programcılara çeşitli durumlarda en uygun döngü yapısını seçme esnekliği sağlar. Bu makalede, her bir döngü türünün kullanımını ayrıntılı olarak ele alacağız.
Dart Dilindeki Temel Döngü Türleri
for
Döngüsü
Başlangıç, Koşul ve Artış İfadesi
Dart dilindeki for
döngüsü, genellikle belirli bir aralıkta veya bir liste üzerinde iterasyon yapmak için kullanılır. Bu döngü türü üç temel bölümden oluşur: başlangıç ifadesi, koşul ifadesi ve artış ifadesi.
- Başlangıç İfadesi: Döngünün başlangıcında bir kere çalışan ifadedir. Genellikle bir değişkenin başlangıç değeri atanır.
- Koşul İfadesi: Döngünün her iterasyonu öncesi değerlendirilen bir ifadedir. Eğer bu ifade doğru (true) ise döngü devam eder, değilse sonlanır.
- Artış İfadesi: Her iterasyon sonunda çalışan ve genellikle bir değişkenin değerini artıran veya azaltan ifadedir.
Örnek Kullanımlar
1. Sayıları Toplama:
1 2 3 4 5 6 7 8 9 10 11 12 13 | void main() { int toplam = 0; for (int i = 1; i <= 10; i++) { toplam += i; } print('Toplam: $toplam'); } |
Bu örnekte, 1’den 10’a kadar olan sayıları toplamak için bir for
döngüsü kullanılmıştır.
2. Liste Elemanlarına Erişim:
1 2 3 4 5 6 7 8 9 10 11 12 | void main() { List<String> meyveler = ['elma', 'armut', 'çilek']; for (String meyve in meyveler) { print('Meyve: $meyve'); } } |
Bu örnekte, bir liste üzerinde for-in
döngüsü kullanılarak meyve isimlerine erişim sağlanmıştır.
for
döngüsü, belirli bir tekrar sayısına veya bir liste üzerinde gezinmeye ihtiyaç duyulan durumlarda kullanılır. Bu sayede kodunuz daha okunabilir ve yönetilebilir hale gelir.
while
Döngüsü
Koşul İfadesi ve İşleyiş Mekanizması
Dart dilindeki while
döngüsü, belirli bir koşul sağlandığı sürece bir bloğu tekrar tekrar yürütür. Temel öğeleri şunlardır:
- Koşul İfadesi: Döngünün her iterasyonu öncesi değerlendirilen bir ifadedir. Eğer bu ifade doğru (true) ise döngü devam eder, değilse sonlanır.
- İşleyiş Mekanizması: Koşul ifadesi doğru olduğu sürece döngü bloğu tekrar tekrar çalıştırılır.
Örnek Senaryolar
1. Sayıları Çarpma:
1 2 3 4 5 6 7 8 9 10 11 | int sayi = 1; int carpim = 1; while (sayi <= 5) { carpim *= sayi; sayi++; } print('Çarpım: $carpim'); |
Bu örnekte, 1’den 5’e kadar olan sayıların çarpımını bulmak için bir while
döngüsü kullanılmıştır.
2. Belirli Bir Koşulu Sağlayan Sayıları Bulma:
1 2 3 4 5 6 7 8 9 10 | int sayi = 1; while (sayi <= 10) { if (sayi % 2 == 0) { print('Çift sayı: $sayi'); } sayi++; } |
Bu örnekte, 1’den 10’a kadar olan çift sayıları bulmak için bir while
döngüsü kullanılmıştır.
do-while
Döngüsü
Koşulun Döngü İçinde Değerlendirilmesi
do-while
döngüsü, döngü bloğunu en az bir kez çalıştırır ve ardından koşulu değerlendirir. Temel öğeleri şunlardır:
- İşleyiş Mekanizması: Döngü bloğu en az bir kez çalıştırılır, ardından koşul ifadesi değerlendirilir. Eğer koşul doğru (true) ise döngü devam eder, değilse sonlanır.
Uygulama Alanları
1. Kullanıcıdan Giriş Alma:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | import 'dart:math'; import 'dart:io'; void main() { // Bilgisayar rastgele bir sayı seçer int bilgisayarSayisi = Random().nextInt(100) + 1; // Kullanıcıdan tahmin girmesini istenir int kullaniciTahmini; int denemeSayisi = 0; print('1 ile 100 arasında bir sayı tahmin edin.'); do { // Kullanıcının tahmini alınır String? kullaniciGirdisi = stdin.readLineSync(); // Kullanıcının girdisi sayıya dönüştürülür kullaniciTahmini = int.tryParse(kullaniciGirdisi!) ?? 0; // Deneme sayısı arttırılır denemeSayisi++; // Tahmin değeri kontrol edilir if (kullaniciTahmini > bilgisayarSayisi) { print('Daha küçük bir sayı deneyin.'); } else if (kullaniciTahmini < bilgisayarSayisi) { print('Daha büyük bir sayı deneyin.'); } else { print('Tebrikler! Sayıyı doğru tahmin ettiniz.'); print('Deneme sayısı: $denemeSayisi'); } } while (kullaniciTahmini != bilgisayarSayisi); } |
Bu örnekte, kullanıcının belirli bir aralıkta rastgele seçilen bir sayıyı tahmin etmesi istenir. Kullanıcı her tahmininde, bilgisayarın seçtiği sayı ile karşılaştırılır ve kullanıcıya daha yüksek veya daha düşük bir tahminde bulunması konusunda bilgi verilir. Kullanıcı doğru tahmini yaptığında, kaç denemede doğru tahmin yapıldığı ekrana yazdırılır.
2. Toplamı Belirli Bir Sınıra Çekme:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | import 'dart:math'; void main() { int toplam = 0; do { int rastgeleSayi = Random().nextInt(10); toplam += rastgeleSayi; } while (toplam < 100); print('Toplam: $toplam'); } |
Döngü Kontrollerindeki Temel İfadeler
break
İfadesi
Döngüden Erken Çıkma
Dart dilindeki break
ifadesi, bir döngüyü belirli bir koşul sağlandığında erken sonlandırmak için kullanılır. Temel öğeleri şunlardır:
- Kullanım Noktaları:
break
ifadesi genellikle birif
ifadesi içinde belirli bir koşul sağlandığında döngüden çıkmak için kullanılır. - Döngüden Çıkma Mantığı:
break
ifadesi, bulunduğu döngüyü hemen sonlandırır ve döngü sonrasındaki kodun çalışmasına devam eder.
Kullanım Örnekleri
1. Belirli Bir Koşulu Sağlayan Elemanı Bulma:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | void main() { List<int> sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; int arananSayi = 7; for (int sayi in sayilar) { if (sayi == arananSayi) { print('Sayı bulundu: $sayi'); break; // Sayı bulunduğunda döngüden çık } } } |
Bu örnekte, belirli bir sayıyı içeren bir liste üzerinde döngü kurulmuş ve aranan sayı bulunduğunda break
ifadesi kullanılarak döngüden çıkılmıştır.
2. Kullanıcıdan Belirli Bir Girdi Bekleme:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import 'dart:io'; void main() { String? kullaniciGirdisi; while (true) { print('Devam etmek için "E" tuşuna, çıkmak için "Q" tuşuna basın: '); kullaniciGirdisi = stdin.readLineSync(); if (kullaniciGirdisi!.toUpperCase() == 'Q') { print('Programdan çıkılıyor...'); break; // Kullanıcı "Q" tuşuna bastığında döngüden çık } } } |
Bu örnekte, kullanıcının “E” tuşuna basarak devam etmesi veya “Q” tuşuna basarak programdan çıkması sağlanmış ve break
ifadesi kullanılarak döngüden çıkılmıştır.
continue
İfadesi
Döngü İterasyonunu Atlama
Dart dilindeki continue
ifadesi, bir döngünün belirli bir koşulu sağlayan iterasyonlarını atlamak için kullanılır. Temel öğeleri şunlardır:
- Kullanım Noktaları:
continue
ifadesi genellikle birif
ifadesi içinde belirli bir koşul sağlandığında döngü iterasyonunu atlamak için kullanılır. - İterasyonu Atlama Mantığı:
continue
ifadesi, bulunduğu döngüdeki mevcut iterasyonu atlar ve bir sonraki iterasyona geçer.
Pratik Kullanımlar
1. Tek Sayıları Atlayarak Toplama:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | void main() { int toplam = 0; for (int i = 1; i <= 10; i++) { if (i % 2 == 1) { continue; // Tek sayıları atla } toplam += i; } print('Toplam: $toplam'); } |
Bu örnekte, continue
ifadesi kullanılarak for
döngüsünde tek sayılar atlanmış ve sadece çift sayılar toplanmıştır.
2. Belirli Bir Durumu İptal Etme:
1 2 3 4 5 6 7 8 9 10 11 12 | void main() { List<String?> isimler = ['Ahmet', ' ', 'Mehmet', null, 'Hayri']; for (String? isim in isimler) { if (isim == null || isim.trim().isEmpty) { continue; // Boş veya null isimleri ignore et } print('İsim: $isim'); } } |
Bu örnekte, continue
ifadesi kullanılarak for
döngüsünde boş veya null olan isimler ignore edilmiştir.
Iterable ve Iterator Kavramları
Dart’ta Iterable ve Iterator Nedir?
Iterable Nedir?
Dart dilinde bir nesnenin üzerinde gezinmeyi sağlayan ve for-in
döngülerinde kullanılabilen her şey “Iterable” olarak adlandırılır. Iterable, Iterable
sınıfından türetilmiş nesneleri ifade eder.
Iterator Nedir?
Iterator, bir Iterable üzerinde gezinmek için kullanılan bir nesnedir. Iterator, Iterator
sınıfından türetilmiş ve Iterable
üzerindeki elemanlara sırayla erişimi sağlar.
Döngü Kontrollerinde Iterable Kullanımı
Dart dilindeki Iterable nesneleri, for-in
döngülerinde kullanılabilir. Iterable nesneler, koleksiyonlar (List, Set, Map gibi) ve diğer Iterable sınıflarını içerir. Örneğin:
1 2 3 4 5 6 7 8 9 10 11 | void main() { List<String> isimler = ['Ahmet', 'Mehmet', 'Ayşe']; for (String isim in isimler) { print('İsim: $isim'); } } |
Bu örnekte, isimler
listesi bir Iterable nesnesidir ve for-in
döngüsü kullanılarak elemanlarına erişim sağlanmıştır.
Iterator ile Özel İşlemler
Dart dilinde Iterator nesneleri, Iterable
sınıfının iterator
metodunu kullanarak oluşturulabilir. Bu Iterator, moveNext
ve current
metodları ile Iterable üzerinde gezinme yeteneği sağlar.
1 2 3 4 5 6 7 8 9 10 11 12 | void main() { Iterable<int> sayilar = [1, 2, 3, 4, 5]; Iterator<int> iterator = sayilar.iterator; while (iterator.moveNext()) { print('Sayı: ${iterator.current}'); } } |
Bu örnekte, bir Iterator
nesnesi oluşturulmuş ve while
döngüsü ile Iterable üzerinde gezinme gerçekleştirilmiştir.
Döngü Kontrollerinde Güncel ve Modern Yaklaşımlar
forEach
Metodu Kullanımı
Dart dilindeki Iterable nesneleri üzerinde gezinmek için forEach
metodunu kullanmak modern bir yaklaşımdır.
1 2 3 4 5 6 7 8 9 10 11 | void main() { List<String> meyveler = ['elma', 'armut', 'çilek']; meyveler.forEach((meyve) { print('Meyve: $meyve'); }); } |
Bu örnekte, forEach
metodu kullanılarak meyveler listesi üzerinde gezinilmiş ve her eleman için belirli bir işlem gerçekleştirilmiştir.
for-in
Deyimi ve Avantajları
for-in
deyimi, Iterable nesneler üzerinde gezinmek için kullanılan temiz ve okunabilir bir yapısıyla dikkat çeker. Özellikle koleksiyonlarda ve dizilerde kullanımı yaygındır.
1 2 3 4 5 6 7 8 9 10 11 | void main() { Set<int> sayiSeti = {1, 2, 3, 4, 5}; for (int sayi in sayiSeti) { print('Sayı: $sayi'); } } |
Bu örnekte, for-in
deyimi kullanılarak bir Set
üzerinde gezinilmiş ve her eleman için belirli bir işlem gerçekleştirilmiştir.
Döngü Kontrollerinde Lambda (Arrow) Fonksiyonları
Dart dilinde lambda fonksiyonları, kısa ve öz bir şekilde fonksiyon tanımlamak için kullanılır. Döngü kontrollerinde lambda fonksiyonları, daha kompakt ve okunabilir kod yazmaya olanak tanır.
1 2 3 4 5 6 7 8 9 | void main() { List<int> sayilar = [1, 2, 3, 4, 5]; sayilar.forEach((sayi) => print('Sayı: $sayi')); } |
Bu örnekte, forEach
metodu içinde lambda fonksiyonu kullanılarak sayılar listesi üzerinde gezinilmiş ve her eleman için belirli bir işlem gerçekleştirilmiştir.
Döngü Kontrollerinde Hata Yönetimi
Hataların İzlenmesi ve Yönetilmesi
Hata yönetimi, bir programın beklenmeyen durumlarla başa çıkabilme yeteneğini ifade eder. Döngü kontrollerinde hata yönetimi, özellikle bir döngü içinde meydana gelebilecek hataları izlemek ve bunlara uygun bir şekilde yanıt vermek için önemlidir.
Döngü Kontrollerinde Try-Catch Blokları
Dart dilindeki try-catch
blokları, belirli bir kod bloğundaki hataları yakalamak ve bu hatalara uygun bir şekilde tepki vermek için kullanılır. Döngü içinde hata yönetimi sağlamak için try-catch
bloklarını kullanabiliriz.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | void main() { List<int> sayilar = [1, 2, 3, 4, 5]; for (int sayi in sayilar) { try { // Hata oluşturan bir işlem if (sayi == 3) { throw Exception('Hata: 3 sayısı bulundu.'); } // Hata oluşturmayan bir işlem print('Sayı: $sayi'); } catch (e) { // Hata yakalandığında yapılacak işlemler print('Hata Yakalandı: $e'); } } } |
Bu örnekte, döngü içinde belirli bir durumda bir hata oluşturulmuş ve bu hata try-catch
blokları ile yakalanmıştır.
Örnek Uygulama: Bir Liste Üzerinde Döngü Kontrolleri
Liste Oluşturma ve İlk Verilerin Eklenmesi
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | List<int> notlar = []; void main() { notEkle(90); notEkle(80); notEkle(105); // Hata: Geçersiz not değeri. notEkle(95); } void notEkle(int not) { if (not < 0 || not > 100) { throw Exception('Hata: Geçersiz not değeri.'); } notlar.add(not); } |
Bu örnekte, notEkle
fonksiyonu ile bir liste üzerine notlar eklenir. Ancak, geçersiz bir not eklendiğinde bir hata oluşturulur.
Döngü Kontrolleri ile Liste Elemanlarına Erişim
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | List<int> notlar = []; void main() { for (int not in notlar) { try { if (not >= 90) { print('Not: $not - Geçtiniz'); } else { print('Not: $not - Kaldınız'); } } catch (e) { print('Hata Yakalandı: $e'); } } } |
Bu örnekte, for
döngüsü ile oluşturulan hataları yakalayarak her bir not için belirli bir işlem gerçekleştirilir.
Hata Yönetimi ve İterasyonları İzleme
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | List<int> notlar = []; void main() { int iterasyon = 0; for (int not in notlar) { iterasyon++; try { if (not >= 90) { print('Not: $not - Geçtiniz'); } else { print('Not: $not - Kaldınız'); } } catch (e) { print('Hata Yakalandı: $e - İterasyon: $iterasyon'); } } } |
Bu örnekte, her bir iterasyon sırasında oluşan hataların yanı sıra o anki iterasyon numarası da ekrana yazdırılır. Bu, hataların hangi aşamada meydana geldiğini izlemek için faydalı olabilir.
Sonuç
Dart dilinde döngü kontrol mekanizmaları, programların tekrarlayan işlemleri yönetmelerini ve aynı zamanda hata yönetimi ile başa çıkmalarını sağlar. Iterable ve Iterator kavramları, veri koleksiyonları üzerinde gezinmeyi kolaylaştırırken, try-catch blokları hata yönetimini etkin bir şekilde gerçekleştirmemize imkan tanır. Modern yaklaşımlar, kodun okunabilirliğini artırır ve programcılara daha esnek bir yazım stili sunar. Dart dilindeki döngü kontrol mekanizmaları, yazılım geliştirme sürecinde hem güvenilirlik hem de esneklik sağlayarak etkili ve sağlam uygulamalar oluşturmak için önemli araçlar sunar.
Kaynak: https://dart.dev/language/loops
[…] Dart Döngü Kontrolleri ( for, while kullanımı) […]