C# Programlama Dilinde Koşullu İfadeler (if-else, switch-case)

C# programlama dilinde, programların akışını kontrol etmek ve farklı durumlara göre farklı işlemler gerçekleştirmek için koşullu ifadeler kullanılır. Bu ifadeler, programın karar verme yeteneğini artırır ve daha karmaşık ve esnek uygulamalar geliştirmeyi mümkün kılar. En sık kullanılan koşullu ifadeler if-else ve switch-case yapısıdır. Bu makalede, bu yapıları detaylı bir şekilde inceleyeceğiz.

if-else İfadeleri

if-else ifadesi, bir koşulun doğru (true) veya yanlış (false) olmasına göre farklı kod bloklarını çalıştırmak için kullanılır. Temel sözdizimi şu şekildedir:

if (koşul)
{
    // Koşul doğru ise çalışacak kod bloğu
}
else
{
    // Koşul yanlış ise çalışacak kod bloğu
}

Burada koşul, bir boolean ifade olmalıdır. Eğer koşul doğru ise, if bloğu içindeki kod çalışır; aksi takdirde, eğer varsa else bloğu içindeki kod çalışır.

if İfadesi

Sadece bir koşulun doğruluğunu kontrol etmek ve eğer doğruysa bir kod bloğunu çalıştırmak istiyorsak, sadece if ifadesini kullanabiliriz. Örneğin:

int sayi = 10;
if (sayi > 0)
{
    Console.WriteLine("Sayı pozitiftir.");
}

Bu örnekte, sayi değişkeninin değeri 0’dan büyükse, ekrana “Sayı pozitiftir.” yazdırılır.

else İfadesi

Bir koşulun yanlış olması durumunda da bir işlem yapmak istiyorsak, else ifadesini kullanırız. Örneğin:

int sayi = -5;
if (sayi > 0)
{
    Console.WriteLine("Sayı pozitiftir.");
}
else
{
    Console.WriteLine("Sayı negatif veya sıfırdır.");
}

Bu örnekte, sayi değişkeninin değeri 0’dan büyük değilse, ekrana “Sayı negatif veya sıfırdır.” yazdırılır.

else if İfadesi

Birden fazla koşulu kontrol etmek ve farklı koşullara göre farklı işlemler yapmak istiyorsak, else if ifadesini kullanırız. Örneğin:

int not = 75;

if (not >= 90)
{
    Console.WriteLine("A");
}
else if (not >= 80)
{
    Console.WriteLine("B");
}
else if (not >= 70)
{
    Console.WriteLine("C");
}
else if (not >= 60)
{
    Console.WriteLine("D");
}
else
{
    Console.WriteLine("F");
}

Bu örnekte, not değişkeninin değerine göre farklı notlar (A, B, C, D, F) ekrana yazdırılır. else if zinciri, yukarıdan aşağıya doğru koşulları kontrol eder ve ilk doğru olan koşulun bloğunu çalıştırır. Eğer hiçbir koşul doğru değilse, en sondaki else bloğu çalışır.

switch-case İfadesi

switch-case ifadesi, bir değişkenin değerine göre farklı kod bloklarını çalıştırmak için kullanılır. Özellikle, bir değişkenin birden fazla olası değeri olduğunda ve her bir değer için farklı bir işlem yapmak gerektiğinde kullanışlıdır. Temel sözdizimi şu şekildedir:

switch (değişken)
{
    case değer1:
        // değişken değeri değer1 ise çalışacak kod bloğu
        break;
    case değer2:
        // değişken değeri değer2 ise çalışacak kod bloğu
        break;
    ...
    default:
        // değişken değeri hiçbir case ile eşleşmezse çalışacak kod bloğu
        break;
}

