Bölüm 3 — Konu 10: Aritmetik, Atama, Karşılaştırma, Mantıksal Operatörler

Bölüm 3'e hoş geldin — bu bölümde gerçek anlamda "mantık kurmaya" başlıyoruz. İlk durağımız, tüm kontrol akışının (if, döngüler vb.) temelini oluşturan operatörler.

#1. Aritmetik Operatörler

void main() {
  int a = 10;
  int b = 3;

  print(a + b);  // 13 — toplama
  print(a - b);  // 7  — çıkarma
  print(a * b);  // 30 — çarpma
  print(a / b);  // 3.3333333333333335 — bölme, HER ZAMAN double döner
  print(a ~/ b); // 3  — tam sayı bölmesi (integer division)
  print(a % b);  // 1  — mod (kalan)
}

Bölüm 2'de ~/ ve %'e kısaca değinmiştik, burada pekiştirelim:

void main() {
  print(17 ~/ 5); // 3 — 17'nin 5'e tam bölümü
  print(17 % 5);  // 2 — kalan

  // Doğrulama: (bölüm * bölen) + kalan = orijinal sayı
  print((3 * 5) + 2); // 17 ✓
}

Artırma/Azaltma operatörleri:

void main() {
  int sayac = 5;

  sayac++; // sayac = sayac + 1
  print(sayac); // 6

  sayac--; // sayac = sayac - 1
  print(sayac); // 5

  print(sayac++); // 5 yazdırır, SONRA artırır (post-increment)
  print(sayac);   // 6

  print(++sayac); // ÖNCE artırır, SONRA 7 yazdırır (pre-increment)
  print(sayac);   // 7
}

Bu ++x ile x++ farkı sık karıştırılır: x++ önce mevcut değeri kullanır, sonra artırır. ++x önce artırır, sonra yeni değeri kullanır.

#2. Bileşik Atama Operatörleri (Compound Assignment)

void main() {
  int puan = 100;

  puan += 10; // puan = puan + 10
  print(puan); // 110

  puan -= 20; // puan = puan - 20
  print(puan); // 90

  puan *= 2;  // puan = puan * 2
  print(puan); // 180

  puan ~/= 3; // puan = puan ~/ 3
  print(puan); // 60
}

Bunlar, puan = puan + 10 yazmanın kısayoludur — Dart'a özgü değil, C ailesindeki hemen her dilde bulunur.

#3. Karşılaştırma Operatörleri

void main() {
  int a = 10;
  int b = 20;

  print(a == b); // false — eşit mi?
  print(a != b); // true  — eşit değil mi?
  print(a < b);  // true  — küçük mü?
  print(a > b);  // false — büyük mü?
  print(a <= b); // true  — küçük veya eşit mi?
  print(a >= b); // false — büyük veya eşit mi?
}

Bunların hepsi bir bool sonuç döndürür — bu yüzden genelde if koşullarında kullanılırlar (bir sonraki konuda işleyeceğiz).

Önemli detay — == ile nesne karşılaştırması:

void main() {
  String isim1 = "Ahmet";
  String isim2 = "Ahmet";
  print(isim1 == isim2); // true — içerik karşılaştırılır
}

Dart'ta == operatörü, ilkel tipler (int, double, String, bool) için içerik karşılaştırması yapar (Java'daki gibi referans karşılaştırması değil). Kendi yazacağın sınıflar için bu davranışı özelleştirebilirsin — bunu Bölüm 6'da göreceğiz.

#4. Mantıksal Operatörler

void main() {
  bool ogrenciMi = true;
  bool calisiyorMu = false;

  print(ogrenciMi && calisiyorMu); // false — VE (AND): ikisi de true olmalı
  print(ogrenciMi || calisiyorMu); // true  — VEYA (OR): en az biri true olmalı
  print(!ogrenciMi);               // false — DEĞİL (NOT): tersini alır
}

Kısa devre değerlendirmesi (Short-circuit evaluation):

bool pahaliIslem() {
  print("pahaliIslem çağrıldı");
  return true;
}

void main() {
  bool sonuc = false && pahaliIslem();
  // "pahaliIslem çağrıldı" YAZDIRILMAZ!
  // Çünkü && operatöründe sol taraf false ise, sağ taraf hiç değerlendirilmez

  print(sonuc); // false
}

