Operatörler

BERK'te çeşitli operatörler matematiksel işlemler, karşılaştırmalar ve mantıksal işlemler için kullanılır.

Aritmetik Operatörler

Temel İşlemler

değişken a = 10
değişken b = 3

yazdır(a + b)   // 13 - Toplama
yazdır(a - b)   // 7  - Çıkarma
yazdır(a * b)   // 30 - Çarpma
yazdır(a / b)   // 3  - Bölme (tamsayı)
yazdır(a % b)   // 1  - Mod (kalan)
yazdır(a ** b)  // 1000 - Üs alma

Ondalık Bölme

değişken x = 10.0
değişken y = 3.0

yazdır(x / y)   // 3.333333 - Ondalık bölme

Unary Operatörler

değişken n = 5

yazdır(+n)  // 5  - Pozitif işareti
yazdır(-n)  // -5 - Negatif işareti
yazdır(++n) // 6  - Ön artırma
yazdır(n++) // 6  - Son artırma (7 olur)
yazdır(--n) // 6  - Ön azaltma
yazdır(n--) // 6  - Son azaltma (5 olur)

Karşılaştırma Operatörleri

değişken a = 10
değişken b = 5

yazdır(a == b)  // yanlış - Eşit mi
yazdır(a != b)  // doğru  - Eşit değil mi
yazdır(a > b)   // doğru  - Büyük mü
yazdır(a < b)   // yanlış - Küçük mü
yazdır(a >= b)  // doğru  - Büyük eşit mi
yazdır(a <= b)  // yanlış - Küçük eşit mi

Mantıksal Operatörler

değişken x = doğru
değişken y = yanlış

yazdır(x && y)  // yanlış - VE (AND)
yazdır(x || y)  // doğru  - VEYA (OR)
yazdır(!x)      // yanlış - DEĞİL (NOT)

Short-Circuit Evaluation

// İkinci ifade değerlendirilmez
eğer (x || çağır_fonksiyon()) {
    // x doğru ise çağır_fonksiyon() çalıştırılmaz
}

// İkinci ifade değerlendirilir
eğer (x && çağır_fonksiyon()) {
    // x yanlış ise çağır_fonksiyon() çalıştırılmaz
}

Atama Operatörleri

Basit Atama

değişken x = 10
x = 20  // Yeni değer atama

Bileşik Atama

değişken n = 10

n += 5   // n = n + 5  (15)
n -= 3   // n = n - 3  (12)
n *= 2   // n = n * 2  (24)
n /= 4   // n = n / 4  (6)
n %= 5   // n = n % 5  (1)
n **= 3  // n = n ** 3 (1)

Çoklu Atama

değişken a, b, c = 1, 2, 3
yazdır(a, b, c)  // 1 2 3

// Değer takası (swap)
a, b = b, a
yazdır(a, b)  // 2 1

Bitwise Operatörler

değişken a = 0b1010  // 10
değişken b = 0b1100  // 12

yazdır(a & b)   // 0b1000 (8)  - AND
yazdır(a | b)   // 0b1110 (14) - OR
yazdır(a ^ b)   // 0b0110 (6)  - XOR
yazdır(~a)      // 0b0101 (-11) - NOT
yazdır(a << 1)  // 0b10100 (20) - Sol kaydırma
yazdır(a >> 1)  // 0b0101 (5)   - Sağ kaydırma

String Operatörleri

Birleştirme

değişken ad = "Ahmet"
değişken soyad = "Yılmaz"

değişken tam_ad = ad + " " + soyad
yazdır(tam_ad)  // Ahmet Yılmaz

// Bileşik atama
değişken mesaj = "Merhaba "
mesaj += "Dünya"
yazdır(mesaj)  // Merhaba Dünya

Tekrarlama

değişken yıldız = "*" * 10
yazdır(yıldız)  // **********

Karşılaştırma

yazdır("abc" == "abc")   // doğru
yazdır("abc" < "abd")    // doğru (leksikografik)
yazdır("a" + "b" == "ab") // doğru

Range Operatörü

// Inclusive range (son dahil)
döngü i 1'den 5'e kadar {
    yazdır(i)  // 1, 2, 3, 4, 5
}

// Exclusive range (son hariç)
döngü i 1'den 5'e {
    yazdır(i)  // 1, 2, 3, 4
}

// Liste oluşturma
değişken sayılar = [1..10]  // [1, 2, 3, ..., 10]
değişken harfler = ['a'..'z']

Elvis Operatörü (Null Coalescing)

değişken değer: Sayı? = null

// Eğer null ise varsayılan değer kullan
değişken sonuç = değer ?: 0
yazdır(sonuç)  // 0

değer = 42
sonuç = değer ?: 0
yazdır(sonuç)  // 42

Safe Navigation Operatörü

