7. Döngüler (for, while, do-while, foreach)

C# programlama dilinde döngüler, belirli bir kod bloğunu tekrar tekrar çalıştırmak için kullanılan temel kontrol yapılarıdır. Bu yapılar, bir koşul sağlandığı sürece veya bir koleksiyonun tüm elemanları üzerinde işlem yapılana kadar kodun tekrarlanmasını sağlar. C#, geliştiricilere farklı ihtiyaçlara uygun çeşitli döngü türleri sunar: for, while, do-while ve foreach.

Döngülerin Önemi

Döngüler, programlamada tekrar eden işlemleri otomatikleştirmek ve karmaşık algoritmaları uygulamak için vazgeçilmezdir. Veri işleme, hesaplama, kullanıcı arayüzü oluşturma gibi birçok alanda kullanılırlar. Döngüler sayesinde, aynı kodu birden çok kez yazmak yerine, döngü mekanizması sayesinde bu işlemler otomatik olarak gerçekleştirilir. Bu da kodun daha okunabilir, sürdürülebilir ve hatasız olmasını sağlar.

for Döngüsü

for döngüsü, belirli bir sayıda tekrar yapılması gereken durumlarda kullanılır. Genellikle bir sayaç değişkeni ile birlikte kullanılır ve döngünün kaç kez çalışacağını önceden belirlemek için idealdir.

for Döngüsünün Yapısı

for döngüsünün genel yapısı aşağıdaki gibidir:

for (başlangıç; koşul; artış/azalış) {
    // Tekrarlanacak kod bloğu
}

• Başlangıç: Döngü başlamadan önce bir sayaç değişkeni tanımlanır ve ilk değeri atanır.
• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir mantıksal ifadedir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.
• Artış/Azalış: Her döngü adımında sayaç değişkeninin değeri artırılır veya azaltılır. Bu, döngünün sonlanmasını sağlar.

for Döngüsü Örneği

Aşağıdaki örnek, 1’den 10’a kadar olan sayıları ekrana yazdırır:

for (int i = 1; i <= 10; i++) {
    Console.WriteLine(i);
}

Bu kodda, i değişkeni 1’den başlar ve her adımda 1 artar. Döngü, i değeri 10’dan küçük veya eşit olduğu sürece devam eder. Her adımda i değeri ekrana yazdırılır.

while Döngüsü

while döngüsü, belirli bir koşul sağlandığı sürece bir kod bloğunu tekrar tekrar çalıştırmak için kullanılır. Koşul, döngünün başında kontrol edilir. Eğer koşul başlangıçta yanlış (false) ise, döngü hiç çalışmaz.

while Döngüsünün Yapısı

while döngüsünün genel yapısı aşağıdaki gibidir:

while (koşul) {
    // Tekrarlanacak kod bloğu
}

• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir mantıksal ifadedir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.

while Döngüsü Örneği

Aşağıdaki örnek, kullanıcının girdiği sayı 0’dan farklı olduğu sürece sayıları toplamaya devam eder:

int toplam = 0;
int sayi = 1;

while (sayi != 0) {
    Console.Write("Bir sayı girin (0 çıkış): ");
    sayi = int.Parse(Console.ReadLine());
    toplam += sayi;
}

Console.WriteLine("Toplam: " + toplam);

Bu kodda, döngü sayi değişkeni 0’dan farklı olduğu sürece devam eder. Kullanıcıdan bir sayı alınır ve toplam değişkenine eklenir. Kullanıcı 0 girdiğinde döngü sona erer ve toplam ekrana yazdırılır.

do-while Döngüsü

do-while döngüsü, while döngüsüne benzer, ancak koşul döngünün sonunda kontrol edilir. Bu, döngünün en az bir kez çalışmasını garanti eder.

do-while Döngüsünün Yapısı

do-while döngüsünün genel yapısı aşağıdaki gibidir:

do {
    // Tekrarlanacak kod bloğu
} while (koşul);

• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir mantıksal ifadedir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.

do-while Döngüsü Örneği

Aşağıdaki örnek, kullanıcıdan geçerli bir şifre girmesini ister ve şifre doğru olana kadar tekrar sorar:

string sifre;
do {
    Console.Write("Şifreyi girin: ");
    sifre = Console.ReadLine();
} while (sifre != "gizli");

Console.WriteLine("Şifre doğru!");

