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ı:
breakifadesi genellikle birififadesi içinde belirli bir koşul sağlandığında döngüden çıkmak için kullanılır. - Döngüden Çıkma Mantığı:
breakifadesi, 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ı:
continueifadesi genellikle birififadesi içinde belirli bir koşul sağlandığında döngü iterasyonunu atlamak için kullanılır. - İterasyonu Atlama Mantığı:
continueifadesi, 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ı) […]