2. Temel sözdizimi

Değişken · tür · işleç · koşul · döngü · fonksiyon. Bu sayfayı bitirdiğinizde dilin iskeletini biliyor olacaksınız.

Girinti blokları tanımlar

KabaLang'de blok açan her satır : ile biter, gövdesi girintilidir (4 boşluk önerilir). Süslü parantez yoktur.

eger 2 > 1:
    yazdir("içerideyim")
yazdir("dışarıdayım")

Değişkenler ve temel türler

Tür yazmanız gerekmez; değerden anlaşılır.

ad    = "Deniz"        # metin
yas   = 30             # sayi   (tam sayı)
boy   = 1.78           # ondalik
aktif = dogru          # mantik (dogru / yanlis)

yazdir(f"{ad} {yas} {boy} {aktif}")

# Türler arası dönüşüm açıkça yapılır:
dogrula(sayi("42") == 42, "metinden sayıya")
dogrula(metin(42) == "42", "sayıdan metne")
dogrula(ondalik("2.5") + 0.5 == 3.0, "metinden ondalığa")
dogrula(sayi("3.9") == 3, "ondalık metin sayi(3.9) gibi kırpılır")

Sayı olmayan bir metni (sayi("abc"), sayi("")) çevirmek çalışma hatasıdır — eskiden sessizce 0 dönüyordu. Kullanıcı girdisi gibi çevrilemeyebilecek metinler için konsol.sayi_coz(m) / konsol.ondalik_coz(m) kullanın: belki döner, bos_mu() ile denetlenir.

Uzun sayılarda basamakları _ ile gruplayabilirsiniz; değer değişmez:

nufus = 85_000_000
oran = 1_000.5
dogrula(nufus == 85000000, "rakam ayırıcı")
dogrula(oran * 2 == 2001.0, "ondalıkta da")

İsterseniz türü açıkça de yazabilirsiniz; derleyici o zaman denetler:

fonksiyon topla(a: sayi, b: sayi) -> sayi:
    don a + b

dogrula(topla(2, 3) == 5, "topla")
yazdir("tip bildirimi çalışıyor")

İşleçler