Bu kodda, döngü en az bir kez çalışır ve kullanıcıdan bir şifre girmesi istenir. Girilen şifre “gizli” değilse, döngü tekrar başlar ve kullanıcıdan tekrar şifre girmesi istenir. Şifre doğru girildiğinde döngü sona erer.

foreach Döngüsü

foreach döngüsü, bir koleksiyonun (dizi, liste, vb.) tüm elemanları üzerinde işlem yapmak için kullanılır. Bu döngü, koleksiyonun her bir elemanı için kod bloğunu otomatik olarak çalıştırır.

foreach Döngüsünün Yapısı

foreach döngüsünün genel yapısı aşağıdaki gibidir:

foreach (veri_tipi değişken in koleksiyon) {
    // Tekrarlanacak kod bloğu
}

• Veri Tipi: Koleksiyondaki elemanların veri tipini belirtir.
• Değişken: Koleksiyondaki her bir elemanı temsil eden bir değişkendir.
• Koleksiyon: Üzerinde işlem yapılacak olan koleksiyon (dizi, liste, vb.).

foreach Döngüsü Örneği

Aşağıdaki örnek, bir dizideki tüm sayıları ekrana yazdırır:

int[] sayilar = { 1, 2, 3, 4, 5 };

foreach (int sayi in sayilar) {
    Console.WriteLine(sayi);
}

Bu kodda, sayilar dizisindeki her bir sayı sayi değişkenine atanır ve ekrana yazdırılır. Döngü, dizinin tüm elemanları üzerinde işlem yapana kadar devam eder.

Döngülerde Dikkat Edilmesi Gerekenler

• Sonsuz Döngülerden Kaçının: Döngü koşulunun hiçbir zaman false olmaması durumunda, döngü sonsuza kadar çalışır. Bu durumu önlemek için koşulun doğru bir şekilde tanımlandığından ve döngü içinde koşulu etkileyen bir değişiklik yapıldığından emin olun.
• Performansı Göz Önünde Bulundurun: Özellikle büyük veri kümeleri üzerinde çalışan döngülerde, performans önemlidir. Gereksiz işlemleri döngü dışına taşıyarak ve uygun veri yapılarını kullanarak performansı artırabilirsiniz.
• Okunabilirliği Artırın: Döngülerin içindeki kodun okunabilir ve anlaşılır olması, kodun bakımını ve hataların giderilmesini kolaylaştırır. Anlamlı değişken isimleri kullanın ve karmaşık işlemleri daha küçük parçalara ayırın.

“Döngüler, programlamanın temel yapı taşlarından biridir. İyi tasarlanmış döngüler, karmaşık problemleri çözmek ve verimli çözümler üretmek için güçlü bir araçtır.” – Bilgisayar Bilimi Uzmanı

Sonuç

C# programlama dilinde for, while, do-while ve foreach döngüleri, farklı ihtiyaçlara uygun esnek ve güçlü araçlar sunar. Bu döngülerin doğru kullanımı, kodun daha verimli, okunabilir ve sürdürülebilir olmasını sağlar. Döngülerin yapısını ve kullanım senaryolarını iyi anlamak, başarılı bir C# geliştiricisi olmak için önemlidir.

7. Döngüler (for, while, do-while, foreach) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

6. Döngüler (for, while, repeat-until)

Delphi programlama dilinde döngüler, belirli bir kod bloğunu tekrar tekrar çalıştırmak için kullanılan temel kontrol yapılarıdır. Bu döngüler, bir koşul doğru olduğu sürece veya belirli bir sayıda tekrar gerçekleşene kadar çalışmaya devam ederler. Delphi’de yaygın olarak kullanılan üç ana döngü türü vardır: for, while ve repeat-until. Bu makalede, bu döngülerin her birini ayrıntılı olarak inceleyeceğiz ve nasıl kullanılacaklarına dair örnekler sunacağız.

for Döngüsü

for döngüsü, belirli bir sayıda tekrar yapmak istediğimizde kullanılır. Genellikle bir sayaç değişkeni kullanılarak kontrol edilir.

for Döngüsünün Sözdizimi

for döngüsünün genel sözdizimi şu şekildedir:

for sayaç := başlangıç değeri to bitiş değeri do
begin
  // Tekrarlanacak kod bloğu
end;

Eğer sayaç değişkenini azaltarak döngü yapmak isterseniz downto anahtar kelimesini kullanabilirsiniz:

for sayaç := başlangıç değeri downto bitiş değeri do
begin
  // Tekrarlanacak kod bloğu
end;

for Döngüsü Örneği

Aşağıdaki örnek, 1’den 10’a kadar olan sayıları ekrana yazdırmak için for döngüsünü kullanır:

program ForDongusu;

{$APPTYPE CONSOLE}

var
  i: Integer;

begin
  for i := 1 to 10 do
  begin
    Writeln('Sayı: ', i);
  end;
  Readln;
end.

Bu kod, konsolda aşağıdaki çıktıyı üretir:

Sayı: 1
Sayı: 2
Sayı: 3
Sayı: 4
Sayı: 5
Sayı: 6
Sayı: 7
Sayı: 8
Sayı: 9
Sayı: 10

while Döngüsü

while döngüsü, belirli bir koşul doğru olduğu sürece bir kod bloğunu çalıştırmak için kullanılır. Koşul döngünün başında kontrol edilir, bu nedenle eğer koşul başlangıçta yanlışsa döngü hiç çalışmaz.

while Döngüsünün Sözdizimi

while döngüsünün genel sözdizimi şu şekildedir:

while koşul do
begin
  // Tekrarlanacak kod bloğu
end;

while Döngüsü Örneği

Aşağıdaki örnek, bir sayacın değeri 5’ten küçük olduğu sürece ekrana sayacı yazdırmak için while döngüsünü kullanır:

program WhileDongusu;

{$APPTYPE CONSOLE}

var
  sayac: Integer;

begin
  sayac := 1;
  while sayac < 5 do
  begin
    Writeln('Sayaç değeri: ', sayac);
    sayac := sayac + 1;
  end;
  Readln;
end.

Bu kod, konsolda aşağıdaki çıktıyı üretir:

Sayaç değeri: 1
Sayaç değeri: 2
Sayaç değeri: 3
Sayaç değeri: 4

repeat-until Döngüsü

repeat-until döngüsü, bir kod bloğunu en az bir kez çalıştırmak ve ardından bir koşul yanlış olana kadar tekrar çalıştırmak için kullanılır. Koşul döngünün sonunda kontrol edilir, bu nedenle döngü içindeki kod bloğu en az bir kez çalışır.

repeat-until Döngüsünün Sözdizimi

repeat-until döngüsünün genel sözdizimi şu şekildedir:

repeat
  // Tekrarlanacak kod bloğu
until koşul;

repeat-until Döngüsü Örneği

Aşağıdaki örnek, bir sayacın değeri 5’ten büyük veya eşit olana kadar ekrana sayacı yazdırmak için repeat-until döngüsünü kullanır:

program RepeatUntilDongusu;

{$APPTYPE CONSOLE}

var
  sayac: Integer;

begin
  sayac := 1;
  repeat
    Writeln('Sayaç değeri: ', sayac);
    sayac := sayac + 1;
  until sayac >= 5;
  Readln;
end.

Bu kod, konsolda aşağıdaki çıktıyı üretir:

Sayaç değeri: 1
Sayaç değeri: 2
Sayaç değeri: 3
Sayaç değeri: 4
Sayaç değeri: 5

Döngü Kontrol İfadeleri: break ve continue

Delphi, döngülerin akışını kontrol etmek için iki önemli ifade sunar: break ve continue.

break İfadesi

break ifadesi, döngüyü anında sonlandırır ve döngüden sonraki ilk ifadeye geçilir. Bu, belirli bir koşul karşılandığında döngüyü erken sonlandırmak için kullanışlıdır.

program BreakOrnegi;
{$APPTYPE CONSOLE}
var
  i: Integer;
begin
  for i := 1 to 10 do
  begin
    if i = 5 then
      break; // Döngüyü sonlandır
    Writeln('Sayı: ', i);
  end;
  Writeln('Döngü tamamlandı.');
  Readln;
end.

Bu örnekte, i değeri 5 olduğunda break ifadesi çalışır ve döngü sonlanır. Çıktı aşağıdaki gibi olacaktır:

Sayı: 1
Sayı: 2
Sayı: 3
Sayı: 4
Döngü tamamlandı.

continue İfadesi

continue ifadesi, döngünün mevcut iterasyonunu atlar ve bir sonraki iterasyona geçer. Bu, belirli bir koşul karşılandığında döngü içindeki belirli bir kod bloğunu atlamak için kullanışlıdır.

