Döngüler

Tekrarlı işlemler için döngü yapıları.

For Döngüsü (Range)

// 0'dan 4'e kadar (5 hariç)
döngü i 0'dan 5'e {
    yazdır(i)  // 0, 1, 2, 3, 4
}

// 0'dan 5'e kadar (5 dahil)
döngü i 0'dan 6'ya kadar {
    yazdır(i)  // 0, 1, 2, 3, 4, 5
}

// Tersden sayma
döngü i 10'dan 0'a {
    yazdır(i)  // 10, 9, 8, ..., 1
}

// Adım boyutu
döngü i 0'dan 10'a adım 2 {
    yazdır(i)  // 0, 2, 4, 6, 8
}

İngilizce syntax:

for i from 0 to 5 {
    print(i)
}

for i from 0 to 5 inclusive {
    print(i)
}

For-Each Döngüsü

değişken sayılar = [1, 2, 3, 4, 5]

döngü sayı sayılarda {
    yazdır(sayı)
}

// İndeks ile
döngü (indeks, değer) sayılarda {
    yazdır(indeks, ": ", değer)
}

İngilizce:

for num in numbers {
    print(num)
}

for (index, value) in numbers {
    print(index, ": ", value)
}

While Döngüsü

değişken sayaç = 0

iken sayaç < 5 {
    yazdır(sayaç)
    sayaç += 1
}

İngilizce:

var counter = 0

while counter < 5 {
    print(counter)
    counter += 1
}

Do-While Döngüsü

En az bir kez çalışır:

değişken x = 0

yap {
    yazdır(x)
    x += 1
} iken x < 5

Sonsuz Döngü

döngü {
    // Sonsuz döngü
    eğer koşul {
        kır  // Çıkış
    }
}

Break ve Continue

Break (Kır)

Döngüden çık:

döngü i 0'dan 10'a {
    eğer i == 5 {
        kır  // Döngü durur
    }
    yazdır(i)  // 0, 1, 2, 3, 4
}

Continue (Devam)

Sonraki iterasyona geç:

döngü i 0'dan 10'a {
    eğer i % 2 == 0 {
        devam  // Çift sayıları atla
    }
    yazdır(i)  // 1, 3, 5, 7, 9 (tek sayılar)
}

İç İçe Döngüler

döngü i 1'den 4'e {
    döngü j 1'den 4'e {
        yazdır(i * j, " ", sonlandırma: "")
    }
    yazdır()  // Yeni satır
}
// Çıktı:
// 1 2 3
// 2 4 6
// 3 6 9

Etiketli break:

dış: döngü i 0'dan 5'e {
    iç: döngü j 0'dan 5'e {
        eğer i * j > 10 {
            kır dış  // Dış döngüden çık
        }
        yazdır(i, "*", j, "=", i*j)
    }
}

Döngü ile Koleksiyonlar

Liste Üzerinde

değişken meyveler = ["elma", "armut", "kiraz"]

döngü meyve meyvelerde {
    yazdır(meyve)
}

// Filtreleme
döngü meyve meyvelerde {
    eğer meyve.uzunluk > 4 {
        yazdır(meyve)
    }
}

Map Üzerinde

değişken yaşlar = {
    "Ahmet": 25,
    "Mehmet": 30,
    "Ayşe": 28
}

döngü (isim, yaş) yaşlarda {
    yazdır(isim, ": ", yaş)
}

Range ile

// 1'den 10'a (10 dahil)
döngü x [1..10]'da {
    yazdır(x)
}

// Filtreli range
döngü x [1..20]'de {
    eğer x % 3 == 0 {
        yazdır(x)  // 3'e bölünenler
    }
}

Iterator Metodları

değişken sayılar = [1, 2, 3, 4, 5]

// Map
değişken kareler = sayılar.eşle(x => x * x)

// Filter
değişken çiftler = sayılar.filtrele(x => x % 2 == 0)

// Reduce
değişken toplam = sayılar.azalt((a, b) => a + b)

// ForEach
sayılar.herbiri(x => yazdır(x))

Best Practices

✅ Yapılması Gerekenler

// Anlamlı değişken isimleri
döngü öğrenci öğrencilerde {
    işle(öğrenci)
}

// For-each tercih edin
değişken liste = [1, 2, 3]
döngü eleman listede {  // İyi
    yazdır(eleman)
}

// Iterator metodları kullanın
değişken sonuç = sayılar
    .filtrele(x => x > 0)
    .eşle(x => x * 2)
    .azalt((a, b) => a + b)

❌ Kaçınılması Gerekenler

// Manuel indeks yönetimi
döngü i 0'dan liste.uzunluk'a {
    yazdır(liste[i])  // Kötü
}
// Bunun yerine:
döngü eleman listede {
    yazdır(eleman)  // İyi
}

// Sonsuz döngü tuzakları
iken doğru {  // Tehlikeli
    // Çıkış koşulu olmadan
}

// Gereksiz iç içe döngüler
// O(n²) veya daha kötü karmaşıklık

Örnekler

Fibonacci

işlev fibonacci(n: Sayı) -> Liste<Sayı> {
    değişken sonuç = [0, 1]
    
    döngü i 2'den n'ye {
        değişken sonraki = sonuç[i-1] + sonuç[i-2]
        sonuç.ekle(sonraki)
    }
    
    geri dön sonuç
}

Asal Sayılar

işlev asal_mi(n: Sayı) -> Boolean {
    eğer n < 2 {
        geri dön yanlış
    }
    
    döngü i 2'den n'ye {
        eğer i * i > n {
            kır
        }
        eğer n % i == 0 {
            geri dön yanlış
        }
    }
    
    geri dön doğru
}