Burada değişken, bir ifade veya değişken olabilir. case etiketleri, değişkenin olası değerlerini temsil eder. Eğer değişkenin değeri bir case etiketiyle eşleşirse, o case bloğu içindeki kod çalışır. break ifadesi, switch ifadesinden çıkılmasını sağlar. Eğer break ifadesi kullanılmazsa, eşleşen case bloğundan sonraki case blokları da çalıştırılır (fall-through). default etiketi, değişkenin değeri hiçbir case etiketiyle eşleşmezse çalışacak olan kod bloğunu belirtir.

Örneğin:

int gun = 3;
string gunAdi;

switch (gun)
{
    case 1:
        gunAdi = "Pazartesi";
        break;
    case 2:
        gunAdi = "Salı";
        break;
    case 3:
        gunAdi = "Çarşamba";
        break;
    case 4:
        gunAdi = "Perşembe";
        break;
    case 5:
        gunAdi = "Cuma";
        break;
    case 6:
        gunAdi = "Cumartesi";
        break;
    case 7:
        gunAdi = "Pazar";
        break;
    default:
        gunAdi = "Geçersiz gün numarası";
        break;
}

Console.WriteLine("Gün: " + gunAdi);

Bu örnekte, gun değişkeninin değerine göre haftanın gün adı belirlenir ve ekrana yazdırılır. Eğer gun değişkeninin değeri 1 ile 7 arasında değilse, default bloğu çalışır ve ekrana “Geçersiz gün numarası” yazdırılır.

Koşullu İfadelerin Önemi

Koşullu ifadeler, programlama dillerinin temel yapı taşlarından biridir ve programların karar verme yeteneğini sağlar. Bu sayede, programlar farklı durumlara uyum sağlayabilir, kullanıcı girdilerine göre farklı işlemler gerçekleştirebilir ve daha karmaşık algoritmalar uygulayabilir. if-else ve switch-case ifadeleri, C# programlama dilinde en sık kullanılan koşullu ifadelerdir ve programların akışını kontrol etmek için vazgeçilmez araçlardır.

Doğru ve etkili koşullu ifadeler kullanarak, daha okunabilir, bakımı kolay ve hatasız kodlar yazabilirsiniz. Bu nedenle, koşullu ifadelerin kullanımını iyi anlamak ve pratik yapmak, başarılı bir C# programcısı olmak için önemlidir.

Sonuç

Bu makalede, C# programlama dilinde kullanılan koşullu ifadelerden if-else ve switch-case yapılarını detaylı bir şekilde inceledik. Bu yapıların nasıl kullanıldığını, ne zaman tercih edildiğini ve programların akışını nasıl kontrol ettiğini öğrendik. Koşullu ifadeler, programlama becerilerinizi geliştirmenize ve daha karmaşık uygulamalar oluşturmanıza yardımcı olacaktır.

“Koşullu ifadeler, programların karar verme mekanizmalarını oluşturur ve onları daha akıllı hale getirir.” – Bilge Programcı

6. Koşullu İfadeler (if-else, switch-case) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

5. Koşullu İfadeler (if-else, case of)

Delphi programlama dilinde, program akışını kontrol etmek ve farklı durumlara göre farklı işlemler yapmak için koşullu ifadeler kullanılır. En yaygın kullanılan koşullu ifadeler if-else ve case of deyimleridir. Bu ifadeler, belirli bir koşulun doğru (True) veya yanlış (False) olmasına bağlı olarak farklı kod bloklarını çalıştırmayı sağlar.

if-else Deyimi

if-else deyimi, bir koşulun değerlendirilmesi ve sonucuna göre farklı kod bloklarının çalıştırılması için kullanılır. if anahtar kelimesi, bir koşulu belirtir. Eğer bu koşul doğruysa, then anahtar kelimesinden sonra gelen kod bloğu çalıştırılır. Eğer koşul yanlışsa, else anahtar kelimesinden sonra gelen kod bloğu çalıştırılır. else bloğu opsiyoneldir, yani sadece koşulun yanlış olduğu durumda yapılacak bir işlem yoksa kullanılmayabilir.

if Deyiminin Temel Yapısı