program ContinueOrnegi;
{$APPTYPE CONSOLE}
var
  i: Integer;
begin
  for i := 1 to 10 do
  begin
    if i mod 2 = 0 then
      continue; // Mevcut iterasyonu atla (çift sayıları atla)
    Writeln('Sayı: ', i);
  end;
  Writeln('Döngü tamamlandı.');
  Readln;
end.

Bu örnekte, i değeri çift sayı olduğunda continue ifadesi çalışır ve o iterasyon atlanır. Çıktı aşağıdaki gibi olacaktır:

Sayı: 1
Sayı: 3
Sayı: 5
Sayı: 7
Sayı: 9
Döngü tamamlandı.

İç İçe Döngüler

Delphi’de, döngülerin içine başka döngüler yerleştirmek mümkündür. Bu tür yapılara iç içe döngüler denir. İç içe döngüler, iki veya daha fazla boyutlu veri yapılarını işlemek veya karmaşık algoritmaları uygulamak için kullanışlıdır.

program IcIceDonguler;
{$APPTYPE CONSOLE}
var
  i, j: Integer;
begin
  for i := 1 to 3 do
  begin
    for j := 1 to 3 do
    begin
      Writeln('i = ', i, ', j = ', j);
    end;
  end;
  Readln;
end.

Bu örnek, 1’den 3’e kadar olan i ve j değerlerini kullanarak iç içe for döngülerini gösterir. Çıktı aşağıdaki gibi olacaktır:

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3

Sonuç

Delphi’de döngüler, programlamanın temel bir parçasıdır ve kodunuzun verimli ve etkili bir şekilde çalışmasını sağlamak için önemlidir. for, while ve repeat-until döngüleri, farklı senaryolarda kullanılabilecek güçlü araçlardır. Ayrıca, break ve continue ifadeleri ile döngülerin akışını daha da kontrol edebilirsiniz. Bu döngüleri ve kontrol ifadelerini iyi anlamak, daha karmaşık ve güçlü Delphi uygulamaları geliştirmenize yardımcı olacaktır.

Bu makalede, Delphi’deki döngülerin temel kavramlarını ve kullanımlarını ele aldık. Umarım bu bilgiler, Delphi programlama becerilerinizi geliştirmenize yardımcı olur.

6. Döngüler (for, while, repeat-until) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

7. Döngüler (for, while, do-while, foreach)

Java programlama dilinde, döngüler, belirli bir kod bloğunu tekrar tekrar çalıştırmak için kullanılan temel kontrol yapılarından biridir. Döngüler, aynı işlemi birden çok kez yapmanız gerektiğinde kodunuzu daha verimli ve okunaklı hale getirir. Bu makalede, Java’da bulunan başlıca döngü türlerini (for, while, do-while ve foreach) ayrıntılı olarak inceleyeceğiz ve örneklerle nasıl kullanıldıklarını göstereceğiz.

Döngülerin Önemi

Döngüler, programlamanın temel taşlarından biridir. Tekrarlayan görevleri otomatikleştirerek kod yazma sürecini hızlandırır ve karmaşıklığı azaltır. Örneğin, bir dizideki tüm elemanları yazdırmak, bir listedeki verileri işlemek veya belirli bir koşul sağlanana kadar bir işlemi sürdürmek gibi birçok senaryoda döngülere ihtiyaç duyulur.

for Döngüsü

for döngüsü, belirli bir sayıda tekrar yapmak istediğinizde idealdir. Başlangıç değeri, döngü koşulu ve artırma/azaltma ifadesi olmak üzere üç ana bölümden oluşur.

for Döngüsünün Sözdizimi

for (başlangıç; koşul; artırma/azaltma) {
  // Tekrar edilecek kod bloğu
}

• Başlangıç: Döngü değişkenini tanımlar ve başlangıç değerini atar. Bu bölüm döngünün başında yalnızca bir kez çalışır.
• Koşul: Döngünün devam edip etmeyeceğini belirleyen bir boolean ifadesidir. Koşul doğru (true) olduğu sürece döngü çalışmaya devam eder.
• Artırma/Azaltma: Döngü değişkeninin değerini her yinelemede günceller. Bu bölüm, döngüdeki kod bloğu çalıştıktan sonra çalışır.

for Döngüsü Örneği