değişken kullanıcı: Kullanıcı? = null

// Null kontrolü olmadan güvenli erişim
değişken email = kullanıcı?.email
// Eğer kullanıcı null ise email de null olur

// Zincirleme
değişken şehir = kullanıcı?.adres?.şehir?.ad

Pipeline Operatörü

// Fonksiyon zincirleme
değişken sonuç = [1, 2, 3, 4, 5]
    |> filtrele(x => x % 2 == 0)
    |> eşle(x => x * 2)
    |> azalt((a, b) => a + b)

yazdır(sonuç)  // 12 (2*2 + 4*2)

Spread Operatörü

// Liste spread
değişken liste1 = [1, 2, 3]
değişken liste2 = [4, 5, 6]
değişken birleşik = [...liste1, ...liste2]
yazdır(birleşik)  // [1, 2, 3, 4, 5, 6]

// Fonksiyon argümanı
işlev topla(a, b, c) -> Sayı {
    geri dön a + b + c
}

değişken args = [1, 2, 3]
yazdır(topla(...args))  // 6

Ternary Operatörü

değişken yaş = 18
değişken durum = yaş >= 18 ? "Yetişkin" : "Çocuk"
yazdır(durum)  // Yetişkin

// İç içe ternary
değişken not = 85
değişken harf = not >= 90 ? "A" :
                not >= 80 ? "B" :
                not >= 70 ? "C" : "F"
yazdır(harf)  // B

Type Check Operatörü

değişken değer: Any = "Hello"

eğer değer is Yazı {
    yazdır("Bu bir string")
}

eğer değer !is Sayı {
    yazdır("Bu bir sayı değil")
}

// Casting ile
değişken metin = değer as Yazı

In Operatörü

// Liste kontrol
değişken sayılar = [1, 2, 3, 4, 5]
eğer 3 in sayılar {
    yazdır("3 listede var")
}

// String kontrol
değişken metin = "Merhaba Dünya"
eğer "Dünya" in metin {
    yazdır("'Dünya' bulundu")
}

// Range kontrol
eğer 5 in 1..10 {
    yazdır("5 aralıkta")
}

// Map kontrol
değişken sözlük = {"ad": "Ahmet", "yaş": 30}
eğer "ad" in sözlük {
    yazdır("'ad' anahtarı var")
}

Operatör Önceliği

Yüksekten düşüğe:

Parantezle Öncelik Değiştirme

değişken a = 2 + 3 * 4      // 14 (çarpma önce)
değişken b = (2 + 3) * 4    // 20 (toplama önce)

değişken c = 10 / 2 + 3     // 8
değişken d = 10 / (2 + 3)   // 2

Özel Operatörler

Assert Operatörü

değişken x = 10
assert x > 0, "x pozitif olmalı"

// Eğer koşul yanlış ise program durur

Match Operatörü

değişken sayı = 2

değişken sonuç = sayı eş {
    1 => "bir",
    2 => "iki",
    3 => "üç",
    _ => "diğer"
}

yazdır(sonuç)  // iki

Best Practices

✅ Yapılması Gerekenler

// Karmaşık ifadelerde parantez kullan
değişken sonuç = (a + b) * (c - d)

// Short-circuit evaluation'dan faydalanın
eğer kullanıcı != null && kullanıcı.aktif {
    // ...
}

// Null-safe operatörler kullan
değişken email = kullanıcı?.email ?: "Bilinmiyor"

// Operatör etrafında boşluk
değişken toplam = a + b  // İyi
değişken toplam = a+b    // Okunabilir değil

❌ Kaçınılması Gerekenler

// Çok uzun ternary zincirleri
değişken x = a ? b ? c ? d : e : f : g  // Okunması zor

// Gereksiz karmaşık bitwise işlemler
değişken y = (a & b) | (~c ^ d)  // Ne yaptığı belli değil

// Yan etki yaratan operatörler
değişken z = x++ + ++x + x++  // Kafa karıştırıcı

Örnek: Çeşitli Operatörler

işlev ana() {
    // Aritmetik
    değişken toplam = 10 + 20
    değişken fark = 100 - 50
    değişken çarpım = 5 * 6
    değişken bölüm = 20 / 4
    
    // Karşılaştırma
    eğer toplam > fark {
        yazdır("Toplam daha büyük")
    }
    
    // Mantıksal
    değişken a = doğru
    değişken b = yanlış
    eğer a && !b {
        yazdır("Koşul sağlandı")
    }
    
    // String
    değişken mesaj = "Merhaba" + " " + "Dünya"
    
    // Null-safe
    değişken değer: Sayı? = null
    değişken sonuç = değer ?: 0
    
    yazdır("Tüm işlemler tamamlandı")
}

Bir Sonraki

• Kontrol Yapıları
• Fonksiyonlar