if deyiminin temel yapısı aşağıdaki gibidir:

if koşul then
begin
  // Koşul doğruysa yapılacak işlemler
end;

Eğer sadece tek bir işlem yapılacaksa, begin ve end blokları kullanılmayabilir. Ancak okunabilirliği artırmak ve olası hataları önlemek için blok kullanılması önerilir.

else Deyiminin Kullanımı

else deyimi, koşulun yanlış olduğu durumda yapılacak işlemleri belirtir. Yapısı aşağıdaki gibidir:

if koşul then
begin
  // Koşul doğruysa yapılacak işlemler
end
else
begin
  // Koşul yanlışsa yapılacak işlemler
end;

İç İçe if Deyimleri (Nested if)

if deyimleri iç içe kullanılabilir. Bu, daha karmaşık koşulları değerlendirmek için kullanışlıdır. Örneğin:

if koşul1 then
begin
  if koşul2 then
  begin
    // koşul1 ve koşul2 doğruysa yapılacak işlemler
  end
  else
  begin
    // koşul1 doğru, koşul2 yanlışsa yapılacak işlemler
  end;
end
else
begin
  // koşul1 yanlışsa yapılacak işlemler
end;

Örnek: if-else Kullanımı

Aşağıdaki örnekte, bir sayının pozitif, negatif veya sıfır olup olmadığını kontrol eden bir if-else yapısı gösterilmektedir:

var
  sayi: Integer;
begin
  sayi := -5;

  if sayi > 0 then
    ShowMessage('Sayı pozitif')
  else if sayi < 0 then
    ShowMessage('Sayı negatif')
  else
    ShowMessage('Sayı sıfır');
end;

case of Deyimi

case of deyimi, bir değişkenin değerine göre farklı kod bloklarını çalıştırmak için kullanılır. Özellikle, bir değişkenin birçok farklı olası değeri varsa ve her bir değer için farklı bir işlem yapılması gerekiyorsa, if-else yapısına göre daha okunabilir ve yönetilebilir bir alternatif sunar.

case of Deyiminin Temel Yapısı

case of deyiminin temel yapısı aşağıdaki gibidir:

case değişken of
  değer1: begin
    // değişken değeri değer1 ise yapılacak işlemler
  end;
  değer2: begin
    // değişken değeri değer2 ise yapılacak işlemler
  end;
  else
  begin
    // Değişken hiçbir değerle eşleşmiyorsa yapılacak işlemler (opsiyonel)
  end;
end;

Her bir değer için ayrı bir kod bloğu belirtilir. Eğer değişkenin değeri, belirtilen değerlerden biriyle eşleşirse, o değere karşılık gelen kod bloğu çalıştırılır. else bloğu, değişkenin hiçbir değerle eşleşmediği durumda çalıştırılacak olan kod bloğunu belirtir. else bloğu opsiyoneldir.

Örnek: case of Kullanımı

Aşağıdaki örnekte, bir harfin sesli veya sessiz olup olmadığını kontrol eden bir case of yapısı gösterilmektedir:

var
  harf: Char;
begin
  harf := 'a';

  case harf of
    'a', 'e', 'i', 'o', 'u': ShowMessage('Sesli harf');
    else ShowMessage('Sessiz harf');
  end;
end;

Bu örnekte, harf değişkeninin değeri ‘a’, ‘e’, ‘i’, ‘o’ veya ‘u’ ise, ekrana ‘Sesli harf’ mesajı yazdırılır. Aksi takdirde, ‘Sessiz harf’ mesajı yazdırılır.

if-else mi, case of mu?

if-else ve case of deyimleri, koşullu ifadeler için farklı yaklaşımlar sunar. Hangi deyimin kullanılacağı, duruma göre değişir. Genel olarak:

• Eğer sadece bir veya iki koşul varsa, if-else deyimi daha uygun olabilir.
• Eğer birden fazla koşul varsa ve değişkenin değeri birçok farklı olası değere sahipse, case of deyimi daha okunabilir ve yönetilebilir bir çözüm sunar.
• Eğer koşullar karmaşık mantıksal ifadeler içeriyorsa (örneğin, birden fazla değişkenin karşılaştırılması gerekiyorsa), if-else deyimi daha esnek olabilir.

Önemli olan, kodun okunabilirliğini ve anlaşılabilirliğini artırmaktır. Hangi deyimin daha uygun olduğuna karar verirken, bu faktörleri göz önünde bulundurmak önemlidir.

“Doğru koşullu ifade seçimi, kodunuzun sadece daha verimli değil, aynı zamanda daha anlaşılır olmasını sağlar. Delphi’de, her aracın avantajlarını bilerek doğru kararı vermek, iyi bir programcının işaretidir.”

Sonuç

if-else ve case of deyimleri, Delphi programlama dilinde program akışını kontrol etmek ve farklı durumlara göre farklı işlemler yapmak için kullanılan temel araçlardır. Bu ifadelerin doğru kullanımı, daha esnek, okunabilir ve yönetilebilir kodlar yazmanızı sağlar. Her iki deyimin de avantajlarını ve dezavantajlarını bilerek, projenizin gereksinimlerine en uygun olanı seçmek önemlidir.

5. Koşullu İfadeler (if-else, case of) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

6. Koşullu İfadeler (if-else, switch-case)

Java’da, programların akışını kontrol etmek ve belirli koşullara göre farklı kod bloklarını çalıştırmak için koşullu ifadeler kullanılır. Bu ifadeler, programların karar verme yeteneğini geliştirerek daha karmaşık ve dinamik uygulamalar oluşturulmasına olanak tanır. Bu makalede, Java’daki temel koşullu ifadeleri (if-else ve switch-case) ayrıntılı olarak inceleyeceğiz.

if-else İfadeleri

if-else ifadeleri, belirli bir koşulun doğru (true) veya yanlış (false) olmasına göre farklı kod bloklarını çalıştırmak için kullanılır. Temel sözdizimi aşağıdaki gibidir:

if (koşul) {
    // Koşul doğruysa çalışacak kod
} else {
    // Koşul yanlışsa çalışacak kod
}

Burada, koşul bir boolean ifade olmalıdır. Eğer koşul doğruysa, if bloğundaki kod çalıştırılır; aksi takdirde, else bloğundaki kod çalıştırılır. else bloğu isteğe bağlıdır.

Basit if Örneği

int x = 10;
if (x > 5) {
    System.out.println("x 5'ten büyüktür");
}

Bu örnekte, x değişkeninin değeri 5’ten büyük olduğu için, ekrana “x 5’ten büyüktür” yazdırılır.

if-else Örneği

int x = 3;
if (x > 5) {
    System.out.println("x 5'ten büyüktür");
} else {
    System.out.println("x 5'ten küçük veya eşittir");
}

Bu örnekte, x değişkeninin değeri 5’ten küçük olduğu için, ekrana “x 5’ten küçük veya eşittir” yazdırılır.

if-else if-else Zinciri

Birden fazla koşulu kontrol etmek için if-else if-else zinciri kullanılabilir. Bu yapı, koşullar sırayla kontrol edilir ve ilk doğru olan koşulun bloğu çalıştırılır. Hiçbir koşul doğru değilse, else bloğu (varsa) çalıştırılır.

int x = 75;

if (x >= 90) {
    System.out.println("Not: A");
} else if (x >= 80) {
    System.out.println("Not: B");
} else if (x >= 70) {
    System.out.println("Not: C");
} else if (x >= 60) {
    System.out.println("Not: D");
} else {
    System.out.println("Not: F");
}

Bu örnekte, x değişkeninin değeri 75 olduğu için, ekrana “Not: C” yazdırılır.

switch-case İfadeleri