dogrula(7 + 2 == 9,   "toplama")
dogrula(7 - 2 == 5,   "çıkarma")
dogrula(7 * 2 == 14,  "çarpma")
dogrula(7 // 2 == 3,  "tam bölme")
dogrula(7 % 2 == 1,   "kalan")
dogrula(2 ** 10 == 1024, "üs")

dogrula((3 > 2) ve (2 > 1), "ve")
dogrula((3 < 2) veya dogru, "veya")
dogrula(degil yanlis, "degil")

yazdir("işleçler tamam")

Mantık işleçleri sözcüktür: ve · veya · degil. &&, ||, ! yoktur.

Bileşik atama x op= y, x = x op y ile aynıdır: += -= *= /= %= //= **=.

x = 10
x %= 4
x **= 3
dogrula(x == 8, "bileşik atama")
o = 10.0
o /= 4
dogrula(o == 2.5, "ondalık bölme")

Bit işleçleri

Tam sayı (sayi, 64 bit, iki tümleyen) üzerinde simgeyle yazılır: & (ve), | (veya), ^ (özel veya), ~ (tümleyen), << ve >> (kaydırma; >> işareti korur). Öncelik Python'daki gibidir: + - kaydırmadan, kaydırma &'den, & ^'den, ^ |'dan, hepsi karşılaştırmadan önce bağlanır.

dogrula(12 & 10 == 8, "ve")
dogrula(12 | 10 == 14, "veya")
dogrula(12 ^ 10 == 6, "özel veya")
dogrula(~0 == -1, "tümleyen")
dogrula(1 << 10 == 1024, "sola kaydır")
dogrula(-16 >> 2 == -4, "sağa kaydır (işaret korunur)")

Bit işleçleri yalnız sayi alır; mantik için ve/veya/degil yazılır (dogru & yanlis derleme hatasıdır). Kaydırma miktarı 0..63 dışındaysa sabitte derleme hatası (KAYDIRMA_MIKTARI), değişkende çalışma zamanı hatasıdır.

Taşma: varsayılan durdurur, açıkça sarmak ya da denetlemek

+ - * taşarsa program durur (D5). Özet/sağlama toplamı gibi sarması istenen hesap ve taşmayı değer olarak ele almak için yerleşik işlevler:

dogrula(sarmali_topla(9223372036854775807, 1) == -9223372036854775807 - 1, "sarar")
t = denetimli_carp(3037000500, 3037000500)     # -> belki<sayi>
dogrula(degil t.var_mi(), "taştı → bos")
dogrula(denetimli_topla(2, 3).deger_veya(0) == 5, "taşmadı → dolu(5)")

sarmali_topla/cikar/carp ve denetimli_topla/cikar/carp vardır.

Değişkenin türü ilk atamada belirlenir. sayi başlamış bir değişkene ondalık değer yazmak (x = 10 · x /= 4) kesir kısmını sessizce kaybettireceği için derleme hatasıdır (ONDALIK_KIRPMA); ondalık tutacaksa x = 10.0 ile başlatın.

Koşul — eger / degilse

sicaklik = 31

eger sicaklik > 30:
    yazdir("Hava sıcak.")
degilse:
    yazdir("Hava serin.")

Çok basamaklı karar için degilse eger yazılır:

fonksiyon derece(n):
    eger n > 100:
        don "çok büyük"
    degilse eger n > 10:
        don "büyük"
    degilse eger n > 5:
        don "orta"
    degilse:
        don "küçük"

fonksiyon ana():
    yazdir(derece(7))
ana()

⚠️ Bu kılavuzun 2026-09-23'ten önceki sürümleri "degilse eger YOKTUR" diyordu; o eksik giderildi, yukarıdaki biçim bugün çalışır.

degilse: içine yeni bir eger yazmak da geçerlidir; ikisi aynı işi yapar:

n = 7

eger n > 10:
    yazdir("büyük")
degilse:
    eger n > 5:
        yazdir("orta")
    degilse:
        yazdir("küçük")

Döngü — iken

Koşul doğru olduğu sürece tekrar eder.

sayac = 1
iken sayac <= 5:
    yazdir(f"{sayac}. satır: " + "★".tekrarla(sayac))
    sayac = sayac + 1

Döngü — dongu ... icinde

Bir listenin ya da sayı aralığının üzerinde gezer.

sehirler = ["İstanbul", "Ankara", "İzmir"]
dongu sehir icinde sehirler:
    yazdir(f"şehir: {sehir}")

toplam = 0
dongu i icinde 1..5:          # 1, 2, 3, 4, 5 — üst sınır DAHİLDİR
    toplam = toplam + i
dogrula(toplam == 15, "1..5 toplamı 15 olmalı")

İndeks döngüsünde ..< üst sınırı hariç tutar — 0..<l.uzunluk() boş listede hiç dönmez, 0..n - 1 gibi tek-fazla hatasına yer bırakmaz. adim artışı belirler (azalan için eksi):

l = [10, 20, 30]
s = 0
dongu i icinde 0..<l.uzunluk():   # 0, 1, 2
    s = s + l[i]
dogrula(s == 60, "0..<n")

besler: liste<sayi> = []
dongu i icinde 0..20 adim 5:      # 0, 5, 10, 15, 20
    besler.ekle(i)
geri: liste<sayi> = []
dongu i icinde 10..0 adim -3:     # 10, 7, 4, 1
    geri.ekle(i)
dogrula(l[0..<2] == [10, 20], "dilimde de aynı anlam")

adim 0 derleme (değişkense çalışma zamanı) hatasıdır. adim yalnız döngü başlığında, aralıktan sonra sözcüktür; başka yerde sıradan bir addır.

Sıra numarası ile öğeyi, sözlükte anahtar ile değeri birlikte açmak için (ara liste kurulmaz):

urunler = ["klavye", "fare"]
dongu i, ad icinde urunler.numarali():     # (0, klavye), (1, fare)
    yazdir(f"{i + 1}. {ad}")

ayarlar = {"dil": "tr", "tema": "koyu"}
dongu k, v icinde ayarlar.ciftler():
    yazdir(f"{k} = {v}")

kir ve devam

toplam = 0
i = 0
iken i < 10:
    i = i + 1
    eger i % 2 == 0:
        devam          # bu turu atla
    eger i > 7:
        kir            # döngüden tümden çık
    toplam = toplam + i

dogrula(toplam == 16, f"1+3+5+7 = 16 bekleniyordu, {toplam} çıktı")
yazdir("döngü denetimi tamam")

İç içe döngüden tek adımda çıkmak için döngüye etiket verilir; kir ad / devam ad o döngüyü hedefler (bayrak değişkenine gerek kalmaz):

tablo = [[1, 2], [3, 99]]
konum = ""
dis: dongu satir icinde 0..<2:
    dongu sutun icinde 0..<2:
        eger tablo[satir][sutun] == 99:
            konum = f"{satir},{sutun}"
            kir dis
dogrula(konum == "1,1", "etiketli kir")

Etiket iken için de yazılır (ana: iken kosul:). Çevrede olmayan bir etiket derleme hatasıdır (DONGU_ETIKETI).

Fonksiyonlar

fonksiyon selam(ad: metin = "dünya") -> metin:
    don "merhaba " + ad

fonksiyon faktoriyel(n: sayi) -> sayi:
    eger n <= 1:
        don 1
    don n * faktoriyel(n - 1)

dogrula(selam() == "merhaba dünya", "varsayılan parametre")
dogrula(selam("KabaOS") == "merhaba KabaOS", "argümanlı çağrı")
dogrula(faktoriyel(5) == 120, "özyineleme")
yazdir("fonksiyonlar tamam")

• Dönüş: don (dondur DEĞİL).
• Parametre türü ve dönüş türü isteğe bağlıdır — yazarsanız denetlenir.
• Varsayılan değerli parametreler sondadır.

Fonksiyon ve dışarıdaki değişkenler — kuresel

Fonksiyon (ya da metot), kendisinden önce modül düzeyinde (fonksiyonların dışında) tanımlanmış bir değişkeni okuyabilir. O değişkene yazmak (=, +=, çoklu atama, döngü değişkeni olarak kullanmak) ise gövdenin başında kuresel ad bildirimi ister; bildirim yoksa derleme hatasıdır (KURESEL_BILDIRIMSIZ). Sebep: fonksiyonun dışarıdaki bir değeri sessizce değiştirmesi, programın başka bir yerinde iz sürülmesi zor bir yan etkidir (KARAR D10).

sayac = 0

fonksiyon arttir():
    sayac = sayac + 1      # 'sayac' fonksiyonun dışında tanımlı

arttir()

sayac = 0
oran = 3

fonksiyon arttir():
    kuresel sayac          # gövdenin İLK satırı; birden çoksa: kuresel a, b
    sayac = sayac + oran   # `oran` yalnız okunuyor — bildirim gerekmez

arttir()
arttir()
dogrula(sayac == 6, "kuresel ile modül düzeyindeki değer değişti")

# Çoğu zaman daha açık yol: değeri parametre olarak alıp `don` ile döndürmek.
fonksiyon artmis(n: sayi) -> sayi:
    don n + 1

sayac = artmis(sayac)
dogrula(sayac == 7, "parametre + don")
yazdir("kuresel tamam")

• kuresel yalnız fonksiyon gövdesinin başında yazılır; fonksiyon dışında, bir bloğun içinde ya da başka satırlardan sonra yazılırsa hata (KURESEL_YERI).
• Ad, fonksiyondan önce modül düzeyinde değer almış olmalı; yoksa KURESEL_TANIMSIZ. Parametreyle aynı ad olamaz (KURESEL_PARAMETRE).
• Etkilenmeyenler: aynı kapsamda yeniden atama (x = 5, sonra x = 10), self.alan = ..., listeye/sözlüğe yerinde yazma (l.ekle(x), d["k"] = v) ve olay işleyicileri (dugme.tiklandiginda:).
• Fonksiyondan sonra tanımlanan aynı adlı değişken fonksiyonu etkilemez: oradaki atama fonksiyonun kendi yerelidir.
• İç içe fonksiyonda bildirim her fonksiyonun kendisinde yazılır; dıştaki fonksiyonun kureseli içtekine geçmez.

Tek satırlık fonksiyon

kare = (x) => x * x
dogrula(kare(6) == 36, "tek satırlık fonksiyon")
yazdir("tek satırlık fonksiyon tamam")

Kapanış — çok satırlı ve kaçan anonim fonksiyon

=>'dan sonra satır biterse gövde girintili bloktur. Anonim fonksiyon dışarıdaki değişkenleri değerle yakalar (oluşturulduğu andaki değer) ve fonksiyondan döndürülebilir:

fonksiyon carpan(k: sayi):
    don (x) => x * k          # k kapanışla birlikte yaşar

ikiyle = carpan(2)
dogrula(ikiyle(5) == 10, "kaçan kapanış")

onek = "Sn. "
selamla = (ad) =>
    tam = onek + ad
    don tam + "!"
onek = "Dr. "                 # yakalama değerledir: kapanış "Sn. " gördü
dogrula(selamla("Ali") == "Sn. Ali!", "değerle yakalama")

Yakalanan bir adı kapanışın içinde değiştirmek derleme hatasıdır (KAPANIS_YAZMA) — yeni değeri döndürün. Çok satırlı gövde bir çağrının parantezi içinde yazılamaz (satırlar parantez içinde birleşir): kapanışı önce bir ada atayın, sonra adı geçirin.

main yok — dosya yukarıdan aşağı çalışır

KabaLang'de zorunlu bir başlangıç fonksiyonu yoktur; dosyadaki satırlar sırayla çalışır. İsterseniz kendiniz bir ana() yazıp çağırırsınız (konsol şablonu bunu yapar).

fonksiyon ana():
    yazdir("program başladı")
    don 0

ana()

Argüman yayılması — f(*liste)

Elinizde bir liste varsa, öğelerini tek tek yazmak yerine * ile yayabilirsiniz:

fonksiyon topla(a, b, c):
    don a + b + c

sayilar = [10, 20, 30]
dogrula(topla(*sayilar) == 60, "liste yayılması")

ikisi = [20, 30]
dogrula(topla(10, *ikisi) == 60, "konumsal + yayılma")

fonksiyon selamla(ad, soyad):
    don "Merhaba " + ad + " " + soyad

isim = ["Ayşe", "Yılmaz"]
dogrula(selamla(*isim) == "Merhaba Ayşe Yılmaz", "metin listesi yayılması")
yazdir("argüman yayılması tamam")

Liste uzunluğu çalışma anında denetlenir: topla(*[1, 2]) derlenir ama koşarken 'topla' 3 argüman bekliyor, yayılan liste 2 öğe taşıyor der. Uzun liste de hatadır — sessizce kırpılmaz.

Sınırlar (hepsi derleme anında, KabaLang iletisiyle reddedilir):

fonksiyon f(*l): — yani değişken sayıda parametre alan fonksiyon tanımlamak — henüz yoktur; parametreyi liste olarak alıp f([1, 2, 3]) diye çağırın.

Sonraki adım

3. Metin ve Türkçe kuralları