Aşağıdaki örnek, 1’den 10’a kadar olan sayıları ekrana yazdırır:

public class ForLoopExample {
  public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
      System.out.println(i);
    }
  }
}

while Döngüsü

while döngüsü, belirli bir koşul doğru olduğu sürece bir kod bloğunu tekrar tekrar çalıştırmak için kullanılır. Döngü koşulu, döngü başlamadan önce kontrol edilir. Eğer koşul başlangıçta yanlışsa (false), döngü hiç çalışmaz.

while Döngüsünün Sözdizimi

while (koşul) {
  // Tekrar edilecek kod bloğu
}

while Döngüsü Örneği

Aşağıdaki örnek, bir sayacın değerini 5’ten 1’e düşürür ve her adımda değeri ekrana yazdırır:

public class WhileLoopExample {
  public static void main(String[] args) {
    int sayac = 5;
    while (sayac >= 1) {
      System.out.println(sayac);
      sayac--;
    }
  }
}

do-while Döngüsü

do-while döngüsü, while döngüsüne benzer, ancak döngü koşulu, döngü bloğu çalıştıktan sonra kontrol edilir. Bu, döngü bloğunun en az bir kez çalışmasını garanti eder.

do-while Döngüsünün Sözdizimi

do {
  // Tekrar edilecek kod bloğu
} while (koşul);

do-while Döngüsü Örneği

Aşağıdaki örnek, kullanıcıdan bir sayı girmesini ister ve sayı 0’dan küçük olduğu sürece tekrar sorar:

import java.util.Scanner;

public class DoWhileLoopExample {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int sayi;
    do {
      System.out.print("Lütfen 0'dan büyük bir sayı girin: ");
      sayi = scanner.nextInt();
    } while (sayi <= 0);
    System.out.println("Girilen sayı: " + sayi);
  }
}

foreach Döngüsü (Gelişmiş for Döngüsü)

foreach döngüsü, diziler ve koleksiyonlar gibi veri yapıları üzerinde iterasyon yapmak için kullanılır. Her elemanı tek tek işlemek için kolay ve okunaklı bir yol sağlar. Java’da, for-each döngüsü olarak da bilinir.

foreach Döngüsünün Sözdizimi

for (veriTipi eleman : diziVeyaKoleksiyon) {
  // Eleman üzerinde yapılacak işlemler
}

• veriTipi: Dizideki veya koleksiyondaki elemanların veri türü.
• eleman: Diziden veya koleksiyondan alınan her bir elemanı temsil eden değişken.
• diziVeyaKoleksiyon: Üzerinde iterasyon yapılacak dizi veya koleksiyon.

foreach Döngüsü Örneği

Aşağıdaki örnek, bir string dizisindeki tüm elemanları ekrana yazdırır:

public class ForeachLoopExample {
  public static void main(String[] args) {
    String[] meyveler = {"Elma", "Armut", "Muz", "Çilek"};
    for (String meyve : meyveler) {
      System.out.println(meyve);
    }
  }
}

Döngü Kontrol İfadeleri: break ve continue

Döngülerin akışını kontrol etmek için break ve continue ifadeleri kullanılabilir.

break İfadesi

break ifadesi, döngüyü tamamen sonlandırır ve döngüden sonraki ilk ifadeye geçilir.

continue İfadesi

continue ifadesi, döngünün mevcut iterasyonunu atlar ve bir sonraki iterasyona geçer.

Örnek

public class LoopControlExample {
  public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
      if (i == 5) {
        break; // Döngüyü sonlandırır
      }
      if (i % 2 == 0) {
        continue; // Mevcut iterasyonu atlar
      }
      System.out.println(i);
    }
    System.out.println("Döngü sona erdi.");
  }
}

Bu örnekte, break ifadesi i 5 olduğunda döngüyü sonlandırırken, continue ifadesi çift sayıları atlar.

Sonuç

Java’da döngüler, tekrar eden görevleri verimli bir şekilde yönetmek için güçlü araçlardır. for, while, do-while ve foreach döngüleri, farklı senaryolara uygun çözümler sunar. Döngülerin nasıl çalıştığını anlamak ve uygun döngü türünü seçmek, daha temiz, daha okunaklı ve daha verimli kod yazmanıza yardımcı olur. break ve continue ifadeleri ile döngülerin akışını daha da kontrol edebilirsiniz.

7. Döngüler (for, while, do-while, foreach) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.