switch-case ifadeleri, bir değişkenin değerine göre farklı kod bloklarını çalıştırmak için kullanılır. Özellikle, bir değişkenin birden çok olası değerine göre farklı işlemler yapmak gerektiğinde kullanışlıdır.

switch (değişken) {
    case değer1:
        // değişken değeri değer1'e eşitse çalışacak kod
        break;
    case değer2:
        // değişken değeri değer2'ye eşitse çalışacak kod
        break;
    ...
    default:
        // değişken hiçbir değere eşit değilse çalışacak kod
}

Burada, değişken bir byte, short, int, char, enum veya String türünde olabilir. Her case etiketi, değişken‘in olası bir değerini temsil eder. Eğer değişken‘in değeri bir case etiketindeki değerle eşleşirse, o case bloğundaki kod çalıştırılır. break ifadesi, o case bloğunun sonunu işaret eder ve switch ifadesinden çıkılmasını sağlar. Eğer break ifadesi kullanılmazsa, bir sonraki case bloğu da çalıştırılır (fall-through). default etiketi, değişken‘in hiçbir case etiketindeki değerle eşleşmediği durumlarda çalışacak kodu belirtir. default etiketi isteğe bağlıdır.

switch-case Örneği

int day = 3;
String dayName;

switch (day) {
    case 1:
        dayName = "Pazartesi";
        break;
    case 2:
        dayName = "Salı";
        break;
    case 3:
        dayName = "Çarşamba";
        break;
    case 4:
        dayName = "Perşembe";
        break;
    case 5:
        dayName = "Cuma";
        break;
    case 6:
        dayName = "Cumartesi";
        break;
    case 7:
        dayName = "Pazar";
        break;
    default:
        dayName = "Geçersiz gün";
}

System.out.println("Gün: " + dayName);

Bu örnekte, day değişkeninin değeri 3 olduğu için, ekrana “Gün: Çarşamba” yazdırılır.

Fall-Through Durumu

switch-case ifadelerinde break ifadesinin kullanılmaması durumunda, bir sonraki case bloğu da çalıştırılır. Bu duruma fall-through denir. Bazen bu özellik, birden fazla değer için aynı kodu çalıştırmak istediğimizde faydalı olabilir.

int month = 2;
int daysInMonth;

switch (month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        daysInMonth = 31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        daysInMonth = 30;
        break;
    case 2:
        daysInMonth = 28; // Artık yıl kontrolü yapılmadı
        break;
    default:
        daysInMonth = 0;
}

System.out.println("Ayın gün sayısı: " + daysInMonth);

Bu örnekte, birden fazla ay için aynı sayıda gün sayısı olduğundan, break ifadeleri atlanarak fall-through özelliği kullanılmıştır.

Koşullu İfadelerde Dikkat Edilmesi Gerekenler

• if ifadesinin koşulu her zaman bir boolean ifade olmalıdır.
• switch-case ifadesinde, break ifadesinin unutulması fall-through durumuna yol açabilir.
• switch-case ifadesinde, default etiketi isteğe bağlıdır, ancak kullanılmadığında beklenmedik sonuçlar ortaya çıkabilir.
• Karmaşık koşullu ifadeler yerine, kodu daha okunabilir hale getirmek için fonksiyonlar kullanılabilir.

Sonuç

Java’daki koşullu ifadeler (if-else ve switch-case), programların karar verme yeteneğini geliştirerek daha karmaşık ve dinamik uygulamalar oluşturulmasına olanak tanır. Bu ifadelerin doğru kullanımı, programların daha esnek ve kullanıcı dostu olmasını sağlar. Bu makalede, koşullu ifadelerin temel kavramları, sözdizimi ve örnek kullanımları ayrıntılı olarak açıklanmıştır. Pratik yaparak ve farklı senaryoları deneyerek, bu ifadeleri daha iyi anlayabilir ve programlama becerilerinizi geliştirebilirsiniz.

6. Koşullu İfadeler (if-else, switch-case) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.