Bu davranış önemli bir performans/mantık aracıdır: && operatöründe sol taraf false ise, Dart sağ tarafı hiç çalıştırmaz (çünkü sonucun zaten false olacağı belli). Benzer şekilde || operatöründe sol taraf true ise sağ taraf çalıştırılmaz.

Bu, null kontrolü gibi durumlarda pratik bir kullanım sağlar:

void main() {
  String? isim;

  if (isim != null && isim.length > 3) {
    print("Uzun isim");
  } else {
    print("Kısa isim veya null");
  }
}

isim != null false ise, isim.length > 3 kısmı hiç çalıştırılmaz — bu sayede isim null olsa bile hata almayız (eğer sıra tersine çevrilseydi, yani isim.length > 3 && isim != null yazsaydık, null olduğunda önce .length'e erişmeye çalışırdı ve hata verirdi).

#5. Operatör Önceliği (Precedence)

Matematikte olduğu gibi, Dart'ta da operatörlerin bir öncelik sırası vardır:

void main() {
  int sonuc = 2 + 3 * 4; // çarpma önce yapılır
  print(sonuc); // 14, (2 + (3*4)) — 20 değil!

  int sonuc2 = (2 + 3) * 4; // parantez önceliği değiştirir
  print(sonuc2); // 20
}

Genel öncelik sırası (yüksekten düşüğe, basitleştirilmiş):

1. () parantezler
2. !, ++, -- (unary operatörler)
3. *, /, ~/, %
4. +, -
5. <, >, <=, >=
6. ==, !=
7. &&
8. ||
9. ??
10. =, +=, -= vb. (atama operatörleri)

Pratik tavsiye: Öncelik sırasını ezbere bilmek yerine, karmaşık ifadelerde her zaman parantez kullan. Bu hem hatayı önler hem de kodu okuyan başka birinin niyetini yanlış anlamasını engeller:

// Belirsiz — önceliği bilmeyen biri yanlış anlayabilir
bool sonuc = a && b || c;

// Net — parantez ile niyet açık
bool sonuc2 = (a && b) || c;

#6. is ve is! — Tip Kontrolü Operatörleri

Bölüm 2'de kısaca gördüğümüz is operatörünü burada tam bir mantıksal operatör olarak da hatırlayalım:

void main() {
  Object deger = "Merhaba";

  print(deger is String);  // true
  print(deger is! String); // false — "değil" versiyonu
  print(deger is int);     // false
}

#🎯 Bu Dersten Çıkarılması Gerekenler

• Aritmetik: + - * / ~/ %, ~/ tam sayı bölmesi yapar, / her zaman double döner.
• x++ mevcut değeri kullanıp sonra artırır, ++x önce artırıp yeni değeri kullanır.
• Bileşik atama: += -= *= ~/= gibi kısayollar.
• Karşılaştırma: == != < > <= >=, hepsi bool döner.
• Mantıksal: && || !, kısa devre değerlendirmesi önemli bir davranıştır (null kontrollerinde kritik).
• Operatör önceliği matematikteki gibi işler — belirsiz durumlarda parantez kullan.

#📝 Ödevler

• [ ] İki sayı al (elle tanımla), tüm aritmetik operatörleri (+ - * / ~/ %) uygulayıp sonuçlarını yazdır.
• [ ] x++ ile ++x arasındaki farkı gösteren, aynı değişkeni her ikisiyle de kullanan bir örnek yaz.
• [ ] Kısa devre değerlendirmesini kanıtlayan bir örnek yaz: false && pahaliBirFonksiyon() çağrısında fonksiyonun hiç çalışmadığını print ile göster.
• [ ] Nullable bir değişkenle güvenli bir && zinciri kur (örn. isim != null && isim.length > 5), sırayı bilerek tersine çevirip hatayı gözlemle.
• [ ] Parantezsiz ve parantezli iki versiyonunu yazdığın bir ifadeyle (2 + 3 * 4 gibi) operatör önceliğinin sonucu nasıl değiştirdiğini göster.

Sıradaki konu: Bölüm 3 — Konu 11: if / else if / else